diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..820e26c58d8148a57d691309150af1b82dcd150d --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.png +*.pyc +concept_attention.egg-info +concept_attention/flux/src/flux.egg-info/PKG-INFO +*.pyc \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..abd84d74712ff3078d3a414624db15aee2aec258 --- /dev/null +++ b/README.md @@ -0,0 +1,7 @@ +--- +title: ConceptAttention +sdk: gradio +sdk_version: "5.15.0" +app_file: app.py +pinned: false +--- diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..5ae603a8b176511e00fcb081c910a45067c5b2b2 --- /dev/null +++ b/app.py @@ -0,0 +1,140 @@ +import base64 +import io + +import spaces +import gradio as gr +from PIL import Image + +from concept_attention import ConceptAttentionFluxPipeline + +concept_attention_default_args = { + "model_name": "flux-schnell", + "device": "cuda", + "layer_indices": list(range(10, 19)), + "timesteps": list(range(4)), + "num_samples": 4, + "num_inference_steps": 4 +} +IMG_SIZE = 250 + +EXAMPLES = [ + [ + "A fluffy cat sitting on a windowsill", # prompt + "cat.jpg", # image + "fur, whiskers, eyes", # words + 42, # seed + ], + # ["Mountain landscape with lake", "cat.jpg", "sky, trees, water", 123], + # ["Portrait of a young woman", "monkey.png", "face, hair, eyes", 456], +] + + +pipeline = ConceptAttentionFluxPipeline(model_name="flux-schnell", device="cuda") + + +@spaces.GPU(duration=60) +def process_inputs(prompt, input_image, word_list, seed): + prompt = prompt.strip() + if not word_list.strip(): + return None, "Please enter comma-separated words" + + concepts = [w.strip() for w in word_list.split(",")] + + if input_image is not None: + input_image = Image.fromarray(input_image) + input_image = input_image.convert("RGB") + input_image = input_image.resize((1024, 1024)) + + pipeline_output = pipeline.encode_image( + image=input_image, + concepts=concepts, + prompt=prompt, + width=1024, + height=1024, + seed=seed, + num_samples=concept_attention_default_args["num_samples"] + ) + else: + pipeline_output = pipeline.generate_image( + prompt=prompt, + concepts=concepts, + width=1024, + height=1024, + seed=seed, + timesteps=concept_attention_default_args["timesteps"], + num_inference_steps=concept_attention_default_args["num_inference_steps"], + ) + + output_image = pipeline_output.image + concept_heatmaps = pipeline_output.concept_heatmaps + + html_elements = [] + for concept, heatmap in zip(concepts, concept_heatmaps): + img = heatmap.resize((IMG_SIZE, IMG_SIZE), resample=Image.NEAREST) + buffered = io.BytesIO() + img.save(buffered, format="PNG") + img_str = base64.b64encode(buffered.getvalue()).decode() + + html = f""" +
+

{concept}

+ +
+ """ + html_elements.append(html) + + combined_html = "
" + "".join(html_elements) + "
" + return output_image, combined_html + + +with gr.Blocks( + css=""" + .container { max-width: 1200px; margin: 0 auto; padding: 20px; } + .title { text-align: center; margin-bottom: 10px; } + .authors { text-align: center; margin-bottom: 20px; } + .affiliations { text-align: center; color: #666; margin-bottom: 40px; } + .content { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; } + .section { border: 2px solid #ddd; border-radius: 10px; padding: 20px; } +""" +) as demo: + with gr.Column(elem_classes="container"): + gr.Markdown("# ConceptAttention: Diffusion Transformers Learn Highly Interpretable Features", elem_classes="title") + gr.Markdown("**Alec Helbling**¹, **Tuna Meral**², **Ben Hoover**¹³, **Pinar Yanardag**², **Duen Horng (Polo) Chau**¹", elem_classes="authors") + gr.Markdown("¹Georgia Tech · ²Virginia Tech · ³IBM Research", elem_classes="affiliations") + + with gr.Row(elem_classes="content"): + with gr.Column(elem_classes="section"): + gr.Markdown("### Input") + prompt = gr.Textbox(label="Enter your prompt") + words = gr.Textbox(label="Enter words (comma-separated)") + seed = gr.Slider(minimum=0, maximum=10000, step=1, label="Seed", value=42) + gr.HTML("

Or

") + image_input = gr.Image(type="numpy", label="Upload image (optional)") + + with gr.Column(elem_classes="section"): + gr.Markdown("### Output") + output_image = gr.Image(type="numpy", label="Output image") + + with gr.Row(): + submit_btn = gr.Button("Process") + + with gr.Row(elem_classes="section"): + saliency_display = gr.HTML(label="Saliency Maps") + + submit_btn.click( + fn=process_inputs, + inputs=[prompt, image_input, words, seed], outputs=[output_image, saliency_display] + ) + + gr.Examples(examples=EXAMPLES, inputs=[prompt, image_input, words, seed], outputs=[output_image, saliency_display], fn=process_inputs, cache_examples=False) + +if __name__ == "__main__": + demo.launch( + share=True, + server_name="0.0.0.0", + inbrowser=True, + # share=False, + server_port=6754, + quiet=True, + max_threads=1 + ) diff --git a/concept_attention/__init__.py b/concept_attention/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34fa78770ffac3212003d0f1f063a26e0ce36e9a --- /dev/null +++ b/concept_attention/__init__.py @@ -0,0 +1,2 @@ + +from concept_attention.concept_attention_pipeline import ConceptAttentionFluxPipeline \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/__init__.py b/concept_attention/binary_segmentation_baselines/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/__init__.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c82dc49dbbbdaddf4c02760d85212047f776bcec Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/__init__.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/chefer_clip_vit_baselines.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/chefer_clip_vit_baselines.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a3a6302f86a7c4240fc8c8bc2fe59e553577ba9 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/chefer_clip_vit_baselines.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/clip_text_span_baseline.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/clip_text_span_baseline.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f842baa923c549d60b001e01dd6a4d2f0839281e Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/clip_text_span_baseline.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/daam.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/daam.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bf3ab902678fdfc05713de34fd77f389536e307 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/daam.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/daam_sd2.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/daam_sd2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..430188dcb2acb97eb7b4d60bbec9b727b30bdd9c Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/daam_sd2.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/daam_sdxl.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/daam_sdxl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18992a4cf8b907cb0b0a7aa57d8aa6e6e1d55f29 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/daam_sdxl.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/dino.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/dino.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3357fe8e9463c20492c3990524370e67224a7c16 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/dino.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/raw_cross_attention.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/raw_cross_attention.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45111b26b5c7cc9ba8bf7826530354371360cd65 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/raw_cross_attention.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/raw_output_space.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/raw_output_space.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d91b4de5e05599d40e51f5f8a9d8c34d473017b Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/raw_output_space.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/__pycache__/raw_value_space.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/__pycache__/raw_value_space.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3229c3df1993ba93d3bfb6ba7cdacbfe4c8bfb0 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/__pycache__/raw_value_space.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_clip_vit_baselines.py b/concept_attention/binary_segmentation_baselines/chefer_clip_vit_baselines.py new file mode 100644 index 0000000000000000000000000000000000000000..81fa084e8bb4418c3c17f851c780c3a14743c777 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_clip_vit_baselines.py @@ -0,0 +1,272 @@ +""" + This is just a wrapper around the various baselines implemented in the + Chefer et. al. Transformer Explainability repository. + + Implements + - CheferLRPSegmentationModel + - CheferRolloutSegmentationModel + - CheferLastLayerAttentionSegmentationModel + - CheferAttentionGradCAMSegmentationModel + - CheferTransformerAttributionSegmentationModel + - CheferFullLRPSegmentationModel + - CheferLastLayerLRPSegmentationModel +""" + +# # segmentation test for the rollout baseline +# if args.method == 'rollout': +# Res = baselines.generate_rollout(image.cuda(), start_layer=1).reshape(batch_size, 1, 14, 14) + +# # segmentation test for the LRP baseline (this is full LRP, not partial) +# elif args.method == 'full_lrp': +# Res = orig_lrp.generate_LRP(image.cuda(), method="full").reshape(batch_size, 1, 224, 224) + +# # segmentation test for our method +# elif args.method == 'transformer_attribution': +# Res = lrp.generate_LRP(image.cuda(), start_layer=1, method="transformer_attribution").reshape(batch_size, 1, 14, 14) + +# # segmentation test for the partial LRP baseline (last attn layer) +# elif args.method == 'lrp_last_layer': +# Res = orig_lrp.generate_LRP(image.cuda(), method="last_layer", is_ablation=args.is_ablation)\ +# .reshape(batch_size, 1, 14, 14) + +# # segmentation test for the raw attention baseline (last attn layer) +# elif args.method == 'attn_last_layer': +# Res = orig_lrp.generate_LRP(image.cuda(), method="last_layer_attn", is_ablation=args.is_ablation)\ +# .reshape(batch_size, 1, 14, 14) + +# # segmentation test for the GradCam baseline (last attn layer) +# elif args.method == 'attn_gradcam': +# Res = baselines.generate_cam_attn(image.cuda()).reshape(batch_size, 1, 14, 14) + +# if args.method != 'full_lrp': +# # interpolate to full image size (224,224) +# Res = torch.nn.functional.interpolate(Res, scale_factor=16, mode='bilinear').cuda() + +import torch +import PIL + +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_explanation_generator import LRP +from concept_attention.segmentation import SegmentationAbstractClass +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_explanation_generator import Baselines, LRP +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_new import vit_base_patch16_224 +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_LRP import vit_base_patch16_224 as vit_LRP +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_orig_LRP import vit_base_patch16_224 as vit_orig_LRP + + +# # Model +# model = vit_base_patch16_224(pretrained=True).cuda() +# baselines = Baselines(model) + +# # LRP +# model_LRP = vit_LRP(pretrained=True).cuda() +# model_LRP.eval() +# lrp = LRP(model_LRP) + +# # orig LRP +# model_orig_LRP = vit_orig_LRP(pretrained=True).cuda() +# model_orig_LRP.eval() +# orig_lrp = LRP(model_orig_LRP) + +# model.eval() + +class CheferLRPSegmentationModel(SegmentationAbstractClass): + + def __init__( + self, + device: str = "cuda", + width: int = 224, + height: int = 224, + ): + """ + Initialize the segmentation model. + """ + super(CheferLRPSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + # Load the LRP model + model_orig_LRP = vit_orig_LRP(pretrained=True).to(self.device) + model_orig_LRP.eval() + self.orig_lrp = LRP(model_orig_LRP) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + """ + Takes a real image and generates a concept segmentation map + it by adding noise and running the DiT on it. + """ + if len(image.shape) == 3: + image = image.unsqueeze(0) + + prediction_map = self.orig_lrp.generate_LRP( + image.to(self.device), + method="full" + ) + prediction_map = prediction_map.unsqueeze(0) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + +class CheferRolloutSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferRolloutSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model = vit_base_patch16_224(pretrained=True).to(device) + self.baselines = Baselines(model) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + prediction_map = self.baselines.generate_rollout( + image.to(self.device), start_layer=1 + ).reshape(1, 1, 14, 14) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + + +class CheferLastLayerAttentionSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferLastLayerAttentionSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model_orig_LRP = vit_orig_LRP(pretrained=True).to(device) + model_orig_LRP.eval() + self.orig_lrp = LRP(model_orig_LRP) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + + prediction_map = self.orig_lrp.generate_LRP( + image.to(self.device), method="last_layer_attn" + ).reshape(1, 1, 14, 14) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + + +class CheferAttentionGradCAMSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferAttentionGradCAMSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model = vit_base_patch16_224(pretrained=True).to(device) + self.baselines = Baselines(model) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + prediction_map = self.baselines.generate_cam_attn( + image.to(self.device) + ).reshape(1, 1, 14, 14) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + + +class CheferTransformerAttributionSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferTransformerAttributionSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model_LRP = vit_LRP(pretrained=True).to(device) + model_LRP.eval() + self.lrp = LRP(model_LRP) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + prediction_map = self.lrp.generate_LRP( + image.to(self.device), start_layer=1, method="transformer_attribution" + ).reshape(1, 1, 14, 14) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + + +class CheferFullLRPSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferFullLRPSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model_LRP = vit_LRP(pretrained=True).to(device) + model_LRP.eval() + self.lrp = LRP(model_LRP) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + prediction_map = self.lrp.generate_LRP( + image.to(self.device), method="full" + ).reshape(1, 1, 224, 224) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None + + +class CheferLastLayerLRPSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device: str = "cuda", width: int = 224, height: int = 224): + super(CheferLastLayerLRPSegmentationModel, self).__init__() + self.width = width + self.height = height + self.device = device + model_LRP = vit_LRP(pretrained=True).to(device) + model_LRP.eval() + self.lrp = LRP(model_LRP) + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + if len(image.shape) == 3: + image = image.unsqueeze(0) + prediction_map = self.lrp.generate_LRP( + image.to(self.device), method="last_layer" + ).reshape(1, 1, 14, 14) + # Rescale the prediction map to 64x64 + prediction_map = torch.nn.functional.interpolate( + prediction_map, + size=(self.width, self.height), + mode="nearest" + ).reshape(1, self.width, self.height) + + return prediction_map, None \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_LRP.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_LRP.py new file mode 100644 index 0000000000000000000000000000000000000000..131edfcabca9b2f7a5872e9f5db6dc34ec0cf67a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_LRP.py @@ -0,0 +1,437 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +import torch +import torch.nn as nn +from einops import rearrange + +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.modules.layers_ours import * +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.helpers import load_pretrained +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.weight_init import trunc_normal_ +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.layer_helpers import to_2tuple + + +def _cfg(url='', **kwargs): + return { + 'url': url, + 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None, + 'crop_pct': .9, 'interpolation': 'bicubic', + 'first_conv': 'patch_embed.proj', 'classifier': 'head', + **kwargs + } + + +default_cfgs = { + # patch models + 'vit_small_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth', + ), + 'vit_base_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), + ), + 'vit_large_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), +} + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = torch.eye(num_tokens).expand(batch_size, num_tokens, num_tokens).to(all_layer_matrices[0].device) + all_layer_matrices = [all_layer_matrices[i] + eye for i in range(len(all_layer_matrices))] + # all_layer_matrices = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + # for i in range(len(all_layer_matrices))] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer+1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = Linear(in_features, hidden_features) + self.act = GELU() + self.fc2 = Linear(hidden_features, out_features) + self.drop = Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + def relprop(self, cam, **kwargs): + cam = self.drop.relprop(cam, **kwargs) + cam = self.fc2.relprop(cam, **kwargs) + cam = self.act.relprop(cam, **kwargs) + cam = self.fc1.relprop(cam, **kwargs) + return cam + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False,attn_drop=0., proj_drop=0.): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim ** -0.5 + + # A = Q*K^T + self.matmul1 = einsum('bhid,bhjd->bhij') + # attn = A*V + self.matmul2 = einsum('bhij,bhjd->bhid') + + self.qkv = Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = Dropout(attn_drop) + self.proj = Linear(dim, dim) + self.proj_drop = Dropout(proj_drop) + self.softmax = Softmax(dim=-1) + + self.attn_cam = None + self.attn = None + self.v = None + self.v_cam = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def get_v(self): + return self.v + + def save_v(self, v): + self.v = v + + def save_v_cam(self, cam): + self.v_cam = cam + + def get_v_cam(self): + return self.v_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def forward(self, x): + b, n, _, h = *x.shape, self.num_heads + qkv = self.qkv(x) + q, k, v = rearrange(qkv, 'b n (qkv h d) -> qkv b h n d', qkv=3, h=h) + + self.save_v(v) + + dots = self.matmul1([q, k]) * self.scale + + attn = self.softmax(dots) + attn = self.attn_drop(attn) + + self.save_attn(attn) + attn.register_hook(self.save_attn_gradients) + + out = self.matmul2([attn, v]) + out = rearrange(out, 'b h n d -> b n (h d)') + + out = self.proj(out) + out = self.proj_drop(out) + return out + + def relprop(self, cam, **kwargs): + cam = self.proj_drop.relprop(cam, **kwargs) + cam = self.proj.relprop(cam, **kwargs) + cam = rearrange(cam, 'b n (h d) -> b h n d', h=self.num_heads) + + # attn = A*V + (cam1, cam_v)= self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam_v /= 2 + + self.save_v_cam(cam_v) + self.save_attn_cam(cam1) + + cam1 = self.attn_drop.relprop(cam1, **kwargs) + cam1 = self.softmax.relprop(cam1, **kwargs) + + # A = Q*K^T + (cam_q, cam_k) = self.matmul1.relprop(cam1, **kwargs) + cam_q /= 2 + cam_k /= 2 + + cam_qkv = rearrange([cam_q, cam_k, cam_v], 'qkv b h n d -> b n (qkv h d)', qkv=3, h=self.num_heads) + + return self.qkv.relprop(cam_qkv, **kwargs) + + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0.): + super().__init__() + self.norm1 = LayerNorm(dim, eps=1e-6) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) + self.norm2 = LayerNorm(dim, eps=1e-6) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, drop=drop) + + self.add1 = Add() + self.add2 = Add() + self.clone1 = Clone() + self.clone2 = Clone() + + def forward(self, x): + x1, x2 = self.clone1(x, 2) + x = self.add1([x1, self.attn(self.norm1(x2))]) + x1, x2 = self.clone2(x, 2) + x = self.add2([x1, self.mlp(self.norm2(x2))]) + return x + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.add2.relprop(cam, **kwargs) + cam2 = self.mlp.relprop(cam2, **kwargs) + cam2 = self.norm2.relprop(cam2, **kwargs) + cam = self.clone2.relprop((cam1, cam2), **kwargs) + + (cam1, cam2) = self.add1.relprop(cam, **kwargs) + cam2 = self.attn.relprop(cam2, **kwargs) + cam2 = self.norm1.relprop(cam2, **kwargs) + cam = self.clone1.relprop((cam1, cam2), **kwargs) + return cam + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + def relprop(self, cam, **kwargs): + cam = cam.transpose(1,2) + cam = cam.reshape(cam.shape[0], cam.shape[1], + (self.img_size[0] // self.patch_size[0]), (self.img_size[1] // self.patch_size[1])) + return self.proj.relprop(cam, **kwargs) + + +class VisionTransformer(nn.Module): + """ Vision Transformer with support for patch or hybrid CNN input stage + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, mlp_head=False, drop_rate=0., attn_drop_rate=0.): + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, + drop=drop_rate, attn_drop=attn_drop_rate) + for i in range(depth)]) + + self.norm = LayerNorm(embed_dim) + if mlp_head: + # paper diagram suggests 'MLP head', but results in 4M extra parameters vs paper + self.head = Mlp(embed_dim, int(embed_dim * mlp_ratio), num_classes) + else: + # with a single Linear layer as head, the param count within rounding of paper + self.head = Linear(embed_dim, num_classes) + + # FIXME not quite sure what the proper weight init is supposed to be, + # normal / trunc normal w/ std == .02 similar to other Bert like transformers + trunc_normal_(self.pos_embed, std=.02) # embeddings same as weights? + trunc_normal_(self.cls_token, std=.02) + self.apply(self._init_weights) + + self.pool = IndexSelect() + self.add = Add() + + self.inp_grad = None + + def save_inp_grad(self,grad): + self.inp_grad = grad + + def get_inp_grad(self): + return self.inp_grad + + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @property + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def forward(self, x): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand(B, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = self.add([x, self.pos_embed]) + + x.register_hook(self.save_inp_grad) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + x = self.pool(x, dim=1, indices=torch.tensor(0, device=x.device)) + x = x.squeeze(1) + x = self.head(x) + return x + + def relprop(self, cam=None,method="transformer_attribution", is_ablation=False, start_layer=0, **kwargs): + # print(kwargs) + # print("conservation 1", cam.sum()) + cam = self.head.relprop(cam, **kwargs) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + cam = self.norm.relprop(cam, **kwargs) + for blk in reversed(self.blocks): + cam = blk.relprop(cam, **kwargs) + + # print("conservation 2", cam.sum()) + # print("min", cam.min()) + + if method == "full": + (cam, _) = self.add.relprop(cam, **kwargs) + cam = cam[:, 1:] + cam = self.patch_embed.relprop(cam, **kwargs) + # sum on channels + cam = cam.sum(dim=1) + return cam + + elif method == "rollout": + # cam rollout + attn_cams = [] + for blk in self.blocks: + attn_heads = blk.attn.get_attn_cam().clamp(min=0) + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + attn_cams.append(avg_heads) + cam = compute_rollout_attention(attn_cams, start_layer=start_layer) + cam = cam[:, 0, 1:] + return cam + + # our method, method name grad is legacy + elif method == "transformer_attribution" or method == "grad": + cams = [] + for blk in self.blocks: + grad = blk.attn.get_attn_gradients() + cam = blk.attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cams.append(cam.unsqueeze(0)) + rollout = compute_rollout_attention(cams, start_layer=start_layer) + cam = rollout[:, 0, 1:] + return cam + + elif method == "last_layer": + cam = self.blocks[-1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[-1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "last_layer_attn": + cam = self.blocks[-1].attn.get_attn() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "second_layer": + cam = self.blocks[1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + +def _conv_filter(state_dict, patch_size=16): + """ convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if 'patch_embed.proj.weight' in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, qkv_bias=True, **kwargs) + model.default_cfg = default_cfgs['vit_base_patch16_224'] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3), filter_fn=_conv_filter) + return model + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=1024, depth=24, num_heads=16, mlp_ratio=4, qkv_bias=True, **kwargs) + model.default_cfg = default_cfgs['vit_large_patch16_224'] + if pretrained: + load_pretrained(model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3)) + return model + +def deit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, qkv_bias=True, **kwargs) + model.default_cfg = _cfg() + if pretrained: + checkpoint = torch.hub.load_state_dict_from_url( + url="https://dl.fbaipublicfiles.com/deit/deit_base_patch16_224-b5f2ef4d.pth", + map_location="cpu", check_hash=True + ) + model.load_state_dict(checkpoint["model"]) + return model \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_explanation_generator.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_explanation_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..d5302c6e649d5007cbb13359f88e1043a86fd576 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_explanation_generator.py @@ -0,0 +1,83 @@ +import argparse +import torch +import numpy as np +from numpy import * + +# compute rollout between attention layers +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration- code adapted from https://github.com/samiraabnar/attention_flow + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = torch.eye(num_tokens).expand(batch_size, num_tokens, num_tokens).to(all_layer_matrices[0].device) + all_layer_matrices = [all_layer_matrices[i] + eye for i in range(len(all_layer_matrices))] + matrices_aug = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + for i in range(len(all_layer_matrices))] + joint_attention = matrices_aug[start_layer] + for i in range(start_layer+1, len(matrices_aug)): + joint_attention = matrices_aug[i].bmm(joint_attention) + return joint_attention + +class LRP: + def __init__(self, model): + self.model = model + self.model.eval() + + def generate_LRP(self, input, index=None, method="transformer_attribution", is_ablation=False, start_layer=0): + output = self.model(input) + kwargs = {"alpha": 1} + if index == None: + index = np.argmax(output.cpu().data.numpy(), axis=-1) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0, index] = 1 + one_hot_vector = one_hot + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.to(input.device) * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + + return self.model.relprop(torch.tensor(one_hot_vector).to(input.device), method=method, is_ablation=is_ablation, + start_layer=start_layer, **kwargs) + + + +class Baselines: + def __init__(self, model): + self.model = model + self.model.eval() + + def generate_cam_attn(self, input, index=None): + output = self.model(input, register_hook=True) + if index == None: + index = np.argmax(output.cpu().data.numpy()) + + one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32) + one_hot[0][index] = 1 + one_hot = torch.from_numpy(one_hot).requires_grad_(True) + one_hot = torch.sum(one_hot.to(output.device) * output) + + self.model.zero_grad() + one_hot.backward(retain_graph=True) + #################### attn + grad = self.model.blocks[-1].attn.get_attn_gradients() + cam = self.model.blocks[-1].attn.get_attention_map() + cam = cam[0, :, 0, 1:].reshape(-1, 14, 14) + grad = grad[0, :, 0, 1:].reshape(-1, 14, 14) + grad = grad.mean(dim=[1, 2], keepdim=True) + cam = (cam * grad).mean(0).clamp(min=0) + cam = (cam - cam.min()) / (cam.max() - cam.min()) + + return cam + #################### attn + + def generate_rollout(self, input, start_layer=0): + self.model(input) + blocks = self.model.blocks + all_layer_attentions = [] + for blk in blocks: + attn_heads = blk.attn.get_attention_map() + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + all_layer_attentions.append(avg_heads) + rollout = compute_rollout_attention(all_layer_attentions, start_layer=start_layer) + return rollout[:,0, 1:] diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_new.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_new.py new file mode 100644 index 0000000000000000000000000000000000000000..c884599b1f73743039e0e955fc66ec64811b17d3 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_new.py @@ -0,0 +1,238 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +import torch +import torch.nn as nn +from functools import partial +from einops import rearrange + +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.helpers import load_pretrained +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.weight_init import trunc_normal_ +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.layer_helpers import to_2tuple + + +def _cfg(url='', **kwargs): + return { + 'url': url, + 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None, + 'crop_pct': .9, 'interpolation': 'bicubic', + 'first_conv': 'patch_embed.proj', 'classifier': 'head', + **kwargs + } + + +default_cfgs = { + # patch models + 'vit_small_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth', + ), + 'vit_base_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), + ), + 'vit_large_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), +} + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False,attn_drop=0., proj_drop=0.): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim ** -0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + self.attn_gradients = None + self.attention_map = None + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def save_attention_map(self, attention_map): + self.attention_map = attention_map + + def get_attention_map(self): + return self.attention_map + + def forward(self, x, register_hook=False): + b, n, _, h = *x.shape, self.num_heads + + # self.save_output(x) + # x.register_hook(self.save_output_grad) + + qkv = self.qkv(x) + q, k, v = rearrange(qkv, 'b n (qkv h d) -> qkv b h n d', qkv = 3, h = h) + + dots = torch.einsum('bhid,bhjd->bhij', q, k) * self.scale + + attn = dots.softmax(dim=-1) + attn = self.attn_drop(attn) + + out = torch.einsum('bhij,bhjd->bhid', attn, v) + + self.save_attention_map(attn) + if register_hook: + attn.register_hook(self.save_attn_gradients) + + out = rearrange(out, 'b h n d -> b n (h d)') + out = self.proj(out) + out = self.proj_drop(out) + return out + + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + def forward(self, x, register_hook=False): + x = x + self.attn(self.norm1(x), register_hook=register_hook) + x = x + self.mlp(self.norm2(x)) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + +class VisionTransformer(nn.Module): + """ Vision Transformer + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, drop_rate=0., attn_drop_rate=0., norm_layer=nn.LayerNorm): + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.pos_drop = nn.Dropout(p=drop_rate) + + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, + drop=drop_rate, attn_drop=attn_drop_rate, norm_layer=norm_layer) + for i in range(depth)]) + self.norm = norm_layer(embed_dim) + + # Classifier head + self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + trunc_normal_(self.pos_embed, std=.02) + trunc_normal_(self.cls_token, std=.02) + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def forward(self, x, register_hook=False): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand(B, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = x + self.pos_embed + x = self.pos_drop(x) + + for blk in self.blocks: + x = blk(x, register_hook=register_hook) + + x = self.norm(x) + x = x[:, 0] + x = self.head(x) + return x + + +def _conv_filter(state_dict, patch_size=16): + """ convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if 'patch_embed.proj.weight' in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, qkv_bias=True, + norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs) + model.default_cfg = default_cfgs['vit_base_patch16_224'] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3), filter_fn=_conv_filter) + return model + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=1024, depth=24, num_heads=16, mlp_ratio=4, qkv_bias=True, + norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs) + model.default_cfg = default_cfgs['vit_large_patch16_224'] + if pretrained: + load_pretrained(model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3)) + return model diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_orig_LRP.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_orig_LRP.py new file mode 100644 index 0000000000000000000000000000000000000000..044757466c47a567fef29a46021623ff62a12c6b --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/ViT_orig_LRP.py @@ -0,0 +1,425 @@ +""" Vision Transformer (ViT) in PyTorch +Hacked together by / Copyright 2020 Ross Wightman +""" +import torch +import torch.nn as nn +from einops import rearrange + +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.modules.layers_lrp import * +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.helpers import load_pretrained +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.weight_init import trunc_normal_ +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.layer_helpers import to_2tuple + + +def _cfg(url='', **kwargs): + return { + 'url': url, + 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None, + 'crop_pct': .9, 'interpolation': 'bicubic', + 'first_conv': 'patch_embed.proj', 'classifier': 'head', + **kwargs + } + + +default_cfgs = { + # patch models + 'vit_small_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/vit_small_p16_224-15ec54c9.pth', + ), + 'vit_base_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_base_p16_224-80ecf9dd.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), + ), + 'vit_large_patch16_224': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-vitjx/jx_vit_large_p16_224-4ee7a4dc.pth', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), +} + +def compute_rollout_attention(all_layer_matrices, start_layer=0): + # adding residual consideration + num_tokens = all_layer_matrices[0].shape[1] + batch_size = all_layer_matrices[0].shape[0] + eye = torch.eye(num_tokens).expand(batch_size, num_tokens, num_tokens).to(all_layer_matrices[0].device) + all_layer_matrices = [all_layer_matrices[i] + eye for i in range(len(all_layer_matrices))] + # all_layer_matrices = [all_layer_matrices[i] / all_layer_matrices[i].sum(dim=-1, keepdim=True) + # for i in range(len(all_layer_matrices))] + joint_attention = all_layer_matrices[start_layer] + for i in range(start_layer+1, len(all_layer_matrices)): + joint_attention = all_layer_matrices[i].bmm(joint_attention) + return joint_attention + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = Linear(in_features, hidden_features) + self.act = GELU() + self.fc2 = Linear(hidden_features, out_features) + self.drop = Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + def relprop(self, cam, **kwargs): + cam = self.drop.relprop(cam, **kwargs) + cam = self.fc2.relprop(cam, **kwargs) + cam = self.act.relprop(cam, **kwargs) + cam = self.fc1.relprop(cam, **kwargs) + return cam + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False,attn_drop=0., proj_drop=0.): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights + self.scale = head_dim ** -0.5 + + # A = Q*K^T + self.matmul1 = einsum('bhid,bhjd->bhij') + # attn = A*V + self.matmul2 = einsum('bhij,bhjd->bhid') + + self.qkv = Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = Dropout(attn_drop) + self.proj = Linear(dim, dim) + self.proj_drop = Dropout(proj_drop) + self.softmax = Softmax(dim=-1) + + self.attn_cam = None + self.attn = None + self.v = None + self.v_cam = None + self.attn_gradients = None + + def get_attn(self): + return self.attn + + def save_attn(self, attn): + self.attn = attn + + def save_attn_cam(self, cam): + self.attn_cam = cam + + def get_attn_cam(self): + return self.attn_cam + + def get_v(self): + return self.v + + def save_v(self, v): + self.v = v + + def save_v_cam(self, cam): + self.v_cam = cam + + def get_v_cam(self): + return self.v_cam + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def forward(self, x): + b, n, _, h = *x.shape, self.num_heads + qkv = self.qkv(x) + q, k, v = rearrange(qkv, 'b n (qkv h d) -> qkv b h n d', qkv=3, h=h) + + self.save_v(v) + + dots = self.matmul1([q, k]) * self.scale + + attn = self.softmax(dots) + attn = self.attn_drop(attn) + + self.save_attn(attn) + attn.register_hook(self.save_attn_gradients) + + out = self.matmul2([attn, v]) + out = rearrange(out, 'b h n d -> b n (h d)') + + out = self.proj(out) + out = self.proj_drop(out) + return out + + def relprop(self, cam, **kwargs): + cam = self.proj_drop.relprop(cam, **kwargs) + cam = self.proj.relprop(cam, **kwargs) + cam = rearrange(cam, 'b n (h d) -> b h n d', h=self.num_heads) + + # attn = A*V + (cam1, cam_v)= self.matmul2.relprop(cam, **kwargs) + cam1 /= 2 + cam_v /= 2 + + self.save_v_cam(cam_v) + self.save_attn_cam(cam1) + + cam1 = self.attn_drop.relprop(cam1, **kwargs) + cam1 = self.softmax.relprop(cam1, **kwargs) + + # A = Q*K^T + (cam_q, cam_k) = self.matmul1.relprop(cam1, **kwargs) + cam_q /= 2 + cam_k /= 2 + + cam_qkv = rearrange([cam_q, cam_k, cam_v], 'qkv b h n d -> b n (qkv h d)', qkv=3, h=self.num_heads) + + return self.qkv.relprop(cam_qkv, **kwargs) + + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0.): + super().__init__() + self.norm1 = LayerNorm(dim, eps=1e-6) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) + self.norm2 = LayerNorm(dim, eps=1e-6) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, drop=drop) + + self.add1 = Add() + self.add2 = Add() + self.clone1 = Clone() + self.clone2 = Clone() + + def forward(self, x): + x1, x2 = self.clone1(x, 2) + x = self.add1([x1, self.attn(self.norm1(x2))]) + x1, x2 = self.clone2(x, 2) + x = self.add2([x1, self.mlp(self.norm2(x2))]) + return x + + def relprop(self, cam, **kwargs): + (cam1, cam2) = self.add2.relprop(cam, **kwargs) + cam2 = self.mlp.relprop(cam2, **kwargs) + cam2 = self.norm2.relprop(cam2, **kwargs) + cam = self.clone2.relprop((cam1, cam2), **kwargs) + + (cam1, cam2) = self.add1.relprop(cam, **kwargs) + cam2 = self.attn.relprop(cam2, **kwargs) + cam2 = self.norm1.relprop(cam2, **kwargs) + cam = self.clone1.relprop((cam1, cam2), **kwargs) + return cam + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + def relprop(self, cam, **kwargs): + cam = cam.transpose(1,2) + cam = cam.reshape(cam.shape[0], cam.shape[1], + (self.img_size[0] // self.patch_size[0]), (self.img_size[1] // self.patch_size[1])) + return self.proj.relprop(cam, **kwargs) + + +class VisionTransformer(nn.Module): + """ Vision Transformer with support for patch or hybrid CNN input stage + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, mlp_head=False, drop_rate=0., attn_drop_rate=0.): + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, + drop=drop_rate, attn_drop=attn_drop_rate) + for i in range(depth)]) + + self.norm = LayerNorm(embed_dim) + if mlp_head: + # paper diagram suggests 'MLP head', but results in 4M extra parameters vs paper + self.head = Mlp(embed_dim, int(embed_dim * mlp_ratio), num_classes) + else: + # with a single Linear layer as head, the param count within rounding of paper + self.head = Linear(embed_dim, num_classes) + + # FIXME not quite sure what the proper weight init is supposed to be, + # normal / trunc normal w/ std == .02 similar to other Bert like transformers + trunc_normal_(self.pos_embed, std=.02) # embeddings same as weights? + trunc_normal_(self.cls_token, std=.02) + self.apply(self._init_weights) + + self.pool = IndexSelect() + self.add = Add() + + self.inp_grad = None + + def save_inp_grad(self,grad): + self.inp_grad = grad + + def get_inp_grad(self): + return self.inp_grad + + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @property + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def forward(self, x): + B = x.shape[0] + x = self.patch_embed(x) + + cls_tokens = self.cls_token.expand(B, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + x = self.add([x, self.pos_embed]) + + x.register_hook(self.save_inp_grad) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + x = self.pool(x, dim=1, indices=torch.tensor(0, device=x.device)) + x = x.squeeze(1) + x = self.head(x) + return x + + def relprop(self, cam=None,method="grad", is_ablation=False, start_layer=0, **kwargs): + # print(kwargs) + # print("conservation 1", cam.sum()) + cam = self.head.relprop(cam, **kwargs) + cam = cam.unsqueeze(1) + cam = self.pool.relprop(cam, **kwargs) + cam = self.norm.relprop(cam, **kwargs) + for blk in reversed(self.blocks): + cam = blk.relprop(cam, **kwargs) + + # print("conservation 2", cam.sum()) + # print("min", cam.min()) + + if method == "full": + (cam, _) = self.add.relprop(cam, **kwargs) + cam = cam[:, 1:] + cam = self.patch_embed.relprop(cam, **kwargs) + # sum on channels + cam = cam.sum(dim=1) + return cam + + elif method == "rollout": + # cam rollout + attn_cams = [] + for blk in self.blocks: + attn_heads = blk.attn.get_attn_cam().clamp(min=0) + avg_heads = (attn_heads.sum(dim=1) / attn_heads.shape[1]).detach() + attn_cams.append(avg_heads) + cam = compute_rollout_attention(attn_cams, start_layer=start_layer) + cam = cam[:, 0, 1:] + return cam + + elif method == "grad": + cams = [] + for blk in self.blocks: + grad = blk.attn.get_attn_gradients() + cam = blk.attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cams.append(cam.unsqueeze(0)) + rollout = compute_rollout_attention(cams, start_layer=start_layer) + cam = rollout[:, 0, 1:] + return cam + + elif method == "last_layer": + cam = self.blocks[-1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[-1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "last_layer_attn": + cam = self.blocks[-1].attn.get_attn() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + elif method == "second_layer": + cam = self.blocks[1].attn.get_attn_cam() + cam = cam[0].reshape(-1, cam.shape[-1], cam.shape[-1]) + if is_ablation: + grad = self.blocks[1].attn.get_attn_gradients() + grad = grad[0].reshape(-1, grad.shape[-1], grad.shape[-1]) + cam = grad * cam + cam = cam.clamp(min=0).mean(dim=0) + cam = cam[0, 1:] + return cam + + +def _conv_filter(state_dict, patch_size=16): + """ convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if 'patch_embed.proj.weight' in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + return out_dict + + +def vit_base_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, qkv_bias=True, **kwargs) + model.default_cfg = default_cfgs['vit_base_patch16_224'] + if pretrained: + load_pretrained( + model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3), filter_fn=_conv_filter) + return model + +def vit_large_patch16_224(pretrained=False, **kwargs): + model = VisionTransformer( + patch_size=16, embed_dim=1024, depth=24, num_heads=16, mlp_ratio=4, qkv_bias=True, **kwargs) + model.default_cfg = default_cfgs['vit_large_patch16_224'] + if pretrained: + load_pretrained(model, num_classes=model.num_classes, in_chans=kwargs.get('in_chans', 3)) + return model \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_LRP.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_LRP.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00c3fd84b6018eba725203f6b8513443c9cd3be3 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_LRP.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_explanation_generator.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_explanation_generator.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdd2469a415f816a66786591cbd3f6cd99defb19 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_explanation_generator.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_new.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_new.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..054f4400330a600c90651e5a2ca98d317d11d213 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_new.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_orig_LRP.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_orig_LRP.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db084edde44b05bc30902b9167dc5602063cecca Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/ViT_orig_LRP.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/helpers.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/helpers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef3030cd3a8c7a06117cea8deb798eed692c6ab5 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/helpers.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/layer_helpers.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/layer_helpers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..491d4c1090c95c9addcc5015bd01fe73341e88c1 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/layer_helpers.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/weight_init.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/weight_init.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..780f0290e829c923cf78a553a99a65630d6ec2ba Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/__pycache__/weight_init.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/VOC.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/VOC.py new file mode 100644 index 0000000000000000000000000000000000000000..a33f45c0f65ec8be241f470add2991a06caade24 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/VOC.py @@ -0,0 +1,395 @@ +import os +import tarfile +import torch +import torch.utils.data as data +import numpy as np +import h5py + +from PIL import Image +from scipy import io +from torchvision.datasets.utils import download_url + +DATASET_YEAR_DICT = { + '2012': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar', + 'filename': 'VOCtrainval_11-May-2012.tar', + 'md5': '6cd6e144f989b92b3379bac3b3de84fd', + 'base_dir': 'VOCdevkit/VOC2012' + }, + '2011': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2011/VOCtrainval_25-May-2011.tar', + 'filename': 'VOCtrainval_25-May-2011.tar', + 'md5': '6c3384ef61512963050cb5d687e5bf1e', + 'base_dir': 'TrainVal/VOCdevkit/VOC2011' + }, + '2010': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar', + 'filename': 'VOCtrainval_03-May-2010.tar', + 'md5': 'da459979d0c395079b5c75ee67908abb', + 'base_dir': 'VOCdevkit/VOC2010' + }, + '2009': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2009/VOCtrainval_11-May-2009.tar', + 'filename': 'VOCtrainval_11-May-2009.tar', + 'md5': '59065e4b188729180974ef6572f6a212', + 'base_dir': 'VOCdevkit/VOC2009' + }, + '2008': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2008/VOCtrainval_14-Jul-2008.tar', + 'filename': 'VOCtrainval_11-May-2012.tar', + 'md5': '2629fa636546599198acfcfbfcf1904a', + 'base_dir': 'VOCdevkit/VOC2008' + }, + '2007': { + 'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar', + 'filename': 'VOCtrainval_06-Nov-2007.tar', + 'md5': 'c52e279531787c972589f7e41ab4ae64', + 'base_dir': 'VOCdevkit/VOC2007' + } +} + + +class VOCSegmentation(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + """ + + CLASSES = 20 + # CLASSES_NAMES = [ + # "background", 'airplane', 'bicycle', 'bird', 'boat', 'bottle', + # 'bus', 'car', 'cat', 'chair', 'cow', 'table', 'dog', 'horse', + # 'motorcycle', 'person', 'pot', 'sheep', 'sofa', 'train', + # 'monitor' + # # 'ambigious' + # ] + CLASSES_NAMES = [ + "background", 'plane', 'bike', 'bird', 'boat', 'bottle', + 'bus', 'car', 'cat', 'chair', 'cow', 'table', 'dog', 'horse', + 'motorcycle', 'person', 'pot', 'sheep', 'sofa', 'train', + 'monitor' + # 'ambigious' + ] + + def __init__( + self, + root, + year='2012', + image_set='train', + download=False, + transform=None, + target_transform=None, + binary_class=False + ): + self.root = os.path.expanduser(root) + self.binary_class = binary_class + self.year = year + self.url = DATASET_YEAR_DICT[year]['url'] + self.filename = DATASET_YEAR_DICT[year]['filename'] + self.md5 = DATASET_YEAR_DICT[year]['md5'] + self.transform = transform + self.target_transform = target_transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]['base_dir'] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, 'JPEGImages') + mask_dir = os.path.join(voc_root, 'SegmentationClass') + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError('Dataset not found or corrupted.' + + ' You can use download=True to download it') + + splits_dir = os.path.join(voc_root, 'ImageSets/Segmentation') + + split_f = os.path.join(splits_dir, image_set.rstrip('\n') + '.txt') + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"') + + with open(os.path.join(split_f), "r") as f: + file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names] + assert (len(self.images) == len(self.masks)) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert('RGB') + target = Image.open(self.masks[index]) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype('int32') + target[target == 255] = -1 + target = torch.from_numpy(target).long() + + # # Convert target to (2, height, width) + # target = torch.stack([target, 1 - target], dim=0) + # Get a list of the classes that are present in the image + visible_classes = np.unique(target) + # Convert these to class names + present_classes = [self.CLASSES_NAMES[i] for i in visible_classes if i != -1] + + if self.binary_class: + # Take all classes that aren't zero or -1 and mkae them 1 + target[target >= 1] = 1 + + return img, target, present_classes + + @staticmethod + def _mask_transform(mask): + target = np.array(mask).astype('int32') + target[target == 255] = -1 + return torch.from_numpy(target).long() + + def __len__(self): + return len(self.images) + + @property + def pred_offset(self): + return 0 + + +class VOCClassification(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + """ + CLASSES = 20 + + def __init__(self, + root, + year='2012', + image_set='train', + download=False, + transform=None): + self.root = os.path.expanduser(root) + self.year = year + self.url = DATASET_YEAR_DICT[year]['url'] + self.filename = DATASET_YEAR_DICT[year]['filename'] + self.md5 = DATASET_YEAR_DICT[year]['md5'] + self.transform = transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]['base_dir'] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, 'JPEGImages') + mask_dir = os.path.join(voc_root, 'SegmentationClass') + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError('Dataset not found or corrupted.' + + ' You can use download=True to download it') + + splits_dir = os.path.join(voc_root, 'ImageSets/Segmentation') + + split_f = os.path.join(splits_dir, image_set.rstrip('\n') + '.txt') + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"') + + with open(os.path.join(split_f), "r") as f: + file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names] + assert (len(self.images) == len(self.masks)) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert('RGB') + target = Image.open(self.masks[index]) + + # if self.transform is not None: + # img = self.transform(img) + if self.transform is not None: + img, target = self.transform(img, target) + + visible_classes = np.unique(target) + labels = torch.zeros(self.CLASSES) + for id in visible_classes: + if id not in (0, 255): + labels[id - 1].fill_(1) + + return img, labels + + def __len__(self): + return len(self.images) + + +class VOCSBDClassification(data.Dataset): + """`Pascal VOC `_ Segmentation Dataset. + + Args: + root (string): Root directory of the VOC Dataset. + year (string, optional): The dataset year, supports years 2007 to 2012. + image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val`` + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + """ + CLASSES = 20 + + def __init__(self, + root, + sbd_root, + year='2012', + image_set='train', + download=False, + transform=None): + self.root = os.path.expanduser(root) + self.sbd_root = os.path.expanduser(sbd_root) + self.year = year + self.url = DATASET_YEAR_DICT[year]['url'] + self.filename = DATASET_YEAR_DICT[year]['filename'] + self.md5 = DATASET_YEAR_DICT[year]['md5'] + self.transform = transform + self.image_set = image_set + base_dir = DATASET_YEAR_DICT[year]['base_dir'] + voc_root = os.path.join(self.root, base_dir) + image_dir = os.path.join(voc_root, 'JPEGImages') + mask_dir = os.path.join(voc_root, 'SegmentationClass') + sbd_image_dir = os.path.join(sbd_root, 'img') + sbd_mask_dir = os.path.join(sbd_root, 'cls') + + if download: + download_extract(self.url, self.root, self.filename, self.md5) + + if not os.path.isdir(voc_root): + raise RuntimeError('Dataset not found or corrupted.' + + ' You can use download=True to download it') + + splits_dir = os.path.join(voc_root, 'ImageSets/Segmentation') + + split_f = os.path.join(splits_dir, image_set.rstrip('\n') + '.txt') + sbd_split = os.path.join(sbd_root, 'train.txt') + + if not os.path.exists(split_f): + raise ValueError( + 'Wrong image_set entered! Please use image_set="train" ' + 'or image_set="trainval" or image_set="val"') + + with open(os.path.join(split_f), "r") as f: + voc_file_names = [x.strip() for x in f.readlines()] + + with open(os.path.join(sbd_split), "r") as f: + sbd_file_names = [x.strip() for x in f.readlines()] + + self.images = [os.path.join(image_dir, x + ".jpg") for x in voc_file_names] + self.images += [os.path.join(sbd_image_dir, x + ".jpg") for x in sbd_file_names] + self.masks = [os.path.join(mask_dir, x + ".png") for x in voc_file_names] + self.masks += [os.path.join(sbd_mask_dir, x + ".mat") for x in sbd_file_names] + assert (len(self.images) == len(self.masks)) + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is the image segmentation. + """ + img = Image.open(self.images[index]).convert('RGB') + mask_path = self.masks[index] + if mask_path[-3:] == 'mat': + target = io.loadmat(mask_path, struct_as_record=False, squeeze_me=True)['GTcls'].Segmentation + target = Image.fromarray(target, mode='P') + else: + target = Image.open(self.masks[index]) + + if self.transform is not None: + img, target = self.transform(img, target) + + visible_classes = np.unique(target) + labels = torch.zeros(self.CLASSES) + for id in visible_classes: + if id not in (0, 255): + labels[id - 1].fill_(1) + + return img, labels + + def __len__(self): + return len(self.images) + + +def download_extract(url, root, filename, md5): + download_url(url, root, filename, md5) + with tarfile.open(os.path.join(root, filename), "r") as tar: + tar.extractall(path=root) + + +class VOCResults(data.Dataset): + CLASSES = 20 + CLASSES_NAMES = [ + 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', + 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'potted-plant', 'sheep', 'sofa', 'train', + 'tvmonitor', 'ambigious' + ] + + def __init__(self, path): + super(VOCResults, self).__init__() + + self.path = os.path.join(path, 'results.hdf5') + self.data = None + + print('Reading dataset length...') + with h5py.File(self.path , 'r') as f: + self.data_length = len(f['/image']) + + def __len__(self): + return self.data_length + + def __getitem__(self, item): + if self.data is None: + self.data = h5py.File(self.path, 'r') + + image = torch.tensor(self.data['image'][item]) + vis = torch.tensor(self.data['vis'][item]) + target = torch.tensor(self.data['target'][item]) + class_pred = torch.tensor(self.data['class_pred'][item]) + + return image, vis, target, class_pred diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__init__.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/Imagenet.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/Imagenet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0658d9b32ab9bf9305809da1304b727ba8fe7580 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/Imagenet.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/VOC.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/VOC.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2af094b25b607e8091bf55acf0052f904d580977 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/VOC.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/__init__.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7bf42a3ba7d016924c30281a6e2a873422a11e7d Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/__init__.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/imagenet.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/imagenet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66b6564190fad0c1c16d42b8d6a4cf26559c4e8e Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/__pycache__/imagenet.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet.py new file mode 100644 index 0000000000000000000000000000000000000000..1ba762a3cd4646e537b786ce4c2e9762d250002b --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet.py @@ -0,0 +1,200 @@ +import os +import torch +import torch.utils.data as data +import numpy as np +import cv2 + +from torchvision.datasets import ImageNet + +from PIL import Image, ImageFilter +import h5py +from glob import glob + + +class ImageNet_blur(ImageNet): + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (sample, target) where target is class_index of the target class. + """ + path, target = self.samples[index] + sample = self.loader(path) + + gauss_blur = ImageFilter.GaussianBlur(11) + median_blur = ImageFilter.MedianFilter(11) + + blurred_img1 = sample.filter(gauss_blur) + blurred_img2 = sample.filter(median_blur) + blurred_img = Image.blend(blurred_img1, blurred_img2, 0.5) + + if self.transform is not None: + sample = self.transform(sample) + blurred_img = self.transform(blurred_img) + if self.target_transform is not None: + target = self.target_transform(target) + + return (sample, blurred_img), target + + +class Imagenet_Segmentation(data.Dataset): + CLASSES = 2 + + def __init__(self, + path, + transform=None, + target_transform=None): + self.path = path + self.transform = transform + self.target_transform = target_transform + # self.h5py = h5py.File(path, 'r+') + self.h5py = None + with h5py.File(path, 'r') as tmp: + self.data_length = len(tmp['/value/img']) + + def __getitem__(self, index): + + if self.h5py is None: + self.h5py = h5py.File(self.path, 'r') + + img = np.array(self.h5py[self.h5py['/value/img'][index, 0]]).transpose((2, 1, 0)) + target = np.array(self.h5py[self.h5py[self.h5py['/value/gt'][index, 0]][0, 0]]).transpose((1, 0)) + + img = Image.fromarray(img).convert('RGB') + target = Image.fromarray(target) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype('int32') + target = torch.from_numpy(target).long() + + return img, target + + def __len__(self): + # return len(self.h5py['/value/img']) + return self.data_length + + +class Imagenet_Segmentation_Blur(data.Dataset): + CLASSES = 2 + + def __init__(self, + path, + transform=None, + target_transform=None): + self.path = path + self.transform = transform + self.target_transform = target_transform + # self.h5py = h5py.File(path, 'r+') + self.h5py = None + tmp = h5py.File(path, 'r') + self.data_length = len(tmp['/value/img']) + tmp.close() + del tmp + + def __getitem__(self, index): + + if self.h5py is None: + self.h5py = h5py.File(self.path, 'r') + + img = np.array(self.h5py[self.h5py['/value/img'][index, 0]]).transpose((2, 1, 0)) + target = np.array(self.h5py[self.h5py[self.h5py['/value/gt'][index, 0]][0, 0]]).transpose((1, 0)) + + img = Image.fromarray(img).convert('RGB') + target = Image.fromarray(target) + + gauss_blur = ImageFilter.GaussianBlur(11) + median_blur = ImageFilter.MedianFilter(11) + + blurred_img1 = img.filter(gauss_blur) + blurred_img2 = img.filter(median_blur) + blurred_img = Image.blend(blurred_img1, blurred_img2, 0.5) + + # blurred_img1 = cv2.GaussianBlur(img, (11, 11), 5) + # blurred_img2 = np.float32(cv2.medianBlur(img, 11)) + # blurred_img = (blurred_img1 + blurred_img2) / 2 + + if self.transform is not None: + img = self.transform(img) + blurred_img = self.transform(blurred_img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype('int32') + target = torch.from_numpy(target).long() + + return (img, blurred_img), target + + def __len__(self): + # return len(self.h5py['/value/img']) + return self.data_length + + +class Imagenet_Segmentation_eval_dir(data.Dataset): + CLASSES = 2 + + def __init__(self, + path, + eval_path, + transform=None, + target_transform=None): + self.transform = transform + self.target_transform = target_transform + self.h5py = h5py.File(path, 'r+') + + # 500 each file + self.results = glob(os.path.join(eval_path, '*.npy')) + + def __getitem__(self, index): + + img = np.array(self.h5py[self.h5py['/value/img'][index, 0]]).transpose((2, 1, 0)) + target = np.array(self.h5py[self.h5py[self.h5py['/value/gt'][index, 0]][0, 0]]).transpose((1, 0)) + res = np.load(self.results[index]) + + img = Image.fromarray(img).convert('RGB') + target = Image.fromarray(target) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype('int32') + target = torch.from_numpy(target).long() + + return img, target + + def __len__(self): + return len(self.h5py['/value/img']) + + +if __name__ == '__main__': + import torchvision.transforms as transforms + from tqdm import tqdm + from imageio import imsave + import scipy.io as sio + + # meta = sio.loadmat('/home/shirgur/ext/Data/Datasets/temp/ILSVRC2012_devkit_t12/data/meta.mat', squeeze_me=True)['synsets'] + + # Data + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + test_img_trans = transforms.Compose([ + transforms.Resize((224, 224)), + transforms.ToTensor(), + normalize, + ]) + test_lbl_trans = transforms.Compose([ + transforms.Resize((224, 224), Image.NEAREST), + ]) + + ds = Imagenet_Segmentation('/home/shirgur/ext/Data/Datasets/imagenet-seg/other/gtsegs_ijcv.mat', + transform=test_img_trans, target_transform=test_lbl_trans) + + for i, (img, tgt) in enumerate(tqdm(ds)): + tgt = (tgt.numpy() * 255).astype(np.uint8) + imsave('/home/shirgur/ext/Code/C2S/run/imagenet/gt/{}.png'.format(i), tgt) + + print('here') diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet_utils.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..057ea4000af89bbf8202734930759a8107f8890c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/imagenet_utils.py @@ -0,0 +1,1002 @@ +CLS2IDX = { + 0: 'tench, Tinca tinca', + 1: 'goldfish, Carassius auratus', + 2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias', + 3: 'tiger shark, Galeocerdo cuvieri', + 4: 'hammerhead, hammerhead shark', + 5: 'electric ray, crampfish, numbfish, torpedo', + 6: 'stingray', + 7: 'cock', + 8: 'hen', + 9: 'ostrich, Struthio camelus', + 10: 'brambling, Fringilla montifringilla', + 11: 'goldfinch, Carduelis carduelis', + 12: 'house finch, linnet, Carpodacus mexicanus', + 13: 'junco, snowbird', + 14: 'indigo bunting, indigo finch, indigo bird, Passerina cyanea', + 15: 'robin, American robin, Turdus migratorius', + 16: 'bulbul', + 17: 'jay', + 18: 'magpie', + 19: 'chickadee', + 20: 'water ouzel, dipper', + 21: 'kite', + 22: 'bald eagle, American eagle, Haliaeetus leucocephalus', + 23: 'vulture', + 24: 'great grey owl, great gray owl, Strix nebulosa', + 25: 'European fire salamander, Salamandra salamandra', + 26: 'common newt, Triturus vulgaris', + 27: 'eft', + 28: 'spotted salamander, Ambystoma maculatum', + 29: 'axolotl, mud puppy, Ambystoma mexicanum', + 30: 'bullfrog, Rana catesbeiana', + 31: 'tree frog, tree-frog', + 32: 'tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui', + 33: 'loggerhead, loggerhead turtle, Caretta caretta', + 34: 'leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea', + 35: 'mud turtle', + 36: 'terrapin', + 37: 'box turtle, box tortoise', + 38: 'banded gecko', + 39: 'common iguana, iguana, Iguana iguana', + 40: 'American chameleon, anole, Anolis carolinensis', + 41: 'whiptail, whiptail lizard', + 42: 'agama', + 43: 'frilled lizard, Chlamydosaurus kingi', + 44: 'alligator lizard', + 45: 'Gila monster, Heloderma suspectum', + 46: 'green lizard, Lacerta viridis', + 47: 'African chameleon, Chamaeleo chamaeleon', + 48: 'Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis', + 49: 'African crocodile, Nile crocodile, Crocodylus niloticus', + 50: 'American alligator, Alligator mississipiensis', + 51: 'triceratops', + 52: 'thunder snake, worm snake, Carphophis amoenus', + 53: 'ringneck snake, ring-necked snake, ring snake', + 54: 'hognose snake, puff adder, sand viper', + 55: 'green snake, grass snake', + 56: 'king snake, kingsnake', + 57: 'garter snake, grass snake', + 58: 'water snake', + 59: 'vine snake', + 60: 'night snake, Hypsiglena torquata', + 61: 'boa constrictor, Constrictor constrictor', + 62: 'rock python, rock snake, Python sebae', + 63: 'Indian cobra, Naja naja', + 64: 'green mamba', + 65: 'sea snake', + 66: 'horned viper, cerastes, sand viper, horned asp, Cerastes cornutus', + 67: 'diamondback, diamondback rattlesnake, Crotalus adamanteus', + 68: 'sidewinder, horned rattlesnake, Crotalus cerastes', + 69: 'trilobite', + 70: 'harvestman, daddy longlegs, Phalangium opilio', + 71: 'scorpion', + 72: 'black and gold garden spider, Argiope aurantia', + 73: 'barn spider, Araneus cavaticus', + 74: 'garden spider, Aranea diademata', + 75: 'black widow, Latrodectus mactans', + 76: 'tarantula', + 77: 'wolf spider, hunting spider', + 78: 'tick', + 79: 'centipede', + 80: 'black grouse', + 81: 'ptarmigan', + 82: 'ruffed grouse, partridge, Bonasa umbellus', + 83: 'prairie chicken, prairie grouse, prairie fowl', + 84: 'peacock', + 85: 'quail', + 86: 'partridge', + 87: 'African grey, African gray, Psittacus erithacus', + 88: 'macaw', + 89: 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita', + 90: 'lorikeet', + 91: 'coucal', + 92: 'bee eater', + 93: 'hornbill', + 94: 'hummingbird', + 95: 'jacamar', + 96: 'toucan', + 97: 'drake', + 98: 'red-breasted merganser, Mergus serrator', + 99: 'goose', + 100: 'black swan, Cygnus atratus', + 101: 'tusker', + 102: 'echidna, spiny anteater, anteater', + 103: 'platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus', + 104: 'wallaby, brush kangaroo', + 105: 'koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus', + 106: 'wombat', + 107: 'jellyfish', + 108: 'sea anemone, anemone', + 109: 'brain coral', + 110: 'flatworm, platyhelminth', + 111: 'nematode, nematode worm, roundworm', + 112: 'conch', + 113: 'snail', + 114: 'slug', + 115: 'sea slug, nudibranch', + 116: 'chiton, coat-of-mail shell, sea cradle, polyplacophore', + 117: 'chambered nautilus, pearly nautilus, nautilus', + 118: 'Dungeness crab, Cancer magister', + 119: 'rock crab, Cancer irroratus', + 120: 'fiddler crab', + 121: 'king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica', + 122: 'American lobster, Northern lobster, Maine lobster, Homarus americanus', + 123: 'spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish', + 124: 'crayfish, crawfish, crawdad, crawdaddy', + 125: 'hermit crab', + 126: 'isopod', + 127: 'white stork, Ciconia ciconia', + 128: 'black stork, Ciconia nigra', + 129: 'spoonbill', + 130: 'flamingo', + 131: 'little blue heron, Egretta caerulea', + 132: 'American egret, great white heron, Egretta albus', + 133: 'bittern', + 134: 'crane', + 135: 'limpkin, Aramus pictus', + 136: 'European gallinule, Porphyrio porphyrio', + 137: 'American coot, marsh hen, mud hen, water hen, Fulica americana', + 138: 'bustard', + 139: 'ruddy turnstone, Arenaria interpres', + 140: 'red-backed sandpiper, dunlin, Erolia alpina', + 141: 'redshank, Tringa totanus', + 142: 'dowitcher', + 143: 'oystercatcher, oyster catcher', + 144: 'pelican', + 145: 'king penguin, Aptenodytes patagonica', + 146: 'albatross, mollymawk', + 147: 'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus', + 148: 'killer whale, killer, orca, grampus, sea wolf, Orcinus orca', + 149: 'dugong, Dugong dugon', + 150: 'sea lion', + 151: 'Chihuahua', + 152: 'Japanese spaniel', + 153: 'Maltese dog, Maltese terrier, Maltese', + 154: 'Pekinese, Pekingese, Peke', + 155: 'Shih-Tzu', + 156: 'Blenheim spaniel', + 157: 'papillon', + 158: 'toy terrier', + 159: 'Rhodesian ridgeback', + 160: 'Afghan hound, Afghan', + 161: 'basset, basset hound', + 162: 'beagle', + 163: 'bloodhound, sleuthhound', + 164: 'bluetick', + 165: 'black-and-tan coonhound', + 166: 'Walker hound, Walker foxhound', + 167: 'English foxhound', + 168: 'redbone', + 169: 'borzoi, Russian wolfhound', + 170: 'Irish wolfhound', + 171: 'Italian greyhound', + 172: 'whippet', + 173: 'Ibizan hound, Ibizan Podenco', + 174: 'Norwegian elkhound, elkhound', + 175: 'otterhound, otter hound', + 176: 'Saluki, gazelle hound', + 177: 'Scottish deerhound, deerhound', + 178: 'Weimaraner', + 179: 'Staffordshire bullterrier, Staffordshire bull terrier', + 180: 'American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier', + 181: 'Bedlington terrier', + 182: 'Border terrier', + 183: 'Kerry blue terrier', + 184: 'Irish terrier', + 185: 'Norfolk terrier', + 186: 'Norwich terrier', + 187: 'Yorkshire terrier', + 188: 'wire-haired fox terrier', + 189: 'Lakeland terrier', + 190: 'Sealyham terrier, Sealyham', + 191: 'Airedale, Airedale terrier', + 192: 'cairn, cairn terrier', + 193: 'Australian terrier', + 194: 'Dandie Dinmont, Dandie Dinmont terrier', + 195: 'Boston bull, Boston terrier', + 196: 'miniature schnauzer', + 197: 'giant schnauzer', + 198: 'standard schnauzer', + 199: 'Scotch terrier, Scottish terrier, Scottie', + 200: 'Tibetan terrier, chrysanthemum dog', + 201: 'silky terrier, Sydney silky', + 202: 'soft-coated wheaten terrier', + 203: 'West Highland white terrier', + 204: 'Lhasa, Lhasa apso', + 205: 'flat-coated retriever', + 206: 'curly-coated retriever', + 207: 'golden retriever', + 208: 'Labrador retriever', + 209: 'Chesapeake Bay retriever', + 210: 'German short-haired pointer', + 211: 'vizsla, Hungarian pointer', + 212: 'English setter', + 213: 'Irish setter, red setter', + 214: 'Gordon setter', + 215: 'Brittany spaniel', + 216: 'clumber, clumber spaniel', + 217: 'English springer, English springer spaniel', + 218: 'Welsh springer spaniel', + 219: 'cocker spaniel, English cocker spaniel, cocker', + 220: 'Sussex spaniel', + 221: 'Irish water spaniel', + 222: 'kuvasz', + 223: 'schipperke', + 224: 'groenendael', + 225: 'malinois', + 226: 'briard', + 227: 'kelpie', + 228: 'komondor', + 229: 'Old English sheepdog, bobtail', + 230: 'Shetland sheepdog, Shetland sheep dog, Shetland', + 231: 'collie', + 232: 'Border collie', + 233: 'Bouvier des Flandres, Bouviers des Flandres', + 234: 'Rottweiler', + 235: 'German shepherd, German shepherd dog, German police dog, alsatian', + 236: 'Doberman, Doberman pinscher', + 237: 'miniature pinscher', + 238: 'Greater Swiss Mountain dog', + 239: 'Bernese mountain dog', + 240: 'Appenzeller', + 241: 'EntleBucher', + 242: 'boxer', + 243: 'bull mastiff', + 244: 'Tibetan mastiff', + 245: 'French bulldog', + 246: 'Great Dane', + 247: 'Saint Bernard, St Bernard', + 248: 'Eskimo dog, husky', + 249: 'malamute, malemute, Alaskan malamute', + 250: 'Siberian husky', + 251: 'dalmatian, coach dog, carriage dog', + 252: 'affenpinscher, monkey pinscher, monkey dog', + 253: 'basenji', + 254: 'pug, pug-dog', + 255: 'Leonberg', + 256: 'Newfoundland, Newfoundland dog', + 257: 'Great Pyrenees', + 258: 'Samoyed, Samoyede', + 259: 'Pomeranian', + 260: 'chow, chow chow', + 261: 'keeshond', + 262: 'Brabancon griffon', + 263: 'Pembroke, Pembroke Welsh corgi', + 264: 'Cardigan, Cardigan Welsh corgi', + 265: 'toy poodle', + 266: 'miniature poodle', + 267: 'standard poodle', + 268: 'Mexican hairless', + 269: 'timber wolf, grey wolf, gray wolf, Canis lupus', + 270: 'white wolf, Arctic wolf, Canis lupus tundrarum', + 271: 'red wolf, maned wolf, Canis rufus, Canis niger', + 272: 'coyote, prairie wolf, brush wolf, Canis latrans', + 273: 'dingo, warrigal, warragal, Canis dingo', + 274: 'dhole, Cuon alpinus', + 275: 'African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus', + 276: 'hyena, hyaena', + 277: 'red fox, Vulpes vulpes', + 278: 'kit fox, Vulpes macrotis', + 279: 'Arctic fox, white fox, Alopex lagopus', + 280: 'grey fox, gray fox, Urocyon cinereoargenteus', + 281: 'tabby, tabby cat', + 282: 'tiger cat', + 283: 'Persian cat', + 284: 'Siamese cat, Siamese', + 285: 'Egyptian cat', + 286: 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor', + 287: 'lynx, catamount', + 288: 'leopard, Panthera pardus', + 289: 'snow leopard, ounce, Panthera uncia', + 290: 'jaguar, panther, Panthera onca, Felis onca', + 291: 'lion, king of beasts, Panthera leo', + 292: 'tiger, Panthera tigris', + 293: 'cheetah, chetah, Acinonyx jubatus', + 294: 'brown bear, bruin, Ursus arctos', + 295: 'American black bear, black bear, Ursus americanus, Euarctos americanus', + 296: 'ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus', + 297: 'sloth bear, Melursus ursinus, Ursus ursinus', + 298: 'mongoose', + 299: 'meerkat, mierkat', + 300: 'tiger beetle', + 301: 'ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle', + 302: 'ground beetle, carabid beetle', + 303: 'long-horned beetle, longicorn, longicorn beetle', + 304: 'leaf beetle, chrysomelid', + 305: 'dung beetle', + 306: 'rhinoceros beetle', + 307: 'weevil', + 308: 'fly', + 309: 'bee', + 310: 'ant, emmet, pismire', + 311: 'grasshopper, hopper', + 312: 'cricket', + 313: 'walking stick, walkingstick, stick insect', + 314: 'cockroach, roach', + 315: 'mantis, mantid', + 316: 'cicada, cicala', + 317: 'leafhopper', + 318: 'lacewing, lacewing fly', + 319: "dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk", + 320: 'damselfly', + 321: 'admiral', + 322: 'ringlet, ringlet butterfly', + 323: 'monarch, monarch butterfly, milkweed butterfly, Danaus plexippus', + 324: 'cabbage butterfly', + 325: 'sulphur butterfly, sulfur butterfly', + 326: 'lycaenid, lycaenid butterfly', + 327: 'starfish, sea star', + 328: 'sea urchin', + 329: 'sea cucumber, holothurian', + 330: 'wood rabbit, cottontail, cottontail rabbit', + 331: 'hare', + 332: 'Angora, Angora rabbit', + 333: 'hamster', + 334: 'porcupine, hedgehog', + 335: 'fox squirrel, eastern fox squirrel, Sciurus niger', + 336: 'marmot', + 337: 'beaver', + 338: 'guinea pig, Cavia cobaya', + 339: 'sorrel', + 340: 'zebra', + 341: 'hog, pig, grunter, squealer, Sus scrofa', + 342: 'wild boar, boar, Sus scrofa', + 343: 'warthog', + 344: 'hippopotamus, hippo, river horse, Hippopotamus amphibius', + 345: 'ox', + 346: 'water buffalo, water ox, Asiatic buffalo, Bubalus bubalis', + 347: 'bison', + 348: 'ram, tup', + 349: 'bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis', + 350: 'ibex, Capra ibex', + 351: 'hartebeest', + 352: 'impala, Aepyceros melampus', + 353: 'gazelle', + 354: 'Arabian camel, dromedary, Camelus dromedarius', + 355: 'llama', + 356: 'weasel', + 357: 'mink', + 358: 'polecat, fitch, foulmart, foumart, Mustela putorius', + 359: 'black-footed ferret, ferret, Mustela nigripes', + 360: 'otter', + 361: 'skunk, polecat, wood pussy', + 362: 'badger', + 363: 'armadillo', + 364: 'three-toed sloth, ai, Bradypus tridactylus', + 365: 'orangutan, orang, orangutang, Pongo pygmaeus', + 366: 'gorilla, Gorilla gorilla', + 367: 'chimpanzee, chimp, Pan troglodytes', + 368: 'gibbon, Hylobates lar', + 369: 'siamang, Hylobates syndactylus, Symphalangus syndactylus', + 370: 'guenon, guenon monkey', + 371: 'patas, hussar monkey, Erythrocebus patas', + 372: 'baboon', + 373: 'macaque', + 374: 'langur', + 375: 'colobus, colobus monkey', + 376: 'proboscis monkey, Nasalis larvatus', + 377: 'marmoset', + 378: 'capuchin, ringtail, Cebus capucinus', + 379: 'howler monkey, howler', + 380: 'titi, titi monkey', + 381: 'spider monkey, Ateles geoffroyi', + 382: 'squirrel monkey, Saimiri sciureus', + 383: 'Madagascar cat, ring-tailed lemur, Lemur catta', + 384: 'indri, indris, Indri indri, Indri brevicaudatus', + 385: 'Indian elephant, Elephas maximus', + 386: 'African elephant, Loxodonta africana', + 387: 'lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens', + 388: 'giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca', + 389: 'barracouta, snoek', + 390: 'eel', + 391: 'coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch', + 392: 'rock beauty, Holocanthus tricolor', + 393: 'anemone fish', + 394: 'sturgeon', + 395: 'gar, garfish, garpike, billfish, Lepisosteus osseus', + 396: 'lionfish', + 397: 'puffer, pufferfish, blowfish, globefish', + 398: 'abacus', + 399: 'abaya', + 400: "academic gown, academic robe, judge's robe", + 401: 'accordion, piano accordion, squeeze box', + 402: 'acoustic guitar', + 403: 'aircraft carrier, carrier, flattop, attack aircraft carrier', + 404: 'airliner', + 405: 'airship, dirigible', + 406: 'altar', + 407: 'ambulance', + 408: 'amphibian, amphibious vehicle', + 409: 'analog clock', + 410: 'apiary, bee house', + 411: 'apron', + 412: 'ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin', + 413: 'assault rifle, assault gun', + 414: 'backpack, back pack, knapsack, packsack, rucksack, haversack', + 415: 'bakery, bakeshop, bakehouse', + 416: 'balance beam, beam', + 417: 'balloon', + 418: 'ballpoint, ballpoint pen, ballpen, Biro', + 419: 'Band Aid', + 420: 'banjo', + 421: 'bannister, banister, balustrade, balusters, handrail', + 422: 'barbell', + 423: 'barber chair', + 424: 'barbershop', + 425: 'barn', + 426: 'barometer', + 427: 'barrel, cask', + 428: 'barrow, garden cart, lawn cart, wheelbarrow', + 429: 'baseball', + 430: 'basketball', + 431: 'bassinet', + 432: 'bassoon', + 433: 'bathing cap, swimming cap', + 434: 'bath towel', + 435: 'bathtub, bathing tub, bath, tub', + 436: 'beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon', + 437: 'beacon, lighthouse, beacon light, pharos', + 438: 'beaker', + 439: 'bearskin, busby, shako', + 440: 'beer bottle', + 441: 'beer glass', + 442: 'bell cote, bell cot', + 443: 'bib', + 444: 'bicycle-built-for-two, tandem bicycle, tandem', + 445: 'bikini, two-piece', + 446: 'binder, ring-binder', + 447: 'binoculars, field glasses, opera glasses', + 448: 'birdhouse', + 449: 'boathouse', + 450: 'bobsled, bobsleigh, bob', + 451: 'bolo tie, bolo, bola tie, bola', + 452: 'bonnet, poke bonnet', + 453: 'bookcase', + 454: 'bookshop, bookstore, bookstall', + 455: 'bottlecap', + 456: 'bow', + 457: 'bow tie, bow-tie, bowtie', + 458: 'brass, memorial tablet, plaque', + 459: 'brassiere, bra, bandeau', + 460: 'breakwater, groin, groyne, mole, bulwark, seawall, jetty', + 461: 'breastplate, aegis, egis', + 462: 'broom', + 463: 'bucket, pail', + 464: 'buckle', + 465: 'bulletproof vest', + 466: 'bullet train, bullet', + 467: 'butcher shop, meat market', + 468: 'cab, hack, taxi, taxicab', + 469: 'caldron, cauldron', + 470: 'candle, taper, wax light', + 471: 'cannon', + 472: 'canoe', + 473: 'can opener, tin opener', + 474: 'cardigan', + 475: 'car mirror', + 476: 'carousel, carrousel, merry-go-round, roundabout, whirligig', + 477: "carpenter's kit, tool kit", + 478: 'carton', + 479: 'car wheel', + 480: 'cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM', + 481: 'cassette', + 482: 'cassette player', + 483: 'castle', + 484: 'catamaran', + 485: 'CD player', + 486: 'cello, violoncello', + 487: 'cellular telephone, cellular phone, cellphone, cell, mobile phone', + 488: 'chain', + 489: 'chainlink fence', + 490: 'chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour', + 491: 'chain saw, chainsaw', + 492: 'chest', + 493: 'chiffonier, commode', + 494: 'chime, bell, gong', + 495: 'china cabinet, china closet', + 496: 'Christmas stocking', + 497: 'church, church building', + 498: 'cinema, movie theater, movie theatre, movie house, picture palace', + 499: 'cleaver, meat cleaver, chopper', + 500: 'cliff dwelling', + 501: 'cloak', + 502: 'clog, geta, patten, sabot', + 503: 'cocktail shaker', + 504: 'coffee mug', + 505: 'coffeepot', + 506: 'coil, spiral, volute, whorl, helix', + 507: 'combination lock', + 508: 'computer keyboard, keypad', + 509: 'confectionery, confectionary, candy store', + 510: 'container ship, containership, container vessel', + 511: 'convertible', + 512: 'corkscrew, bottle screw', + 513: 'cornet, horn, trumpet, trump', + 514: 'cowboy boot', + 515: 'cowboy hat, ten-gallon hat', + 516: 'cradle', + 517: 'crane', + 518: 'crash helmet', + 519: 'crate', + 520: 'crib, cot', + 521: 'Crock Pot', + 522: 'croquet ball', + 523: 'crutch', + 524: 'cuirass', + 525: 'dam, dike, dyke', + 526: 'desk', + 527: 'desktop computer', + 528: 'dial telephone, dial phone', + 529: 'diaper, nappy, napkin', + 530: 'digital clock', + 531: 'digital watch', + 532: 'dining table, board', + 533: 'dishrag, dishcloth', + 534: 'dishwasher, dish washer, dishwashing machine', + 535: 'disk brake, disc brake', + 536: 'dock, dockage, docking facility', + 537: 'dogsled, dog sled, dog sleigh', + 538: 'dome', + 539: 'doormat, welcome mat', + 540: 'drilling platform, offshore rig', + 541: 'drum, membranophone, tympan', + 542: 'drumstick', + 543: 'dumbbell', + 544: 'Dutch oven', + 545: 'electric fan, blower', + 546: 'electric guitar', + 547: 'electric locomotive', + 548: 'entertainment center', + 549: 'envelope', + 550: 'espresso maker', + 551: 'face powder', + 552: 'feather boa, boa', + 553: 'file, file cabinet, filing cabinet', + 554: 'fireboat', + 555: 'fire engine, fire truck', + 556: 'fire screen, fireguard', + 557: 'flagpole, flagstaff', + 558: 'flute, transverse flute', + 559: 'folding chair', + 560: 'football helmet', + 561: 'forklift', + 562: 'fountain', + 563: 'fountain pen', + 564: 'four-poster', + 565: 'freight car', + 566: 'French horn, horn', + 567: 'frying pan, frypan, skillet', + 568: 'fur coat', + 569: 'garbage truck, dustcart', + 570: 'gasmask, respirator, gas helmet', + 571: 'gas pump, gasoline pump, petrol pump, island dispenser', + 572: 'goblet', + 573: 'go-kart', + 574: 'golf ball', + 575: 'golfcart, golf cart', + 576: 'gondola', + 577: 'gong, tam-tam', + 578: 'gown', + 579: 'grand piano, grand', + 580: 'greenhouse, nursery, glasshouse', + 581: 'grille, radiator grille', + 582: 'grocery store, grocery, food market, market', + 583: 'guillotine', + 584: 'hair slide', + 585: 'hair spray', + 586: 'half track', + 587: 'hammer', + 588: 'hamper', + 589: 'hand blower, blow dryer, blow drier, hair dryer, hair drier', + 590: 'hand-held computer, hand-held microcomputer', + 591: 'handkerchief, hankie, hanky, hankey', + 592: 'hard disc, hard disk, fixed disk', + 593: 'harmonica, mouth organ, harp, mouth harp', + 594: 'harp', + 595: 'harvester, reaper', + 596: 'hatchet', + 597: 'holster', + 598: 'home theater, home theatre', + 599: 'honeycomb', + 600: 'hook, claw', + 601: 'hoopskirt, crinoline', + 602: 'horizontal bar, high bar', + 603: 'horse cart, horse-cart', + 604: 'hourglass', + 605: 'iPod', + 606: 'iron, smoothing iron', + 607: "jack-o'-lantern", + 608: 'jean, blue jean, denim', + 609: 'jeep, landrover', + 610: 'jersey, T-shirt, tee shirt', + 611: 'jigsaw puzzle', + 612: 'jinrikisha, ricksha, rickshaw', + 613: 'joystick', + 614: 'kimono', + 615: 'knee pad', + 616: 'knot', + 617: 'lab coat, laboratory coat', + 618: 'ladle', + 619: 'lampshade, lamp shade', + 620: 'laptop, laptop computer', + 621: 'lawn mower, mower', + 622: 'lens cap, lens cover', + 623: 'letter opener, paper knife, paperknife', + 624: 'library', + 625: 'lifeboat', + 626: 'lighter, light, igniter, ignitor', + 627: 'limousine, limo', + 628: 'liner, ocean liner', + 629: 'lipstick, lip rouge', + 630: 'Loafer', + 631: 'lotion', + 632: 'loudspeaker, speaker, speaker unit, loudspeaker system, speaker system', + 633: "loupe, jeweler's loupe", + 634: 'lumbermill, sawmill', + 635: 'magnetic compass', + 636: 'mailbag, postbag', + 637: 'mailbox, letter box', + 638: 'maillot', + 639: 'maillot, tank suit', + 640: 'manhole cover', + 641: 'maraca', + 642: 'marimba, xylophone', + 643: 'mask', + 644: 'matchstick', + 645: 'maypole', + 646: 'maze, labyrinth', + 647: 'measuring cup', + 648: 'medicine chest, medicine cabinet', + 649: 'megalith, megalithic structure', + 650: 'microphone, mike', + 651: 'microwave, microwave oven', + 652: 'military uniform', + 653: 'milk can', + 654: 'minibus', + 655: 'miniskirt, mini', + 656: 'minivan', + 657: 'missile', + 658: 'mitten', + 659: 'mixing bowl', + 660: 'mobile home, manufactured home', + 661: 'Model T', + 662: 'modem', + 663: 'monastery', + 664: 'monitor', + 665: 'moped', + 666: 'mortar', + 667: 'mortarboard', + 668: 'mosque', + 669: 'mosquito net', + 670: 'motor scooter, scooter', + 671: 'mountain bike, all-terrain bike, off-roader', + 672: 'mountain tent', + 673: 'mouse, computer mouse', + 674: 'mousetrap', + 675: 'moving van', + 676: 'muzzle', + 677: 'nail', + 678: 'neck brace', + 679: 'necklace', + 680: 'nipple', + 681: 'notebook, notebook computer', + 682: 'obelisk', + 683: 'oboe, hautboy, hautbois', + 684: 'ocarina, sweet potato', + 685: 'odometer, hodometer, mileometer, milometer', + 686: 'oil filter', + 687: 'organ, pipe organ', + 688: 'oscilloscope, scope, cathode-ray oscilloscope, CRO', + 689: 'overskirt', + 690: 'oxcart', + 691: 'oxygen mask', + 692: 'packet', + 693: 'paddle, boat paddle', + 694: 'paddlewheel, paddle wheel', + 695: 'padlock', + 696: 'paintbrush', + 697: "pajama, pyjama, pj's, jammies", + 698: 'palace', + 699: 'panpipe, pandean pipe, syrinx', + 700: 'paper towel', + 701: 'parachute, chute', + 702: 'parallel bars, bars', + 703: 'park bench', + 704: 'parking meter', + 705: 'passenger car, coach, carriage', + 706: 'patio, terrace', + 707: 'pay-phone, pay-station', + 708: 'pedestal, plinth, footstall', + 709: 'pencil box, pencil case', + 710: 'pencil sharpener', + 711: 'perfume, essence', + 712: 'Petri dish', + 713: 'photocopier', + 714: 'pick, plectrum, plectron', + 715: 'pickelhaube', + 716: 'picket fence, paling', + 717: 'pickup, pickup truck', + 718: 'pier', + 719: 'piggy bank, penny bank', + 720: 'pill bottle', + 721: 'pillow', + 722: 'ping-pong ball', + 723: 'pinwheel', + 724: 'pirate, pirate ship', + 725: 'pitcher, ewer', + 726: "plane, carpenter's plane, woodworking plane", + 727: 'planetarium', + 728: 'plastic bag', + 729: 'plate rack', + 730: 'plow, plough', + 731: "plunger, plumber's helper", + 732: 'Polaroid camera, Polaroid Land camera', + 733: 'pole', + 734: 'police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria', + 735: 'poncho', + 736: 'pool table, billiard table, snooker table', + 737: 'pop bottle, soda bottle', + 738: 'pot, flowerpot', + 739: "potter's wheel", + 740: 'power drill', + 741: 'prayer rug, prayer mat', + 742: 'printer', + 743: 'prison, prison house', + 744: 'projectile, missile', + 745: 'projector', + 746: 'puck, hockey puck', + 747: 'punching bag, punch bag, punching ball, punchball', + 748: 'purse', + 749: 'quill, quill pen', + 750: 'quilt, comforter, comfort, puff', + 751: 'racer, race car, racing car', + 752: 'racket, racquet', + 753: 'radiator', + 754: 'radio, wireless', + 755: 'radio telescope, radio reflector', + 756: 'rain barrel', + 757: 'recreational vehicle, RV, R.V.', + 758: 'reel', + 759: 'reflex camera', + 760: 'refrigerator, icebox', + 761: 'remote control, remote', + 762: 'restaurant, eating house, eating place, eatery', + 763: 'revolver, six-gun, six-shooter', + 764: 'rifle', + 765: 'rocking chair, rocker', + 766: 'rotisserie', + 767: 'rubber eraser, rubber, pencil eraser', + 768: 'rugby ball', + 769: 'rule, ruler', + 770: 'running shoe', + 771: 'safe', + 772: 'safety pin', + 773: 'saltshaker, salt shaker', + 774: 'sandal', + 775: 'sarong', + 776: 'sax, saxophone', + 777: 'scabbard', + 778: 'scale, weighing machine', + 779: 'school bus', + 780: 'schooner', + 781: 'scoreboard', + 782: 'screen, CRT screen', + 783: 'screw', + 784: 'screwdriver', + 785: 'seat belt, seatbelt', + 786: 'sewing machine', + 787: 'shield, buckler', + 788: 'shoe shop, shoe-shop, shoe store', + 789: 'shoji', + 790: 'shopping basket', + 791: 'shopping cart', + 792: 'shovel', + 793: 'shower cap', + 794: 'shower curtain', + 795: 'ski', + 796: 'ski mask', + 797: 'sleeping bag', + 798: 'slide rule, slipstick', + 799: 'sliding door', + 800: 'slot, one-armed bandit', + 801: 'snorkel', + 802: 'snowmobile', + 803: 'snowplow, snowplough', + 804: 'soap dispenser', + 805: 'soccer ball', + 806: 'sock', + 807: 'solar dish, solar collector, solar furnace', + 808: 'sombrero', + 809: 'soup bowl', + 810: 'space bar', + 811: 'space heater', + 812: 'space shuttle', + 813: 'spatula', + 814: 'speedboat', + 815: "spider web, spider's web", + 816: 'spindle', + 817: 'sports car, sport car', + 818: 'spotlight, spot', + 819: 'stage', + 820: 'steam locomotive', + 821: 'steel arch bridge', + 822: 'steel drum', + 823: 'stethoscope', + 824: 'stole', + 825: 'stone wall', + 826: 'stopwatch, stop watch', + 827: 'stove', + 828: 'strainer', + 829: 'streetcar, tram, tramcar, trolley, trolley car', + 830: 'stretcher', + 831: 'studio couch, day bed', + 832: 'stupa, tope', + 833: 'submarine, pigboat, sub, U-boat', + 834: 'suit, suit of clothes', + 835: 'sundial', + 836: 'sunglass', + 837: 'sunglasses, dark glasses, shades', + 838: 'sunscreen, sunblock, sun blocker', + 839: 'suspension bridge', + 840: 'swab, swob, mop', + 841: 'sweatshirt', + 842: 'swimming trunks, bathing trunks', + 843: 'swing', + 844: 'switch, electric switch, electrical switch', + 845: 'syringe', + 846: 'table lamp', + 847: 'tank, army tank, armored combat vehicle, armoured combat vehicle', + 848: 'tape player', + 849: 'teapot', + 850: 'teddy, teddy bear', + 851: 'television, television system', + 852: 'tennis ball', + 853: 'thatch, thatched roof', + 854: 'theater curtain, theatre curtain', + 855: 'thimble', + 856: 'thresher, thrasher, threshing machine', + 857: 'throne', + 858: 'tile roof', + 859: 'toaster', + 860: 'tobacco shop, tobacconist shop, tobacconist', + 861: 'toilet seat', + 862: 'torch', + 863: 'totem pole', + 864: 'tow truck, tow car, wrecker', + 865: 'toyshop', + 866: 'tractor', + 867: 'trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi', + 868: 'tray', + 869: 'trench coat', + 870: 'tricycle, trike, velocipede', + 871: 'trimaran', + 872: 'tripod', + 873: 'triumphal arch', + 874: 'trolleybus, trolley coach, trackless trolley', + 875: 'trombone', + 876: 'tub, vat', + 877: 'turnstile', + 878: 'typewriter keyboard', + 879: 'umbrella', + 880: 'unicycle, monocycle', + 881: 'upright, upright piano', + 882: 'vacuum, vacuum cleaner', + 883: 'vase', + 884: 'vault', + 885: 'velvet', + 886: 'vending machine', + 887: 'vestment', + 888: 'viaduct', + 889: 'violin, fiddle', + 890: 'volleyball', + 891: 'waffle iron', + 892: 'wall clock', + 893: 'wallet, billfold, notecase, pocketbook', + 894: 'wardrobe, closet, press', + 895: 'warplane, military plane', + 896: 'washbasin, handbasin, washbowl, lavabo, wash-hand basin', + 897: 'washer, automatic washer, washing machine', + 898: 'water bottle', + 899: 'water jug', + 900: 'water tower', + 901: 'whiskey jug', + 902: 'whistle', + 903: 'wig', + 904: 'window screen', + 905: 'window shade', + 906: 'Windsor tie', + 907: 'wine bottle', + 908: 'wing', + 909: 'wok', + 910: 'wooden spoon', + 911: 'wool, woolen, woollen', + 912: 'worm fence, snake fence, snake-rail fence, Virginia fence', + 913: 'wreck', + 914: 'yawl', + 915: 'yurt', + 916: 'web site, website, internet site, site', + 917: 'comic book', + 918: 'crossword puzzle, crossword', + 919: 'street sign', + 920: 'traffic light, traffic signal, stoplight', + 921: 'book jacket, dust cover, dust jacket, dust wrapper', + 922: 'menu', + 923: 'plate', + 924: 'guacamole', + 925: 'consomme', + 926: 'hot pot, hotpot', + 927: 'trifle', + 928: 'ice cream, icecream', + 929: 'ice lolly, lolly, lollipop, popsicle', + 930: 'French loaf', + 931: 'bagel, beigel', + 932: 'pretzel', + 933: 'cheeseburger', + 934: 'hotdog, hot dog, red hot', + 935: 'mashed potato', + 936: 'head cabbage', + 937: 'broccoli', + 938: 'cauliflower', + 939: 'zucchini, courgette', + 940: 'spaghetti squash', + 941: 'acorn squash', + 942: 'butternut squash', + 943: 'cucumber, cuke', + 944: 'artichoke, globe artichoke', + 945: 'bell pepper', + 946: 'cardoon', + 947: 'mushroom', + 948: 'Granny Smith', + 949: 'strawberry', + 950: 'orange', + 951: 'lemon', + 952: 'fig', + 953: 'pineapple, ananas', + 954: 'banana', + 955: 'jackfruit, jak, jack', + 956: 'custard apple', + 957: 'pomegranate', + 958: 'hay', + 959: 'carbonara', + 960: 'chocolate sauce, chocolate syrup', + 961: 'dough', + 962: 'meat loaf, meatloaf', + 963: 'pizza, pizza pie', + 964: 'potpie', + 965: 'burrito', + 966: 'red wine', + 967: 'espresso', + 968: 'cup', + 969: 'eggnog', + 970: 'alp', + 971: 'bubble', + 972: 'cliff, drop, drop-off', + 973: 'coral reef', + 974: 'geyser', + 975: 'lakeside, lakeshore', + 976: 'promontory, headland, head, foreland', + 977: 'sandbar, sand bar', + 978: 'seashore, coast, seacoast, sea-coast', + 979: 'valley, vale', + 980: 'volcano', + 981: 'ballplayer, baseball player', + 982: 'groom, bridegroom', + 983: 'scuba diver', + 984: 'rapeseed', + 985: 'daisy', + 986: "yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum", + 987: 'corn', + 988: 'acorn', + 989: 'hip, rose hip, rosehip', + 990: 'buckeye, horse chestnut, conker', + 991: 'coral fungus', + 992: 'agaric', + 993: 'gyromitra', + 994: 'stinkhorn, carrion fungus', + 995: 'earthstar', + 996: 'hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa', + 997: 'bolete', + 998: 'ear, spike, capitulum', + 999: 'toilet tissue, toilet paper, bathroom tissue' +} diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/transforms.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..f6d723d1e73124658af9081014a75e43422b6ea8 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/data/transforms.py @@ -0,0 +1,442 @@ +from __future__ import division +import sys +import random +from PIL import Image + +try: + import accimage +except ImportError: + accimage = None +import numbers +import collections + +from torchvision.transforms import functional as F + +if sys.version_info < (3, 3): + Sequence = collections.Sequence + Iterable = collections.Iterable +else: + Sequence = collections.abc.Sequence + Iterable = collections.abc.Iterable + +_pil_interpolation_to_str = { + Image.NEAREST: 'PIL.Image.NEAREST', + Image.BILINEAR: 'PIL.Image.BILINEAR', + Image.BICUBIC: 'PIL.Image.BICUBIC', + Image.LANCZOS: 'PIL.Image.LANCZOS', + Image.HAMMING: 'PIL.Image.HAMMING', + Image.BOX: 'PIL.Image.BOX', +} + + +class Compose(object): + """Composes several transforms together. + + Args: + transforms (list of ``Transform`` objects): list of transforms to compose. + + Example: + >>> transforms.Compose([ + >>> transforms.CenterCrop(10), + >>> transforms.ToTensor(), + >>> ]) + """ + + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, img, tgt): + for t in self.transforms: + img, tgt = t(img, tgt) + return img, tgt + + def __repr__(self): + format_string = self.__class__.__name__ + '(' + for t in self.transforms: + format_string += '\n' + format_string += ' {0}'.format(t) + format_string += '\n)' + return format_string + + +class Resize(object): + """Resize the input PIL Image to the given size. + + Args: + size (sequence or int): Desired output size. If size is a sequence like + (h, w), output size will be matched to this. If size is an int, + smaller edge of the image will be matched to this number. + i.e, if height > width, then image will be rescaled to + (size * height / width, size) + interpolation (int, optional): Desired interpolation. Default is + ``PIL.Image.BILINEAR`` + """ + + def __init__(self, size, interpolation=Image.BILINEAR): + assert isinstance(size, int) or (isinstance(size, Iterable) and len(size) == 2) + self.size = size + self.interpolation = interpolation + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be scaled. + + Returns: + PIL Image: Rescaled image. + """ + return F.resize(img, self.size, self.interpolation), F.resize(tgt, self.size, Image.NEAREST) + + def __repr__(self): + interpolate_str = _pil_interpolation_to_str[self.interpolation] + return self.__class__.__name__ + '(size={0}, interpolation={1})'.format(self.size, interpolate_str) + + +class CenterCrop(object): + """Crops the given PIL Image at the center. + + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + """ + + def __init__(self, size): + if isinstance(size, numbers.Number): + self.size = (int(size), int(size)) + else: + self.size = size + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be cropped. + + Returns: + PIL Image: Cropped image. + """ + return F.center_crop(img, self.size), F.center_crop(tgt, self.size) + + def __repr__(self): + return self.__class__.__name__ + '(size={0})'.format(self.size) + + +class RandomCrop(object): + """Crop the given PIL Image at a random location. + + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + padding (int or sequence, optional): Optional padding on each border + of the image. Default is None, i.e no padding. If a sequence of length + 4 is provided, it is used to pad left, top, right, bottom borders + respectively. If a sequence of length 2 is provided, it is used to + pad left/right, top/bottom borders, respectively. + pad_if_needed (boolean): It will pad the image if smaller than the + desired size to avoid raising an exception. + fill: Pixel fill value for constant fill. Default is 0. If a tuple of + length 3, it is used to fill R, G, B channels respectively. + This value is only used when the padding_mode is constant + padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. + + - constant: pads with a constant value, this value is specified with fill + + - edge: pads with the last value on the edge of the image + + - reflect: pads with reflection of image (without repeating the last value on the edge) + + padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode + will result in [3, 2, 1, 2, 3, 4, 3, 2] + + - symmetric: pads with reflection of image (repeating the last value on the edge) + + padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode + will result in [2, 1, 1, 2, 3, 4, 4, 3] + + """ + + def __init__(self, size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant'): + if isinstance(size, numbers.Number): + self.size = (int(size), int(size)) + else: + self.size = size + self.padding = padding + self.pad_if_needed = pad_if_needed + self.fill = fill + self.padding_mode = padding_mode + + @staticmethod + def get_params(img, output_size): + """Get parameters for ``crop`` for a random crop. + + Args: + img (PIL Image): Image to be cropped. + output_size (tuple): Expected output size of the crop. + + Returns: + tuple: params (i, j, h, w) to be passed to ``crop`` for random crop. + """ + w, h = img.size + th, tw = output_size + if w == tw and h == th: + return 0, 0, h, w + + i = random.randint(0, h - th) + j = random.randint(0, w - tw) + return i, j, th, tw + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be cropped. + + Returns: + PIL Image: Cropped image. + """ + if self.padding is not None: + img = F.pad(img, self.padding, self.fill, self.padding_mode) + tgt = F.pad(tgt, self.padding, self.fill, self.padding_mode) + + # pad the width if needed + if self.pad_if_needed and img.size[0] < self.size[1]: + img = F.pad(img, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode) + tgt = F.pad(tgt, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode) + # pad the height if needed + if self.pad_if_needed and img.size[1] < self.size[0]: + img = F.pad(img, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode) + tgt = F.pad(tgt, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode) + + i, j, h, w = self.get_params(img, self.size) + + return F.crop(img, i, j, h, w), F.crop(tgt, i, j, h, w) + + def __repr__(self): + return self.__class__.__name__ + '(size={0}, padding={1})'.format(self.size, self.padding) + + +class RandomHorizontalFlip(object): + """Horizontally flip the given PIL Image randomly with a given probability. + + Args: + p (float): probability of the image being flipped. Default value is 0.5 + """ + + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be flipped. + + Returns: + PIL Image: Randomly flipped image. + """ + if random.random() < self.p: + return F.hflip(img), F.hflip(tgt) + + return img, tgt + + def __repr__(self): + return self.__class__.__name__ + '(p={})'.format(self.p) + + +class RandomVerticalFlip(object): + """Vertically flip the given PIL Image randomly with a given probability. + + Args: + p (float): probability of the image being flipped. Default value is 0.5 + """ + + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Image to be flipped. + + Returns: + PIL Image: Randomly flipped image. + """ + if random.random() < self.p: + return F.vflip(img), F.vflip(tgt) + return img, tgt + + def __repr__(self): + return self.__class__.__name__ + '(p={})'.format(self.p) + + +class Lambda(object): + """Apply a user-defined lambda as a transform. + + Args: + lambd (function): Lambda/function to be used for transform. + """ + + def __init__(self, lambd): + assert callable(lambd), repr(type(lambd).__name__) + " object is not callable" + self.lambd = lambd + + def __call__(self, img, tgt): + return self.lambd(img, tgt) + + def __repr__(self): + return self.__class__.__name__ + '()' + + +class ColorJitter(object): + """Randomly change the brightness, contrast and saturation of an image. + + Args: + brightness (float or tuple of float (min, max)): How much to jitter brightness. + brightness_factor is chosen uniformly from [max(0, 1 - brightness), 1 + brightness] + or the given [min, max]. Should be non negative numbers. + contrast (float or tuple of float (min, max)): How much to jitter contrast. + contrast_factor is chosen uniformly from [max(0, 1 - contrast), 1 + contrast] + or the given [min, max]. Should be non negative numbers. + saturation (float or tuple of float (min, max)): How much to jitter saturation. + saturation_factor is chosen uniformly from [max(0, 1 - saturation), 1 + saturation] + or the given [min, max]. Should be non negative numbers. + hue (float or tuple of float (min, max)): How much to jitter hue. + hue_factor is chosen uniformly from [-hue, hue] or the given [min, max]. + Should have 0<= hue <= 0.5 or -0.5 <= min <= max <= 0.5. + """ + def __init__(self, brightness=0, contrast=0, saturation=0, hue=0): + self.brightness = self._check_input(brightness, 'brightness') + self.contrast = self._check_input(contrast, 'contrast') + self.saturation = self._check_input(saturation, 'saturation') + self.hue = self._check_input(hue, 'hue', center=0, bound=(-0.5, 0.5), + clip_first_on_zero=False) + + def _check_input(self, value, name, center=1, bound=(0, float('inf')), clip_first_on_zero=True): + if isinstance(value, numbers.Number): + if value < 0: + raise ValueError("If {} is a single number, it must be non negative.".format(name)) + value = [center - value, center + value] + if clip_first_on_zero: + value[0] = max(value[0], 0) + elif isinstance(value, (tuple, list)) and len(value) == 2: + if not bound[0] <= value[0] <= value[1] <= bound[1]: + raise ValueError("{} values should be between {}".format(name, bound)) + else: + raise TypeError("{} should be a single number or a list/tuple with lenght 2.".format(name)) + + # if value is 0 or (1., 1.) for brightness/contrast/saturation + # or (0., 0.) for hue, do nothing + if value[0] == value[1] == center: + value = None + return value + + @staticmethod + def get_params(brightness, contrast, saturation, hue): + """Get a randomized transform to be applied on image. + + Arguments are same as that of __init__. + + Returns: + Transform which randomly adjusts brightness, contrast and + saturation in a random order. + """ + transforms = [] + + if brightness is not None: + brightness_factor = random.uniform(brightness[0], brightness[1]) + transforms.append(Lambda(lambda img, tgt: (F.adjust_brightness(img, brightness_factor), tgt))) + + if contrast is not None: + contrast_factor = random.uniform(contrast[0], contrast[1]) + transforms.append(Lambda(lambda img, tgt: (F.adjust_contrast(img, contrast_factor), tgt))) + + if saturation is not None: + saturation_factor = random.uniform(saturation[0], saturation[1]) + transforms.append(Lambda(lambda img, tgt: (F.adjust_saturation(img, saturation_factor), tgt))) + + if hue is not None: + hue_factor = random.uniform(hue[0], hue[1]) + transforms.append(Lambda(lambda img, tgt: (F.adjust_hue(img, hue_factor), tgt))) + + random.shuffle(transforms) + transform = Compose(transforms) + + return transform + + def __call__(self, img, tgt): + """ + Args: + img (PIL Image): Input image. + + Returns: + PIL Image: Color jittered image. + """ + transform = self.get_params(self.brightness, self.contrast, + self.saturation, self.hue) + return transform(img, tgt) + + def __repr__(self): + format_string = self.__class__.__name__ + '(' + format_string += 'brightness={0}'.format(self.brightness) + format_string += ', contrast={0}'.format(self.contrast) + format_string += ', saturation={0}'.format(self.saturation) + format_string += ', hue={0})'.format(self.hue) + return format_string + + +class Normalize(object): + """Normalize a tensor image with mean and standard deviation. + Given mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels, this transform + will normalize each channel of the input ``torch.*Tensor`` i.e. + ``input[channel] = (input[channel] - mean[channel]) / std[channel]`` + + .. note:: + This transform acts out of place, i.e., it does not mutates the input tensor. + + Args: + mean (sequence): Sequence of means for each channel. + std (sequence): Sequence of standard deviations for each channel. + """ + + def __init__(self, mean, std, inplace=False): + self.mean = mean + self.std = std + self.inplace = inplace + + def __call__(self, img, tgt): + """ + Args: + tensor (Tensor): Tensor image of size (C, H, W) to be normalized. + + Returns: + Tensor: Normalized Tensor image. + """ + # return F.normalize(img, self.mean, self.std, self.inplace), tgt + return F.normalize(img, self.mean, self.std), tgt + + def __repr__(self): + return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std) + + +class ToTensor(object): + """Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor. + + Converts a PIL Image or numpy.ndarray (H x W x C) in the range + [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] + if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) + or if the numpy.ndarray has dtype = np.uint8 + + In the other cases, tensors are returned without scaling. + """ + + def __call__(self, img, tgt): + """ + Args: + pic (PIL Image or numpy.ndarray): Image to be converted to tensor. + + Returns: + Tensor: Converted image. + """ + return F.to_tensor(img), tgt + + def __repr__(self): + return self.__class__.__name__ + '()' \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/generate_visualizations.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/generate_visualizations.py new file mode 100644 index 0000000000000000000000000000000000000000..fdde00228f411732ab0e8bf18e9330bc066f7176 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/generate_visualizations.py @@ -0,0 +1,208 @@ +import os +from tqdm import tqdm +import h5py + +import argparse + +# Import saliency methods and models +from misc_functions import * + +from ViT_explanation_generator import Baselines, LRP +from ViT_new import vit_base_patch16_224 +from ViT_LRP import vit_base_patch16_224 as vit_LRP +from ViT_orig_LRP import vit_base_patch16_224 as vit_orig_LRP + +from torchvision.datasets import ImageNet + + +def normalize(tensor, + mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]): + dtype = tensor.dtype + mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device) + std = torch.as_tensor(std, dtype=dtype, device=tensor.device) + tensor.sub_(mean[None, :, None, None]).div_(std[None, :, None, None]) + return tensor + + +def compute_saliency_and_save(args): + first = True + with h5py.File(os.path.join(args.method_dir, 'results.hdf5'), 'a') as f: + data_cam = f.create_dataset('vis', + (1, 1, 224, 224), + maxshape=(None, 1, 224, 224), + dtype=np.float32, + compression="gzip") + data_image = f.create_dataset('image', + (1, 3, 224, 224), + maxshape=(None, 3, 224, 224), + dtype=np.float32, + compression="gzip") + data_target = f.create_dataset('target', + (1,), + maxshape=(None,), + dtype=np.int32, + compression="gzip") + for batch_idx, (data, target) in enumerate(tqdm(sample_loader)): + if first: + first = False + data_cam.resize(data_cam.shape[0] + data.shape[0] - 1, axis=0) + data_image.resize(data_image.shape[0] + data.shape[0] - 1, axis=0) + data_target.resize(data_target.shape[0] + data.shape[0] - 1, axis=0) + else: + data_cam.resize(data_cam.shape[0] + data.shape[0], axis=0) + data_image.resize(data_image.shape[0] + data.shape[0], axis=0) + data_target.resize(data_target.shape[0] + data.shape[0], axis=0) + + # Add data + data_image[-data.shape[0]:] = data.data.cpu().numpy() + data_target[-data.shape[0]:] = target.data.cpu().numpy() + + target = target.to(device) + + data = normalize(data) + data = data.to(device) + data.requires_grad_() + + index = None + if args.vis_class == 'target': + index = target + + if args.method == 'rollout': + Res = baselines.generate_rollout(data, start_layer=1).reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == 'lrp': + Res = lrp.generate_LRP(data, start_layer=1, index=index).reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == 'transformer_attribution': + Res = lrp.generate_LRP(data, start_layer=1, method="grad", index=index).reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == 'full_lrp': + Res = orig_lrp.generate_LRP(data, method="full", index=index).reshape(data.shape[0], 1, 224, 224) + # Res = Res - Res.mean() + + elif args.method == 'lrp_last_layer': + Res = orig_lrp.generate_LRP(data, method="last_layer", is_ablation=args.is_ablation, index=index) \ + .reshape(data.shape[0], 1, 14, 14) + # Res = Res - Res.mean() + + elif args.method == 'attn_last_layer': + Res = lrp.generate_LRP(data, method="last_layer_attn", is_ablation=args.is_ablation) \ + .reshape(data.shape[0], 1, 14, 14) + + elif args.method == 'attn_gradcam': + Res = baselines.generate_cam_attn(data, index=index).reshape(data.shape[0], 1, 14, 14) + + if args.method != 'full_lrp' and args.method != 'input_grads': + Res = torch.nn.functional.interpolate(Res, scale_factor=16, mode='bilinear').cuda() + Res = (Res - Res.min()) / (Res.max() - Res.min()) + + data_cam[-data.shape[0]:] = Res.data.cpu().numpy() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Train a segmentation') + parser.add_argument('--batch-size', type=int, + default=1, + help='') + parser.add_argument('--method', type=str, + default='grad_rollout', + choices=['rollout', 'lrp', 'transformer_attribution', 'full_lrp', 'lrp_last_layer', + 'attn_last_layer', 'attn_gradcam'], + help='') + parser.add_argument('--lmd', type=float, + default=10, + help='') + parser.add_argument('--vis-class', type=str, + default='top', + choices=['top', 'target', 'index'], + help='') + parser.add_argument('--class-id', type=int, + default=0, + help='') + parser.add_argument('--cls-agn', action='store_true', + default=False, + help='') + parser.add_argument('--no-ia', action='store_true', + default=False, + help='') + parser.add_argument('--no-fx', action='store_true', + default=False, + help='') + parser.add_argument('--no-fgx', action='store_true', + default=False, + help='') + parser.add_argument('--no-m', action='store_true', + default=False, + help='') + parser.add_argument('--no-reg', action='store_true', + default=False, + help='') + parser.add_argument('--is-ablation', type=bool, + default=False, + help='') + parser.add_argument('--imagenet-validation-path', type=str, + required=True, + help='') + args = parser.parse_args() + + # PATH variables + PATH = os.path.dirname(os.path.abspath(__file__)) + '/' + os.makedirs(os.path.join(PATH, 'visualizations'), exist_ok=True) + + try: + os.remove(os.path.join(PATH, 'visualizations/{}/{}/results.hdf5'.format(args.method, + args.vis_class))) + except OSError: + pass + + + os.makedirs(os.path.join(PATH, 'visualizations/{}'.format(args.method)), exist_ok=True) + if args.vis_class == 'index': + os.makedirs(os.path.join(PATH, 'visualizations/{}/{}_{}'.format(args.method, + args.vis_class, + args.class_id)), exist_ok=True) + args.method_dir = os.path.join(PATH, 'visualizations/{}/{}_{}'.format(args.method, + args.vis_class, + args.class_id)) + else: + ablation_fold = 'ablation' if args.is_ablation else 'not_ablation' + os.makedirs(os.path.join(PATH, 'visualizations/{}/{}/{}'.format(args.method, + args.vis_class, ablation_fold)), exist_ok=True) + args.method_dir = os.path.join(PATH, 'visualizations/{}/{}/{}'.format(args.method, + args.vis_class, ablation_fold)) + + cuda = torch.cuda.is_available() + device = torch.device("cuda" if cuda else "cpu") + + # Model + model = vit_base_patch16_224(pretrained=True).cuda() + baselines = Baselines(model) + + # LRP + model_LRP = vit_LRP(pretrained=True).cuda() + model_LRP.eval() + lrp = LRP(model_LRP) + + # orig LRP + model_orig_LRP = vit_orig_LRP(pretrained=True).cuda() + model_orig_LRP.eval() + orig_lrp = LRP(model_orig_LRP) + + # Dataset loader for sample images + transform = transforms.Compose([ + transforms.Resize((224, 224)), + transforms.ToTensor(), + ]) + + imagenet_ds = ImageNet(args.imagenet_validation_path, split='val', download=False, transform=transform) + sample_loader = torch.utils.data.DataLoader( + imagenet_ds, + batch_size=args.batch_size, + shuffle=False, + num_workers=4 + ) + + compute_saliency_and_save(args) diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/helpers.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..e2840ea741a5dad1473c14fba1edfd68d91a12d9 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/helpers.py @@ -0,0 +1,295 @@ +""" Model creation / weight loading / state_dict helpers + +Hacked together by / Copyright 2020 Ross Wightman +""" +import logging +import os +import math +from collections import OrderedDict +from copy import deepcopy +from typing import Callable + +import torch +import torch.nn as nn +import torch.utils.model_zoo as model_zoo + +_logger = logging.getLogger(__name__) + + +def load_state_dict(checkpoint_path, use_ema=False): + if checkpoint_path and os.path.isfile(checkpoint_path): + checkpoint = torch.load(checkpoint_path, map_location='cpu') + state_dict_key = 'state_dict' + if isinstance(checkpoint, dict): + if use_ema and 'state_dict_ema' in checkpoint: + state_dict_key = 'state_dict_ema' + if state_dict_key and state_dict_key in checkpoint: + new_state_dict = OrderedDict() + for k, v in checkpoint[state_dict_key].items(): + # strip `module.` prefix + name = k[7:] if k.startswith('module') else k + new_state_dict[name] = v + state_dict = new_state_dict + else: + state_dict = checkpoint + _logger.info("Loaded {} from checkpoint '{}'".format(state_dict_key, checkpoint_path)) + return state_dict + else: + _logger.error("No checkpoint found at '{}'".format(checkpoint_path)) + raise FileNotFoundError() + + +def load_checkpoint(model, checkpoint_path, use_ema=False, strict=True): + state_dict = load_state_dict(checkpoint_path, use_ema) + model.load_state_dict(state_dict, strict=strict) + + +def resume_checkpoint(model, checkpoint_path, optimizer=None, loss_scaler=None, log_info=True): + resume_epoch = None + if os.path.isfile(checkpoint_path): + checkpoint = torch.load(checkpoint_path, map_location='cpu') + if isinstance(checkpoint, dict) and 'state_dict' in checkpoint: + if log_info: + _logger.info('Restoring model state from checkpoint...') + new_state_dict = OrderedDict() + for k, v in checkpoint['state_dict'].items(): + name = k[7:] if k.startswith('module') else k + new_state_dict[name] = v + model.load_state_dict(new_state_dict) + + if optimizer is not None and 'optimizer' in checkpoint: + if log_info: + _logger.info('Restoring optimizer state from checkpoint...') + optimizer.load_state_dict(checkpoint['optimizer']) + + if loss_scaler is not None and loss_scaler.state_dict_key in checkpoint: + if log_info: + _logger.info('Restoring AMP loss scaler state from checkpoint...') + loss_scaler.load_state_dict(checkpoint[loss_scaler.state_dict_key]) + + if 'epoch' in checkpoint: + resume_epoch = checkpoint['epoch'] + if 'version' in checkpoint and checkpoint['version'] > 1: + resume_epoch += 1 # start at the next epoch, old checkpoints incremented before save + + if log_info: + _logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, checkpoint['epoch'])) + else: + model.load_state_dict(checkpoint) + if log_info: + _logger.info("Loaded checkpoint '{}'".format(checkpoint_path)) + return resume_epoch + else: + _logger.error("No checkpoint found at '{}'".format(checkpoint_path)) + raise FileNotFoundError() + + +def load_pretrained(model, cfg=None, num_classes=1000, in_chans=3, filter_fn=None, strict=True): + if cfg is None: + cfg = getattr(model, 'default_cfg') + if cfg is None or 'url' not in cfg or not cfg['url']: + _logger.warning("Pretrained model URL is invalid, using random initialization.") + return + + state_dict = model_zoo.load_url(cfg['url'], progress=False, map_location='cpu') + + if filter_fn is not None: + state_dict = filter_fn(state_dict) + + if in_chans == 1: + conv1_name = cfg['first_conv'] + _logger.info('Converting first conv (%s) pretrained weights from 3 to 1 channel' % conv1_name) + conv1_weight = state_dict[conv1_name + '.weight'] + # Some weights are in torch.half, ensure it's float for sum on CPU + conv1_type = conv1_weight.dtype + conv1_weight = conv1_weight.float() + O, I, J, K = conv1_weight.shape + if I > 3: + assert conv1_weight.shape[1] % 3 == 0 + # For models with space2depth stems + conv1_weight = conv1_weight.reshape(O, I // 3, 3, J, K) + conv1_weight = conv1_weight.sum(dim=2, keepdim=False) + else: + conv1_weight = conv1_weight.sum(dim=1, keepdim=True) + conv1_weight = conv1_weight.to(conv1_type) + state_dict[conv1_name + '.weight'] = conv1_weight + elif in_chans != 3: + conv1_name = cfg['first_conv'] + conv1_weight = state_dict[conv1_name + '.weight'] + conv1_type = conv1_weight.dtype + conv1_weight = conv1_weight.float() + O, I, J, K = conv1_weight.shape + if I != 3: + _logger.warning('Deleting first conv (%s) from pretrained weights.' % conv1_name) + del state_dict[conv1_name + '.weight'] + strict = False + else: + # NOTE this strategy should be better than random init, but there could be other combinations of + # the original RGB input layer weights that'd work better for specific cases. + _logger.info('Repeating first conv (%s) weights in channel dim.' % conv1_name) + repeat = int(math.ceil(in_chans / 3)) + conv1_weight = conv1_weight.repeat(1, repeat, 1, 1)[:, :in_chans, :, :] + conv1_weight *= (3 / float(in_chans)) + conv1_weight = conv1_weight.to(conv1_type) + state_dict[conv1_name + '.weight'] = conv1_weight + + classifier_name = cfg['classifier'] + if num_classes == 1000 and cfg['num_classes'] == 1001: + # special case for imagenet trained models with extra background class in pretrained weights + classifier_weight = state_dict[classifier_name + '.weight'] + state_dict[classifier_name + '.weight'] = classifier_weight[1:] + classifier_bias = state_dict[classifier_name + '.bias'] + state_dict[classifier_name + '.bias'] = classifier_bias[1:] + elif num_classes != cfg['num_classes']: + # completely discard fully connected for all other differences between pretrained and created model + del state_dict[classifier_name + '.weight'] + del state_dict[classifier_name + '.bias'] + strict = False + + model.load_state_dict(state_dict, strict=strict) + + +def extract_layer(model, layer): + layer = layer.split('.') + module = model + if hasattr(model, 'module') and layer[0] != 'module': + module = model.module + if not hasattr(model, 'module') and layer[0] == 'module': + layer = layer[1:] + for l in layer: + if hasattr(module, l): + if not l.isdigit(): + module = getattr(module, l) + else: + module = module[int(l)] + else: + return module + return module + + +def set_layer(model, layer, val): + layer = layer.split('.') + module = model + if hasattr(model, 'module') and layer[0] != 'module': + module = model.module + lst_index = 0 + module2 = module + for l in layer: + if hasattr(module2, l): + if not l.isdigit(): + module2 = getattr(module2, l) + else: + module2 = module2[int(l)] + lst_index += 1 + lst_index -= 1 + for l in layer[:lst_index]: + if not l.isdigit(): + module = getattr(module, l) + else: + module = module[int(l)] + l = layer[lst_index] + setattr(module, l, val) + + +def adapt_model_from_string(parent_module, model_string): + separator = '***' + state_dict = {} + lst_shape = model_string.split(separator) + for k in lst_shape: + k = k.split(':') + key = k[0] + shape = k[1][1:-1].split(',') + if shape[0] != '': + state_dict[key] = [int(i) for i in shape] + + new_module = deepcopy(parent_module) + for n, m in parent_module.named_modules(): + old_module = extract_layer(parent_module, n) + if isinstance(old_module, nn.Conv2d) or isinstance(old_module, Conv2dSame): + if isinstance(old_module, Conv2dSame): + conv = Conv2dSame + else: + conv = nn.Conv2d + s = state_dict[n + '.weight'] + in_channels = s[1] + out_channels = s[0] + g = 1 + if old_module.groups > 1: + in_channels = out_channels + g = in_channels + new_conv = conv( + in_channels=in_channels, out_channels=out_channels, kernel_size=old_module.kernel_size, + bias=old_module.bias is not None, padding=old_module.padding, dilation=old_module.dilation, + groups=g, stride=old_module.stride) + set_layer(new_module, n, new_conv) + if isinstance(old_module, nn.BatchNorm2d): + new_bn = nn.BatchNorm2d( + num_features=state_dict[n + '.weight'][0], eps=old_module.eps, momentum=old_module.momentum, + affine=old_module.affine, track_running_stats=True) + set_layer(new_module, n, new_bn) + if isinstance(old_module, nn.Linear): + # FIXME extra checks to ensure this is actually the FC classifier layer and not a diff Linear layer? + num_features = state_dict[n + '.weight'][1] + new_fc = nn.Linear( + in_features=num_features, out_features=old_module.out_features, bias=old_module.bias is not None) + set_layer(new_module, n, new_fc) + if hasattr(new_module, 'num_features'): + new_module.num_features = num_features + new_module.eval() + parent_module.eval() + + return new_module + + +def adapt_model_from_file(parent_module, model_variant): + adapt_file = os.path.join(os.path.dirname(__file__), 'pruned', model_variant + '.txt') + with open(adapt_file, 'r') as f: + return adapt_model_from_string(parent_module, f.read().strip()) + + +def build_model_with_cfg( + model_cls: Callable, + variant: str, + pretrained: bool, + default_cfg: dict, + model_cfg: dict = None, + feature_cfg: dict = None, + pretrained_strict: bool = True, + pretrained_filter_fn: Callable = None, + **kwargs): + pruned = kwargs.pop('pruned', False) + features = False + feature_cfg = feature_cfg or {} + + if kwargs.pop('features_only', False): + features = True + feature_cfg.setdefault('out_indices', (0, 1, 2, 3, 4)) + if 'out_indices' in kwargs: + feature_cfg['out_indices'] = kwargs.pop('out_indices') + + model = model_cls(**kwargs) if model_cfg is None else model_cls(cfg=model_cfg, **kwargs) + model.default_cfg = deepcopy(default_cfg) + + if pruned: + model = adapt_model_from_file(model, variant) + + if pretrained: + load_pretrained( + model, + num_classes=kwargs.get('num_classes', 0), + in_chans=kwargs.get('in_chans', 3), + filter_fn=pretrained_filter_fn, strict=pretrained_strict) + + if features: + feature_cls = FeatureListNet + if 'feature_cls' in feature_cfg: + feature_cls = feature_cfg.pop('feature_cls') + if isinstance(feature_cls, str): + feature_cls = feature_cls.lower() + if 'hook' in feature_cls: + feature_cls = FeatureHookNet + else: + assert False, f'Unknown feature class {feature_cls}' + model = feature_cls(model, **feature_cfg) + + return model \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/layer_helpers.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/layer_helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..c7d3208dd002cbd75da7a8992f2b889a891c6fa1 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/layer_helpers.py @@ -0,0 +1,21 @@ +""" Layer/Module Helpers +Hacked together by / Copyright 2020 Ross Wightman +""" +from itertools import repeat +import collections.abc + + +# From PyTorch internals +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable): + return x + return tuple(repeat(x, n)) + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = _ntuple diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/misc_functions.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/misc_functions.py new file mode 100644 index 0000000000000000000000000000000000000000..1971eb1b4043af4ef220315891de83d2d30263d3 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/misc_functions.py @@ -0,0 +1,68 @@ +# +# Copyright (c) 2019 Idiap Research Institute, http://www.idiap.ch/ +# Written by Suraj Srinivas +# + +""" Misc helper functions """ + +import cv2 +import numpy as np +import subprocess + +import torch +import torchvision.transforms as transforms + + +class NormalizeInverse(transforms.Normalize): + # Undo normalization on images + + def __init__(self, mean, std): + mean = torch.as_tensor(mean) + std = torch.as_tensor(std) + std_inv = 1 / (std + 1e-7) + mean_inv = -mean * std_inv + super(NormalizeInverse, self).__init__(mean=mean_inv, std=std_inv) + + def __call__(self, tensor): + return super(NormalizeInverse, self).__call__(tensor.clone()) + + +def create_folder(folder_name): + try: + subprocess.call(['mkdir', '-p', folder_name]) + except OSError: + None + + +def save_saliency_map(image, saliency_map, filename): + """ + Save saliency map on image. + + Args: + image: Tensor of size (3,H,W) + saliency_map: Tensor of size (1,H,W) + filename: string with complete path and file extension + + """ + + image = image.data.cpu().numpy() + saliency_map = saliency_map.data.cpu().numpy() + + saliency_map = saliency_map - saliency_map.min() + saliency_map = saliency_map / saliency_map.max() + saliency_map = saliency_map.clip(0, 1) + + saliency_map = np.uint8(saliency_map * 255).transpose(1, 2, 0) + saliency_map = cv2.resize(saliency_map, (224, 224)) + + image = np.uint8(image * 255).transpose(1, 2, 0) + image = cv2.resize(image, (224, 224)) + + # Apply JET colormap + color_heatmap = cv2.applyColorMap(saliency_map, cv2.COLORMAP_JET) + + # Combine image with heatmap + img_with_heatmap = np.float32(color_heatmap) + np.float32(image) + img_with_heatmap = img_with_heatmap / np.max(img_with_heatmap) + + cv2.imwrite(filename, np.uint8(255 * img_with_heatmap)) diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__init__.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/__init__.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c022ecdbdb6a5681e71e1d9763006841686e5de3 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/__init__.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_lrp.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_lrp.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f986f7a7fe06c32c42e9d5dffb5f00662de0b49 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_lrp.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_ours.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_ours.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65b3b56a58f681f80c6e0cc1720ea572a2d59a39 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/__pycache__/layers_ours.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_lrp.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_lrp.py new file mode 100644 index 0000000000000000000000000000000000000000..7358b44674639b980d580dfec710a6f7f6439152 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_lrp.py @@ -0,0 +1,261 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = ['forward_hook', 'Clone', 'Add', 'Cat', 'ReLU', 'GELU', 'Dropout', 'BatchNorm2d', 'Linear', 'MaxPool2d', + 'AdaptiveAvgPool2d', 'AvgPool2d', 'Conv2d', 'Sequential', 'safe_divide', 'einsum', 'Softmax', 'IndexSelect', + 'LayerNorm', 'AddEye'] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + +class ReLU(nn.ReLU, RelProp): + pass + +class GELU(nn.GELU, RelProp): + pass + +class Softmax(nn.Softmax, RelProp): + pass + +class LayerNorm(nn.LayerNorm, RelProp): + pass + +class Dropout(nn.Dropout, RelProp): + pass + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + +class LayerNorm(nn.LayerNorm, RelProp): + pass + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__('dim', dim) + self.__setattr__('indices', indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__('num', num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__('dim', dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + (self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + self.eps).pow(0.5)) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * torch.autograd.grad(Z1, x1, S1)[0] + C2 = x2 * torch.autograd.grad(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] - 2 * self.padding[0] + self.kernel_size[0]) + + return F.conv_transpose2d(DY, weight, stride=self.stride, padding=self.padding, output_padding=output_padding) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = self.X * 0 + \ + torch.min(torch.min(torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3, + keepdim=True)[0] + H = self.X * 0 + \ + torch.max(torch.max(torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3, + keepdim=True)[0] + Za = torch.conv2d(X, self.weight, bias=None, stride=self.stride, padding=self.padding) - \ + torch.conv2d(L, pw, bias=None, stride=self.stride, padding=self.padding) - \ + torch.conv2d(H, nw, bias=None, stride=self.stride, padding=self.padding) + 1e-9 + + S = R / Za + C = X * self.gradprop2(S, self.weight) - L * self.gradprop2(S, pw) - H * self.gradprop2(S, nw) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d(x1, w1, bias=None, stride=self.stride, padding=self.padding) + Z2 = F.conv2d(x2, w2, bias=None, stride=self.stride, padding=self.padding) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_ours.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_ours.py new file mode 100644 index 0000000000000000000000000000000000000000..fd7694fe88c4ee2b4d7c38d5fa6e0f7d8c2eebf6 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/modules/layers_ours.py @@ -0,0 +1,280 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = ['forward_hook', 'Clone', 'Add', 'Cat', 'ReLU', 'GELU', 'Dropout', 'BatchNorm2d', 'Linear', 'MaxPool2d', + 'AdaptiveAvgPool2d', 'AvgPool2d', 'Conv2d', 'Sequential', 'safe_divide', 'einsum', 'Softmax', 'IndexSelect', + 'LayerNorm', 'AddEye'] + + +def safe_divide(a, b): + den = b.clamp(min=1e-9) + b.clamp(max=1e-9) + den = den + den.eq(0).type(den.type()) * 1e-9 + return a / den * b.ne(0).type(b.type()) + + +def forward_hook(self, input, output): + if type(input[0]) in (list, tuple): + self.X = [] + for i in input[0]: + x = i.detach() + x.requires_grad = True + self.X.append(x) + else: + self.X = input[0].detach() + self.X.requires_grad = True + + self.Y = output + + +def backward_hook(self, grad_input, grad_output): + self.grad_input = grad_input + self.grad_output = grad_output + + +class RelProp(nn.Module): + def __init__(self): + super(RelProp, self).__init__() + # if not self.training: + self.register_forward_hook(forward_hook) + + def gradprop(self, Z, X, S): + C = torch.autograd.grad(Z, X, S, retain_graph=True) + return C + + def relprop(self, R, alpha): + return R + +class RelPropSimple(RelProp): + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + +class AddEye(RelPropSimple): + # input of shape B, C, seq_len, seq_len + def forward(self, input): + return input + torch.eye(input.shape[2]).expand_as(input).to(input.device) + +class ReLU(nn.ReLU, RelProp): + pass + +class GELU(nn.GELU, RelProp): + pass + +class Softmax(nn.Softmax, RelProp): + pass + +class LayerNorm(nn.LayerNorm, RelProp): + pass + +class Dropout(nn.Dropout, RelProp): + pass + + +class MaxPool2d(nn.MaxPool2d, RelPropSimple): + pass + +class LayerNorm(nn.LayerNorm, RelProp): + pass + +class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d, RelPropSimple): + pass + + +class AvgPool2d(nn.AvgPool2d, RelPropSimple): + pass + + +class Add(RelPropSimple): + def forward(self, inputs): + return torch.add(*inputs) + + def relprop(self, R, alpha): + Z = self.forward(self.X) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + a = self.X[0] * C[0] + b = self.X[1] * C[1] + + a_sum = a.sum() + b_sum = b.sum() + + a_fact = safe_divide(a_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + b_fact = safe_divide(b_sum.abs(), a_sum.abs() + b_sum.abs()) * R.sum() + + a = a * safe_divide(a_fact, a.sum()) + b = b * safe_divide(b_fact, b.sum()) + + outputs = [a, b] + + return outputs + +class einsum(RelPropSimple): + def __init__(self, equation): + super().__init__() + self.equation = equation + def forward(self, *operands): + return torch.einsum(self.equation, *operands) + +class IndexSelect(RelProp): + def forward(self, inputs, dim, indices): + self.__setattr__('dim', dim) + self.__setattr__('indices', indices) + + return torch.index_select(inputs, dim, indices) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim, self.indices) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + if torch.is_tensor(self.X) == False: + outputs = [] + outputs.append(self.X[0] * C[0]) + outputs.append(self.X[1] * C[1]) + else: + outputs = self.X * (C[0]) + return outputs + + + +class Clone(RelProp): + def forward(self, input, num): + self.__setattr__('num', num) + outputs = [] + for _ in range(num): + outputs.append(input) + + return outputs + + def relprop(self, R, alpha): + Z = [] + for _ in range(self.num): + Z.append(self.X) + S = [safe_divide(r, z) for r, z in zip(R, Z)] + C = self.gradprop(Z, self.X, S)[0] + + R = self.X * C + + return R + +class Cat(RelProp): + def forward(self, inputs, dim): + self.__setattr__('dim', dim) + return torch.cat(inputs, dim) + + def relprop(self, R, alpha): + Z = self.forward(self.X, self.dim) + S = safe_divide(R, Z) + C = self.gradprop(Z, self.X, S) + + outputs = [] + for x, c in zip(self.X, C): + outputs.append(x * c) + + return outputs + + +class Sequential(nn.Sequential): + def relprop(self, R, alpha): + for m in reversed(self._modules.values()): + R = m.relprop(R, alpha) + return R + +class BatchNorm2d(nn.BatchNorm2d, RelProp): + def relprop(self, R, alpha): + X = self.X + beta = 1 - alpha + weight = self.weight.unsqueeze(0).unsqueeze(2).unsqueeze(3) / ( + (self.running_var.unsqueeze(0).unsqueeze(2).unsqueeze(3).pow(2) + self.eps).pow(0.5)) + Z = X * weight + 1e-9 + S = R / Z + Ca = S * weight + R = self.X * (Ca) + return R + + +class Linear(nn.Linear, RelProp): + def relprop(self, R, alpha): + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.linear(x1, w1) + Z2 = F.linear(x2, w2) + S1 = safe_divide(R, Z1 + Z2) + S2 = safe_divide(R, Z1 + Z2) + C1 = x1 * torch.autograd.grad(Z1, x1, S1)[0] + C2 = x2 * torch.autograd.grad(Z2, x2, S2)[0] + + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + + return R + + +class Conv2d(nn.Conv2d, RelProp): + def gradprop2(self, DY, weight): + Z = self.forward(self.X) + + output_padding = self.X.size()[2] - ( + (Z.size()[2] - 1) * self.stride[0] - 2 * self.padding[0] + self.kernel_size[0]) + + return F.conv_transpose2d(DY, weight, stride=self.stride, padding=self.padding, output_padding=output_padding) + + def relprop(self, R, alpha): + if self.X.shape[1] == 3: + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + X = self.X + L = self.X * 0 + \ + torch.min(torch.min(torch.min(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3, + keepdim=True)[0] + H = self.X * 0 + \ + torch.max(torch.max(torch.max(self.X, dim=1, keepdim=True)[0], dim=2, keepdim=True)[0], dim=3, + keepdim=True)[0] + Za = torch.conv2d(X, self.weight, bias=None, stride=self.stride, padding=self.padding) - \ + torch.conv2d(L, pw, bias=None, stride=self.stride, padding=self.padding) - \ + torch.conv2d(H, nw, bias=None, stride=self.stride, padding=self.padding) + 1e-9 + + S = R / Za + C = X * self.gradprop2(S, self.weight) - L * self.gradprop2(S, pw) - H * self.gradprop2(S, nw) + R = C + else: + beta = alpha - 1 + pw = torch.clamp(self.weight, min=0) + nw = torch.clamp(self.weight, max=0) + px = torch.clamp(self.X, min=0) + nx = torch.clamp(self.X, max=0) + + def f(w1, w2, x1, x2): + Z1 = F.conv2d(x1, w1, bias=None, stride=self.stride, padding=self.padding) + Z2 = F.conv2d(x2, w2, bias=None, stride=self.stride, padding=self.padding) + S1 = safe_divide(R, Z1) + S2 = safe_divide(R, Z2) + C1 = x1 * self.gradprop(Z1, x1, S1)[0] + C2 = x2 * self.gradprop(Z2, x2, S2)[0] + return C1 + C2 + + activator_relevances = f(pw, nw, px, nx) + inhibitor_relevances = f(nw, pw, px, nx) + + R = alpha * activator_relevances - beta * inhibitor_relevances + return R diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/pertubation_eval_from_hdf5.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/pertubation_eval_from_hdf5.py new file mode 100644 index 0000000000000000000000000000000000000000..8342a9f17d0fda9adf8860940110f69470b6cc6e --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/pertubation_eval_from_hdf5.py @@ -0,0 +1,232 @@ +import torch +import os +from tqdm import tqdm +import numpy as np +import argparse + +# Import saliency methods and models +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_explanation_generator import Baselines +from concept_attention.binary_segmentation_baselines.chefer_vit_explainability.ViT_new import vit_base_patch16_224 +# from models.vgg import vgg19 +import glob + +from dataset.expl_hdf5 import ImagenetResults + + +def normalize(tensor, + mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]): + dtype = tensor.dtype + mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device) + std = torch.as_tensor(std, dtype=dtype, device=tensor.device) + tensor.sub_(mean[None, :, None, None]).div_(std[None, :, None, None]) + return tensor + + +def eval(args): + num_samples = 0 + num_correct_model = np.zeros((len(imagenet_ds,))) + dissimilarity_model = np.zeros((len(imagenet_ds,))) + model_index = 0 + + if args.scale == 'per': + base_size = 224 * 224 + perturbation_steps = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] + elif args.scale == '100': + base_size = 100 + perturbation_steps = [5, 10, 15, 20, 25, 30, 35, 40, 45] + else: + raise Exception('scale not valid') + + num_correct_pertub = np.zeros((9, len(imagenet_ds))) + dissimilarity_pertub = np.zeros((9, len(imagenet_ds))) + logit_diff_pertub = np.zeros((9, len(imagenet_ds))) + prob_diff_pertub = np.zeros((9, len(imagenet_ds))) + perturb_index = 0 + + for batch_idx, (data, vis, target) in enumerate(tqdm(sample_loader)): + # Update the number of samples + num_samples += len(data) + + data = data.to(device) + vis = vis.to(device) + target = target.to(device) + norm_data = normalize(data.clone()) + + # Compute model accuracy + pred = model(norm_data) + pred_probabilities = torch.softmax(pred, dim=1) + pred_org_logit = pred.data.max(1, keepdim=True)[0].squeeze(1) + pred_org_prob = pred_probabilities.data.max(1, keepdim=True)[0].squeeze(1) + pred_class = pred.data.max(1, keepdim=True)[1].squeeze(1) + tgt_pred = (target == pred_class).type(target.type()).data.cpu().numpy() + num_correct_model[model_index:model_index+len(tgt_pred)] = tgt_pred + + probs = torch.softmax(pred, dim=1) + target_probs = torch.gather(probs, 1, target[:, None])[:, 0] + second_probs = probs.data.topk(2, dim=1)[0][:, 1] + temp = torch.log(target_probs / second_probs).data.cpu().numpy() + dissimilarity_model[model_index:model_index+len(temp)] = temp + + if args.wrong: + wid = np.argwhere(tgt_pred == 0).flatten() + if len(wid) == 0: + continue + wid = torch.from_numpy(wid).to(vis.device) + vis = vis.index_select(0, wid) + data = data.index_select(0, wid) + target = target.index_select(0, wid) + + # Save original shape + org_shape = data.shape + + if args.neg: + vis = -vis + + vis = vis.reshape(org_shape[0], -1) + + for i in range(len(perturbation_steps)): + _data = data.clone() + + _, idx = torch.topk(vis, int(base_size * perturbation_steps[i]), dim=-1) + idx = idx.unsqueeze(1).repeat(1, org_shape[1], 1) + _data = _data.reshape(org_shape[0], org_shape[1], -1) + _data = _data.scatter_(-1, idx, 0) + _data = _data.reshape(*org_shape) + + _norm_data = normalize(_data) + + out = model(_norm_data) + + pred_probabilities = torch.softmax(out, dim=1) + pred_prob = pred_probabilities.data.max(1, keepdim=True)[0].squeeze(1) + diff = (pred_prob - pred_org_prob).data.cpu().numpy() + prob_diff_pertub[i, perturb_index:perturb_index+len(diff)] = diff + + pred_logit = out.data.max(1, keepdim=True)[0].squeeze(1) + diff = (pred_logit - pred_org_logit).data.cpu().numpy() + logit_diff_pertub[i, perturb_index:perturb_index+len(diff)] = diff + + target_class = out.data.max(1, keepdim=True)[1].squeeze(1) + temp = (target == target_class).type(target.type()).data.cpu().numpy() + num_correct_pertub[i, perturb_index:perturb_index+len(temp)] = temp + + probs_pertub = torch.softmax(out, dim=1) + target_probs = torch.gather(probs_pertub, 1, target[:, None])[:, 0] + second_probs = probs_pertub.data.topk(2, dim=1)[0][:, 1] + temp = torch.log(target_probs / second_probs).data.cpu().numpy() + dissimilarity_pertub[i, perturb_index:perturb_index+len(temp)] = temp + + model_index += len(target) + perturb_index += len(target) + + np.save(os.path.join(args.experiment_dir, 'model_hits.npy'), num_correct_model) + np.save(os.path.join(args.experiment_dir, 'model_dissimilarities.npy'), dissimilarity_model) + np.save(os.path.join(args.experiment_dir, 'perturbations_hits.npy'), num_correct_pertub[:, :perturb_index]) + np.save(os.path.join(args.experiment_dir, 'perturbations_dissimilarities.npy'), dissimilarity_pertub[:, :perturb_index]) + np.save(os.path.join(args.experiment_dir, 'perturbations_logit_diff.npy'), logit_diff_pertub[:, :perturb_index]) + np.save(os.path.join(args.experiment_dir, 'perturbations_prob_diff.npy'), prob_diff_pertub[:, :perturb_index]) + + print(np.mean(num_correct_model), np.std(num_correct_model)) + print(np.mean(dissimilarity_model), np.std(dissimilarity_model)) + print(perturbation_steps) + print(np.mean(num_correct_pertub, axis=1), np.std(num_correct_pertub, axis=1)) + print(np.mean(dissimilarity_pertub, axis=1), np.std(dissimilarity_pertub, axis=1)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Train a segmentation') + parser.add_argument('--batch-size', type=int, + default=16, + help='') + parser.add_argument('--neg', type=bool, + default=True, + help='') + parser.add_argument('--value', action='store_true', + default=False, + help='') + parser.add_argument('--scale', type=str, + default='per', + choices=['per', '100'], + help='') + parser.add_argument('--method', type=str, + default='grad_rollout', + choices=['rollout', 'lrp', 'transformer_attribution', 'full_lrp', 'v_gradcam', 'lrp_last_layer', + 'lrp_second_layer', 'gradcam', + 'attn_last_layer', 'attn_gradcam', 'input_grads'], + help='') + parser.add_argument('--vis-class', type=str, + default='top', + choices=['top', 'target', 'index'], + help='') + parser.add_argument('--wrong', action='store_true', + default=False, + help='') + parser.add_argument('--class-id', type=int, + default=0, + help='') + parser.add_argument('--is-ablation', type=bool, + default=False, + help='') + args = parser.parse_args() + + torch.multiprocessing.set_start_method('spawn') + + # PATH variables + PATH = os.path.dirname(os.path.abspath(__file__)) + '/' + dataset = PATH + 'dataset/' + os.makedirs(os.path.join(PATH, 'experiments'), exist_ok=True) + os.makedirs(os.path.join(PATH, 'experiments/perturbations'), exist_ok=True) + + exp_name = args.method + exp_name += '_neg' if args.neg else '_pos' + print(exp_name) + + if args.vis_class == 'index': + args.runs_dir = os.path.join(PATH, 'experiments/perturbations/{}/{}_{}'.format(exp_name, + args.vis_class, + args.class_id)) + else: + ablation_fold = 'ablation' if args.is_ablation else 'not_ablation' + args.runs_dir = os.path.join(PATH, 'experiments/perturbations/{}/{}/{}'.format(exp_name, + args.vis_class, ablation_fold)) + # args.runs_dir = os.path.join(PATH, 'experiments/perturbations/{}/{}'.format(exp_name, + # args.vis_class)) + + if args.wrong: + args.runs_dir += '_wrong' + + experiments = sorted(glob.glob(os.path.join(args.runs_dir, 'experiment_*'))) + experiment_id = int(experiments[-1].split('_')[-1]) + 1 if experiments else 0 + args.experiment_dir = os.path.join(args.runs_dir, 'experiment_{}'.format(str(experiment_id))) + os.makedirs(args.experiment_dir, exist_ok=True) + + cuda = torch.cuda.is_available() + device = torch.device("cuda" if cuda else "cpu") + + if args.vis_class == 'index': + vis_method_dir = os.path.join(PATH,'visualizations/{}/{}_{}'.format(args.method, + args.vis_class, + args.class_id)) + else: + ablation_fold = 'ablation' if args.is_ablation else 'not_ablation' + vis_method_dir = os.path.join(PATH,'visualizations/{}/{}/{}'.format(args.method, + args.vis_class, ablation_fold)) + # vis_method_dir = os.path.join(PATH, 'visualizations/{}/{}'.format(args.method, + # args.vis_class)) + + # imagenet_ds = ImagenetResults('visualizations/{}'.format(args.method)) + imagenet_ds = ImagenetResults(vis_method_dir) + + # Model + model = vit_base_patch16_224(pretrained=True).cuda() + model.eval() + + save_path = PATH + 'results/' + + sample_loader = torch.utils.data.DataLoader( + imagenet_ds, + batch_size=args.batch_size, + num_workers=2, + shuffle=False) + + eval(args) diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__init__.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/__init__.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72c032129396b44410f09474ae43eeda5005fbfe Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/__init__.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/confusionmatrix.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/confusionmatrix.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..217bdd3d7120645c788363707321b9d1d638cd33 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/confusionmatrix.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/iou.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/iou.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..253283fbafb7d5b0bd37dd341e19917b28748e21 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/iou.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metric.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metric.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..801e28bbf1e5c3002eb288d9bc8a2b28f0c6c873 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metric.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metrices.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metrices.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e0f7280bae0d09ae014c3241464c672d17123762 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/metrices.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/render.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/render.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1b46d9b2a3f52f3b9424a11b0a4f7ddd4cbeaa0 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/render.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/saver.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/saver.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e617d5e4791b49efb3e3969438f7283de2d9307c Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/__pycache__/saver.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/confusionmatrix.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/confusionmatrix.py new file mode 100644 index 0000000000000000000000000000000000000000..0c01ca3eed41967b8c9409694db7ade8be930dad --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/confusionmatrix.py @@ -0,0 +1,88 @@ +import numpy as np +import torch +from . import metric + + +class ConfusionMatrix(metric.Metric): + """Constructs a confusion matrix for a multi-class classification problems. + Does not support multi-label, multi-class problems. + Keyword arguments: + - num_classes (int): number of classes in the classification problem. + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + Modified from: https://github.com/pytorch/tnt/blob/master/torchnet/meter/confusionmeter.py + """ + + def __init__(self, num_classes, normalized=False): + super().__init__() + + self.conf = np.ndarray((num_classes, num_classes), dtype=np.int32) + self.normalized = normalized + self.num_classes = num_classes + self.reset() + + def reset(self): + self.conf.fill(0) + + def add(self, predicted, target): + """Computes the confusion matrix + The shape of the confusion matrix is K x K, where K is the number + of classes. + Keyword arguments: + - predicted (Tensor or numpy.ndarray): Can be an N x K tensor/array of + predicted scores obtained from the model for N examples and K classes, + or an N-tensor/array of integer values between 0 and K-1. + - target (Tensor or numpy.ndarray): Can be an N x K tensor/array of + ground-truth classes for N examples and K classes, or an N-tensor/array + of integer values between 0 and K-1. + """ + # If target and/or predicted are tensors, convert them to numpy arrays + if torch.is_tensor(predicted): + predicted = predicted.cpu().numpy() + if torch.is_tensor(target): + target = target.cpu().numpy() + + assert predicted.shape[0] == target.shape[0], \ + 'number of targets and predicted outputs do not match' + + if np.ndim(predicted) != 1: + assert predicted.shape[1] == self.num_classes, \ + 'number of predictions does not match size of confusion matrix' + predicted = np.argmax(predicted, 1) + else: + assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \ + 'predicted values are not between 0 and k-1' + + if np.ndim(target) != 1: + assert target.shape[1] == self.num_classes, \ + 'Onehot target does not match size of confusion matrix' + assert (target >= 0).all() and (target <= 1).all(), \ + 'in one-hot encoding, target values should be 0 or 1' + assert (target.sum(1) == 1).all(), \ + 'multi-label setting is not supported' + target = np.argmax(target, 1) + else: + assert (target.max() < self.num_classes) and (target.min() >= 0), \ + 'target values are not between 0 and k-1' + + # hack for bincounting 2 arrays together + x = predicted + self.num_classes * target + bincount_2d = np.bincount( + x.astype(np.int32), minlength=self.num_classes**2) + assert bincount_2d.size == self.num_classes**2 + conf = bincount_2d.reshape((self.num_classes, self.num_classes)) + + self.conf += conf + + def value(self): + """ + Returns: + Confustion matrix of K rows and K columns, where rows corresponds + to ground-truth targets and columns corresponds to predicted + targets. + """ + if self.normalized: + conf = self.conf.astype(np.float32) + return conf / conf.sum(1).clip(min=1e-12)[:, None] + else: + return self.conf \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/iou.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/iou.py new file mode 100644 index 0000000000000000000000000000000000000000..4135e15892849edf40a5cdde95e49bb501cf876f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/iou.py @@ -0,0 +1,93 @@ +import torch +import numpy as np +from . import metric +from .confusionmatrix import ConfusionMatrix + + +class IoU(metric.Metric): + """Computes the intersection over union (IoU) per class and corresponding + mean (mIoU). + + Intersection over union (IoU) is a common evaluation metric for semantic + segmentation. The predictions are first accumulated in a confusion matrix + and the IoU is computed from it as follows: + + IoU = true_positive / (true_positive + false_positive + false_negative). + + Keyword arguments: + - num_classes (int): number of classes in the classification problem + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + - ignore_index (int or iterable, optional): Index of the classes to ignore + when computing the IoU. Can be an int, or any iterable of ints. + """ + + def __init__(self, num_classes, normalized=False, ignore_index=None): + super().__init__() + self.conf_metric = ConfusionMatrix(num_classes, normalized) + + if ignore_index is None: + self.ignore_index = None + elif isinstance(ignore_index, int): + self.ignore_index = (ignore_index,) + else: + try: + self.ignore_index = tuple(ignore_index) + except TypeError: + raise ValueError("'ignore_index' must be an int or iterable") + + def reset(self): + self.conf_metric.reset() + + def add(self, predicted, target): + """Adds the predicted and target pair to the IoU metric. + + Keyword arguments: + - predicted (Tensor): Can be a (N, K, H, W) tensor of + predicted scores obtained from the model for N examples and K classes, + or (N, H, W) tensor of integer values between 0 and K-1. + - target (Tensor): Can be a (N, K, H, W) tensor of + target scores for N examples and K classes, or (N, H, W) tensor of + integer values between 0 and K-1. + + """ + # Dimensions check + assert predicted.size(0) == target.size(0), \ + 'number of targets and predicted outputs do not match' + assert predicted.dim() == 3 or predicted.dim() == 4, \ + "predictions must be of dimension (N, H, W) or (N, K, H, W)" + assert target.dim() == 3 or target.dim() == 4, \ + "targets must be of dimension (N, H, W) or (N, K, H, W)" + + # If the tensor is in categorical format convert it to integer format + if predicted.dim() == 4: + _, predicted = predicted.max(1) + if target.dim() == 4: + _, target = target.max(1) + + self.conf_metric.add(predicted.view(-1), target.view(-1)) + + def value(self): + """Computes the IoU and mean IoU. + + The mean computation ignores NaN elements of the IoU array. + + Returns: + Tuple: (IoU, mIoU). The first output is the per class IoU, + for K classes it's numpy.ndarray with K elements. The second output, + is the mean IoU. + """ + conf_matrix = self.conf_metric.value() + if self.ignore_index is not None: + for index in self.ignore_index: + conf_matrix[:, self.ignore_index] = 0 + conf_matrix[self.ignore_index, :] = 0 + true_positive = np.diag(conf_matrix) + false_positive = np.sum(conf_matrix, 0) - true_positive + false_negative = np.sum(conf_matrix, 1) - true_positive + + # Just in case we get a division by 0, ignore/hide the error + with np.errstate(divide='ignore', invalid='ignore'): + iou = true_positive / (true_positive + false_positive + false_negative) + + return iou, np.nanmean(iou) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metric.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metric.py new file mode 100644 index 0000000000000000000000000000000000000000..a820609873ec4fc7c3428e95b19baf97515cf792 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metric.py @@ -0,0 +1,12 @@ +class Metric(object): + """Base class for all metrics. + From: https://github.com/pytorch/tnt/blob/master/torchnet/meter/meter.py + """ + def reset(self): + pass + + def add(self): + pass + + def value(self): + pass \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metrices.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metrices.py new file mode 100644 index 0000000000000000000000000000000000000000..6a8524733e429d29f6e481312cb7827188c98f0a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/metrices.py @@ -0,0 +1,208 @@ +import numpy as np +import torch +from sklearn.metrics import f1_score, average_precision_score +from sklearn.metrics import precision_recall_curve, roc_curve + +SMOOTH = 1e-6 +__all__ = ['get_f1_scores', 'get_ap_scores', 'batch_pix_accuracy', 'batch_intersection_union', 'get_iou', 'get_pr', + 'get_roc', 'get_ap_multiclass'] + + +def get_iou(outputs: torch.Tensor, labels: torch.Tensor): + # You can comment out this line if you are passing tensors of equal shape + # But if you are passing output from UNet or something it will most probably + # be with the BATCH x 1 x H x W shape + outputs = outputs.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + labels = labels.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + + intersection = (outputs & labels).float().sum((1, 2)) # Will be zero if Truth=0 or Prediction=0 + union = (outputs | labels).float().sum((1, 2)) # Will be zzero if both are 0 + + iou = (intersection + SMOOTH) / (union + SMOOTH) # We smooth our devision to avoid 0/0 + + return iou.cpu().numpy() + + +def get_f1_scores(predict, target, ignore_index=-1): + # Tensor process + batch_size = target.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target.data.cpu().numpy().reshape(-1) + pb = predict[target != ignore_index].reshape(batch_size, -1) + tb = target[target != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(np.nan_to_num(f1_score(t, p))) + + return total + + +def get_roc(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(roc_curve(t, p)) + + return total + + +def get_pr(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(precision_recall_curve(t, p)) + + return total + + +def get_ap_scores(predict, target, ignore_index=-1): + total = [] + for pred, tgt in zip(predict, target): + target_expand = tgt.unsqueeze(0).expand_as(pred) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + + # Tensor process + x = torch.zeros_like(target_expand) + t = tgt.unsqueeze(0).clamp(min=0).long() + target_1hot = x.scatter_(0, t, 1) + predict_flat = pred.cpu().numpy().reshape(-1) + target_flat = target_1hot.data.cpu().numpy().reshape(-1) + + p = predict_flat[target_expand_numpy != ignore_index] + t = target_flat[target_expand_numpy != ignore_index] + + total.append(np.nan_to_num(average_precision_score(t, p))) + + return total + + +def get_ap_multiclass(predict, target): + total = [] + for pred, tgt in zip(predict, target): + predict_flat = pred.data.cpu().numpy().reshape(-1) + target_flat = tgt.data.cpu().numpy().reshape(-1) + + total.append(np.nan_to_num(average_precision_score(target_flat, predict_flat))) + + return total + + +def batch_precision_recall(predict, target, thr=0.5): + """Batch Precision Recall + Args: + predict: input 4D tensor + target: label 4D tensor + """ + # _, predict = torch.max(predict, 1) + + predict = predict > thr + predict = predict.data.cpu().numpy() + 1 + target = target.data.cpu().numpy() + 1 + + tp = np.sum(((predict == 2) * (target == 2)) * (target > 0)) + fp = np.sum(((predict == 2) * (target == 1)) * (target > 0)) + fn = np.sum(((predict == 1) * (target == 2)) * (target > 0)) + + precision = float(np.nan_to_num(tp / (tp + fp))) + recall = float(np.nan_to_num(tp / (tp + fn))) + + return precision, recall + + +def batch_pix_accuracy(predict, target): + """Batch Pixel Accuracy + Args: + predict: input 3D tensor + target: label 3D tensor + """ + + # for thr in np.linspace(0, 1, slices): + + _, predict = torch.max(predict, 0) + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + pixel_labeled = np.sum(target > 0) + pixel_correct = np.sum((predict == target) * (target > 0)) + assert pixel_correct <= pixel_labeled, \ + "Correct area should be smaller than Labeled" + return pixel_correct, pixel_labeled + + +def batch_intersection_union(predict, target, nclass): + """Batch Intersection of Union + Args: + predict: input 3D tensor + target: label 3D tensor + nclass: number of categories (int) + """ + _, predict = torch.max(predict, 0) + mini = 1 + maxi = nclass + nbins = nclass + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + + predict = predict * (target > 0).astype(predict.dtype) + intersection = predict * (predict == target) + # areas of intersection and union + area_inter, _ = np.histogram(intersection, bins=nbins, range=(mini, maxi)) + area_pred, _ = np.histogram(predict, bins=nbins, range=(mini, maxi)) + area_lab, _ = np.histogram(target, bins=nbins, range=(mini, maxi)) + area_union = area_pred + area_lab - area_inter + assert (area_inter <= area_union).all(), \ + "Intersection area should be smaller than Union area" + return area_inter, area_union + + +# ref https://github.com/CSAILVision/sceneparsing/blob/master/evaluationCode/utils_eval.py +def pixel_accuracy(im_pred, im_lab): + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + + # Remove classes from unlabeled pixels in gt image. + # We should not penalize detections in unlabeled portions of the image. + pixel_labeled = np.sum(im_lab > 0) + pixel_correct = np.sum((im_pred == im_lab) * (im_lab > 0)) + # pixel_accuracy = 1.0 * pixel_correct / pixel_labeled + return pixel_correct, pixel_labeled + + +def intersection_and_union(im_pred, im_lab, num_class): + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + # Remove classes from unlabeled pixels in gt image. + im_pred = im_pred * (im_lab > 0) + # Compute area intersection: + intersection = im_pred * (im_pred == im_lab) + area_inter, _ = np.histogram(intersection, bins=num_class - 1, + range=(1, num_class - 1)) + # Compute area union: + area_pred, _ = np.histogram(im_pred, bins=num_class - 1, + range=(1, num_class - 1)) + area_lab, _ = np.histogram(im_lab, bins=num_class - 1, + range=(1, num_class - 1)) + area_union = area_pred + area_lab - area_inter + return area_inter, area_union diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/parallel.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..c14ef5c0d8e3f84606c339ce513b46d4bc9e4a70 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/parallel.py @@ -0,0 +1,260 @@ +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +## Created by: Hang Zhang +## ECE Department, Rutgers University +## Email: zhang.hang@rutgers.edu +## Copyright (c) 2017 +## +## This source code is licensed under the MIT-style license found in the +## LICENSE file in the root directory of this source tree +##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +"""Encoding Data Parallel""" +import threading +import functools +import torch +from torch.autograd import Variable, Function +import torch.cuda.comm as comm +from torch.nn.parallel.data_parallel import DataParallel +from torch.nn.parallel.parallel_apply import get_a_var +from torch.nn.parallel._functions import ReduceAddCoalesced, Broadcast + +torch_ver = torch.__version__[:3] + +__all__ = ['allreduce', 'DataParallelModel', 'DataParallelCriterion', + 'patch_replication_callback'] + +def allreduce(*inputs): + """Cross GPU all reduce autograd operation for calculate mean and + variance in SyncBN. + """ + return AllReduce.apply(*inputs) + +class AllReduce(Function): + @staticmethod + def forward(ctx, num_inputs, *inputs): + ctx.num_inputs = num_inputs + ctx.target_gpus = [inputs[i].get_device() for i in range(0, len(inputs), num_inputs)] + inputs = [inputs[i:i + num_inputs] + for i in range(0, len(inputs), num_inputs)] + # sort before reduce sum + inputs = sorted(inputs, key=lambda i: i[0].get_device()) + results = comm.reduce_add_coalesced(inputs, ctx.target_gpus[0]) + outputs = comm.broadcast_coalesced(results, ctx.target_gpus) + return tuple([t for tensors in outputs for t in tensors]) + + @staticmethod + def backward(ctx, *inputs): + inputs = [i.data for i in inputs] + inputs = [inputs[i:i + ctx.num_inputs] + for i in range(0, len(inputs), ctx.num_inputs)] + results = comm.reduce_add_coalesced(inputs, ctx.target_gpus[0]) + outputs = comm.broadcast_coalesced(results, ctx.target_gpus) + return (None,) + tuple([Variable(t) for tensors in outputs for t in tensors]) + + +class Reduce(Function): + @staticmethod + def forward(ctx, *inputs): + ctx.target_gpus = [inputs[i].get_device() for i in range(len(inputs))] + inputs = sorted(inputs, key=lambda i: i.get_device()) + return comm.reduce_add(inputs) + + @staticmethod + def backward(ctx, gradOutput): + return Broadcast.apply(ctx.target_gpus, gradOutput) + + +class DataParallelModel(DataParallel): + """Implements data parallelism at the module level. + + This container parallelizes the application of the given module by + splitting the input across the specified devices by chunking in the + batch dimension. + In the forward pass, the module is replicated on each device, + and each replica handles a portion of the input. During the backwards pass, gradients from each replica are summed into the original module. + Note that the outputs are not gathered, please use compatible + :class:`encoding.parallel.DataParallelCriterion`. + + The batch size should be larger than the number of GPUs used. It should + also be an integer multiple of the number of GPUs so that each chunk is + the same size (so that each GPU processes the same number of samples). + + Args: + module: module to be parallelized + device_ids: CUDA devices (default: all devices) + + Reference: + Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, + Amit Agrawal. “Context Encoding for Semantic Segmentation. + *The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2018* + + Example:: + + >>> net = encoding.nn.DataParallelModel(model, device_ids=[0, 1, 2]) + >>> y = net(x) + """ + def gather(self, outputs, output_device): + return outputs + + def replicate(self, module, device_ids): + modules = super(DataParallelModel, self).replicate(module, device_ids) + execute_replication_callbacks(modules) + return modules + + +class DataParallelCriterion(DataParallel): + """ + Calculate loss in multiple-GPUs, which balance the memory usage for + Semantic Segmentation. + + The targets are splitted across the specified devices by chunking in + the batch dimension. Please use together with :class:`encoding.parallel.DataParallelModel`. + + Reference: + Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, + Amit Agrawal. “Context Encoding for Semantic Segmentation. + *The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2018* + + Example:: + + >>> net = encoding.nn.DataParallelModel(model, device_ids=[0, 1, 2]) + >>> criterion = encoding.nn.DataParallelCriterion(criterion, device_ids=[0, 1, 2]) + >>> y = net(x) + >>> loss = criterion(y, target) + """ + def forward(self, inputs, *targets, **kwargs): + # input should be already scatterd + # scattering the targets instead + if not self.device_ids: + return self.module(inputs, *targets, **kwargs) + targets, kwargs = self.scatter(targets, kwargs, self.device_ids) + if len(self.device_ids) == 1: + return self.module(inputs, *targets[0], **kwargs[0]) + replicas = self.replicate(self.module, self.device_ids[:len(inputs)]) + outputs = _criterion_parallel_apply(replicas, inputs, targets, kwargs) + return Reduce.apply(*outputs) / len(outputs) + #return self.gather(outputs, self.output_device).mean() + + +def _criterion_parallel_apply(modules, inputs, targets, kwargs_tup=None, devices=None): + assert len(modules) == len(inputs) + assert len(targets) == len(inputs) + if kwargs_tup: + assert len(modules) == len(kwargs_tup) + else: + kwargs_tup = ({},) * len(modules) + if devices is not None: + assert len(modules) == len(devices) + else: + devices = [None] * len(modules) + + lock = threading.Lock() + results = {} + if torch_ver != "0.3": + grad_enabled = torch.is_grad_enabled() + + def _worker(i, module, input, target, kwargs, device=None): + if torch_ver != "0.3": + torch.set_grad_enabled(grad_enabled) + if device is None: + device = get_a_var(input).get_device() + try: + with torch.cuda.device(device): + # this also avoids accidental slicing of `input` if it is a Tensor + if not isinstance(input, (list, tuple)): + input = (input,) + if type(input) != type(target): + if isinstance(target, tuple): + input = tuple(input) + elif isinstance(target, list): + input = list(input) + else: + raise Exception("Types problem") + + output = module(*(input + target), **kwargs) + with lock: + results[i] = output + except Exception as e: + with lock: + results[i] = e + + if len(modules) > 1: + threads = [threading.Thread(target=_worker, + args=(i, module, input, target, + kwargs, device),) + for i, (module, input, target, kwargs, device) in + enumerate(zip(modules, inputs, targets, kwargs_tup, devices))] + + for thread in threads: + thread.start() + for thread in threads: + thread.join() + else: + _worker(0, modules[0], inputs[0], kwargs_tup[0], devices[0]) + + outputs = [] + for i in range(len(inputs)): + output = results[i] + if isinstance(output, Exception): + raise output + outputs.append(output) + return outputs + + +########################################################################### +# Adapted from Synchronized-BatchNorm-PyTorch. +# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch +# +class CallbackContext(object): + pass + + +def execute_replication_callbacks(modules): + """ + Execute an replication callback `__data_parallel_replicate__` on each module created + by original replication. + + The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)` + + Note that, as all modules are isomorphism, we assign each sub-module with a context + (shared among multiple copies of this module on different devices). + Through this context, different copies can share some information. + + We guarantee that the callback on the master copy (the first copy) will be called ahead + of calling the callback of any slave copies. + """ + master_copy = modules[0] + nr_modules = len(list(master_copy.modules())) + ctxs = [CallbackContext() for _ in range(nr_modules)] + + for i, module in enumerate(modules): + for j, m in enumerate(module.modules()): + if hasattr(m, '__data_parallel_replicate__'): + m.__data_parallel_replicate__(ctxs[j], i) + + +def patch_replication_callback(data_parallel): + """ + Monkey-patch an existing `DataParallel` object. Add the replication callback. + Useful when you have customized `DataParallel` implementation. + + Examples: + > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False) + > sync_bn = DataParallel(sync_bn, device_ids=[0, 1]) + > patch_replication_callback(sync_bn) + # this is equivalent to + > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False) + > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1]) + """ + + assert isinstance(data_parallel, DataParallel) + + old_replicate = data_parallel.replicate + + @functools.wraps(old_replicate) + def new_replicate(module, device_ids): + modules = old_replicate(module, device_ids) + execute_replication_callbacks(modules) + return modules + + data_parallel.replicate = new_replicate diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/render.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/render.py new file mode 100644 index 0000000000000000000000000000000000000000..70c0e1a87614b0f07bf18aedf4df3ed765ac25e8 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/render.py @@ -0,0 +1,266 @@ +import numpy as np +import matplotlib.cm +import skimage.io +import skimage.feature +import skimage.filters + + +def vec2im(V, shape=()): + ''' + Transform an array V into a specified shape - or if no shape is given assume a square output format. + + Parameters + ---------- + + V : numpy.ndarray + an array either representing a matrix or vector to be reshaped into an two-dimensional image + + shape : tuple or list + optional. containing the shape information for the output array if not given, the output is assumed to be square + + Returns + ------- + + W : numpy.ndarray + with W.shape = shape or W.shape = [np.sqrt(V.size)]*2 + + ''' + + if len(shape) < 2: + shape = [np.sqrt(V.size)] * 2 + shape = map(int, shape) + return np.reshape(V, shape) + + +def enlarge_image(img, scaling=3): + ''' + Enlarges a given input matrix by replicating each pixel value scaling times in horizontal and vertical direction. + + Parameters + ---------- + + img : numpy.ndarray + array of shape [H x W] OR [H x W x D] + + scaling : int + positive integer value > 0 + + Returns + ------- + + out : numpy.ndarray + two-dimensional array of shape [scaling*H x scaling*W] + OR + three-dimensional array of shape [scaling*H x scaling*W x D] + depending on the dimensionality of the input + ''' + + if scaling < 1 or not isinstance(scaling, int): + print('scaling factor needs to be an int >= 1') + + if len(img.shape) == 2: + H, W = img.shape + + out = np.zeros((scaling * H, scaling * W)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh:fh + scaling, fw:fw + scaling] = img[h, w] + + elif len(img.shape) == 3: + H, W, D = img.shape + + out = np.zeros((scaling * H, scaling * W, D)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh:fh + scaling, fw:fw + scaling, :] = img[h, w, :] + + return out + + +def repaint_corner_pixels(rgbimg, scaling=3): + ''' + DEPRECATED/OBSOLETE. + + Recolors the top left and bottom right pixel (groups) with the average rgb value of its three neighboring pixel (groups). + The recoloring visually masks the opposing pixel values which are a product of stabilizing the scaling. + Assumes those image ares will pretty much never show evidence. + + Parameters + ---------- + + rgbimg : numpy.ndarray + array of shape [H x W x 3] + + scaling : int + positive integer value > 0 + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] + ''' + + # top left corner. + rgbimg[0:scaling, 0:scaling, :] = (rgbimg[0, scaling, :] + rgbimg[scaling, 0, :] + rgbimg[scaling, scaling, + :]) / 3.0 + # bottom right corner + rgbimg[-scaling:, -scaling:, :] = (rgbimg[-1, -1 - scaling, :] + rgbimg[-1 - scaling, -1, :] + rgbimg[-1 - scaling, + -1 - scaling, + :]) / 3.0 + return rgbimg + + +def digit_to_rgb(X, scaling=3, shape=(), cmap='binary'): + ''' + Takes as input an intensity array and produces a rgb image due to some color map + + Parameters + ---------- + + X : numpy.ndarray + intensity matrix as array of shape [M x N] + + scaling : int + optional. positive integer value > 0 + + shape: tuple or list of its , length = 2 + optional. if not given, X is reshaped to be square. + + cmap : str + name of color map of choice. default is 'binary' + + Returns + ------- + + image : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + ''' + + # create color map object from name string + cmap = eval('matplotlib.cm.{}'.format(cmap)) + + image = enlarge_image(vec2im(X, shape), scaling) # enlarge + image = cmap(image.flatten())[..., 0:3].reshape([image.shape[0], image.shape[1], 3]) # colorize, reshape + + return image + + +def hm_to_rgb(R, X=None, scaling=3, shape=(), sigma=2, cmap='bwr', normalize=True): + ''' + Takes as input an intensity array and produces a rgb image for the represented heatmap. + optionally draws the outline of another input on top of it. + + Parameters + ---------- + + R : numpy.ndarray + the heatmap to be visualized, shaped [M x N] + + X : numpy.ndarray + optional. some input, usually the data point for which the heatmap R is for, which shall serve + as a template for a black outline to be drawn on top of the image + shaped [M x N] + + scaling: int + factor, on how to enlarge the heatmap (to control resolution and as a inverse way to control outline thickness) + after reshaping it using shape. + + shape: tuple or list, length = 2 + optional. if not given, X is reshaped to be square. + + sigma : double + optional. sigma-parameter for the canny algorithm used for edge detection. the found edges are drawn as outlines. + + cmap : str + optional. color map of choice + + normalize : bool + optional. whether to normalize the heatmap to [-1 1] prior to colorization or not. + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + ''' + + # create color map object from name string + cmap = eval('matplotlib.cm.{}'.format(cmap)) + + if normalize: + R = R / np.max(np.abs(R)) # normalize to [-1,1] wrt to max relevance magnitude + R = (R + 1.) / 2. # shift/normalize to [0,1] for color mapping + + R = enlarge_image(R, scaling) + rgb = cmap(R.flatten())[..., 0:3].reshape([R.shape[0], R.shape[1], 3]) + # rgb = repaint_corner_pixels(rgb, scaling) #obsolete due to directly calling the color map with [0,1]-normalized inputs + + if not X is None: # compute the outline of the input + # X = enlarge_image(vec2im(X,shape), scaling) + xdims = X.shape + Rdims = R.shape + + # if not np.all(xdims == Rdims): + # print 'transformed heatmap and data dimension mismatch. data dimensions differ?' + # print 'R.shape = ',Rdims, 'X.shape = ', xdims + # print 'skipping drawing of outline\n' + # else: + # #edges = skimage.filters.canny(X, sigma=sigma) + # edges = skimage.feature.canny(X, sigma=sigma) + # edges = np.invert(np.dstack([edges]*3))*1.0 + # rgb *= edges # set outline pixels to black color + + return rgb + + +def save_image(rgb_images, path, gap=2): + ''' + Takes as input a list of rgb images, places them next to each other with a gap and writes out the result. + + Parameters + ---------- + + rgb_images : list , tuple, collection. such stuff + each item in the collection is expected to be an rgb image of dimensions [H x _ x 3] + where the width is variable + + path : str + the output path of the assembled image + + gap : int + optional. sets the width of a black area of pixels realized as an image shaped [H x gap x 3] in between the input images + + Returns + ------- + + image : numpy.ndarray + the assembled image as written out to path + ''' + + sz = [] + image = [] + for i in range(len(rgb_images)): + if not sz: + sz = rgb_images[i].shape + image = rgb_images[i] + gap = np.zeros((sz[0], gap, sz[2])) + continue + if not sz[0] == rgb_images[i].shape[0] and sz[1] == rgb_images[i].shape[2]: + print('image', i, 'differs in size. unable to perform horizontal alignment') + print('expected: Hx_xD = {0}x_x{1}'.format(sz[0], sz[1])) + print('got : Hx_xD = {0}x_x{1}'.format(rgb_images[i].shape[0], rgb_images[i].shape[1])) + print('skipping image\n') + else: + image = np.hstack((image, gap, rgb_images[i])) + + image *= 255 + image = image.astype(np.uint8) + + print('saving image to ', path) + skimage.io.imsave(path, image) + return image diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/saver.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/saver.py new file mode 100644 index 0000000000000000000000000000000000000000..f767d288f662a9685d90cab8eb188d7b0ae920ce --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/saver.py @@ -0,0 +1,34 @@ +import os +import torch +from collections import OrderedDict +import glob + + +class Saver(object): + + def __init__(self, args): + self.args = args + self.directory = os.path.join('run', args.train_dataset, args.checkname) + self.runs = sorted(glob.glob(os.path.join(self.directory, 'experiment_*'))) + run_id = int(self.runs[-1].split('_')[-1]) + 1 if self.runs else 0 + + self.experiment_dir = os.path.join(self.directory, 'experiment_{}'.format(str(run_id))) + if not os.path.exists(self.experiment_dir): + os.makedirs(self.experiment_dir) + + def save_checkpoint(self, state, filename='checkpoint.pth.tar'): + """Saves checkpoint to disk""" + filename = os.path.join(self.experiment_dir, filename) + torch.save(state, filename) + + def save_experiment_config(self): + logfile = os.path.join(self.experiment_dir, 'parameters.txt') + log_file = open(logfile, 'w') + p = OrderedDict() + p['train_dataset'] = self.args.train_dataset + p['lr'] = self.args.lr + p['epoch'] = self.args.epochs + + for key, val in p.items(): + log_file.write(key + ':' + str(val) + '\n') + log_file.close() diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/summaries.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/summaries.py new file mode 100644 index 0000000000000000000000000000000000000000..6d880ad2a4fea30d0c00af91300a31bd218c4e6f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/utils/summaries.py @@ -0,0 +1,11 @@ +import os +from torch.utils.tensorboard import SummaryWriter + + +class TensorboardSummary(object): + def __init__(self, directory): + self.directory = directory + self.writer = SummaryWriter(log_dir=os.path.join(self.directory)) + + def add_scalar(self, *args): + self.writer.add_scalar(*args) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/weight_init.py b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/weight_init.py new file mode 100644 index 0000000000000000000000000000000000000000..616373c3c1d0e9dc9cac51f85d791346e2240c99 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/chefer_vit_explainability/weight_init.py @@ -0,0 +1,60 @@ +import torch +import math +import warnings + + +def _no_grad_trunc_normal_(tensor, mean, std, a, b): + # Cut & paste from PyTorch official master until it's in a few official releases - RW + # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf + def norm_cdf(x): + # Computes standard normal cumulative distribution function + return (1. + math.erf(x / math.sqrt(2.))) / 2. + + if (mean < a - 2 * std) or (mean > b + 2 * std): + warnings.warn("mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " + "The distribution of values may be incorrect.", + stacklevel=2) + + with torch.no_grad(): + # Values are generated by using a truncated uniform distribution and + # then using the inverse CDF for the normal distribution. + # Get upper and lower cdf values + l = norm_cdf((a - mean) / std) + u = norm_cdf((b - mean) / std) + + # Uniformly fill tensor with values from [l, u], then translate to + # [2l-1, 2u-1]. + tensor.uniform_(2 * l - 1, 2 * u - 1) + + # Use inverse cdf transform for normal distribution to get truncated + # standard normal + tensor.erfinv_() + + # Transform to proper mean, std + tensor.mul_(std * math.sqrt(2.)) + tensor.add_(mean) + + # Clamp to ensure it's in the proper range + tensor.clamp_(min=a, max=b) + return tensor + + +def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.): + # type: (Tensor, float, float, float, float) -> Tensor + r"""Fills the input Tensor with values drawn from a truncated + normal distribution. The values are effectively drawn from the + normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)` + with values outside :math:`[a, b]` redrawn until they are within + the bounds. The method used for generating the random values works + best when :math:`a \leq \text{mean} \leq b`. + Args: + tensor: an n-dimensional `torch.Tensor` + mean: the mean of the normal distribution + std: the standard deviation of the normal distribution + a: the minimum cutoff value + b: the maximum cutoff value + Examples: + >>> w = torch.empty(3, 5) + >>> nn.init.trunc_normal_(w) + """ + return _no_grad_trunc_normal_(tensor, mean, std, a, b) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/.gitignore b/concept_attention/binary_segmentation_baselines/clip_text_span/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..9538023f6050298dfcfdca406c61e225c691236f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/.gitignore @@ -0,0 +1,6 @@ +.ipynb_checkpoints/ +__pycache__/ +*/*.mat +utils/__pycache__ +imagenet_seg/ +run/ \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/LICENSE.txt b/concept_attention/binary_segmentation_baselines/clip_text_span/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..b9440fe7b1e8577617a0980b0e76d364188d5212 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Yossi Gandelsman + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/README.md b/concept_attention/binary_segmentation_baselines/clip_text_span/README.md new file mode 100644 index 0000000000000000000000000000000000000000..13fe75ede9ed09459a1ca8cfe171e46201255d5f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/README.md @@ -0,0 +1,111 @@ +## Interpreting CLIP's Image Representation via Text-Based Decomposition +Official PyTorch Implementation + +### [Paper](https://arxiv.org/abs/2310.05916) | [Project Page](https://yossigandelsman.github.io/clip_decomposition/) + +[Yossi Gandelsman](https://yossigandelsman.github.io/), [Alexei A. Efros](https://people.eecs.berkeley.edu/~efros/) and [Jacob Steinhardt](https://jsteinhardt.stat.berkeley.edu/) + +![Teaser](images/teaser.png) + +🔥 Check out [our latest work](https://yossigandelsman.github.io/clip_neurons/) on interpreting neurons in CLIP with text. + +### Setup +We provide an [`environment.yml`](environment.yml) file that can be used to create a Conda environment: + +```bash +conda env create -f environment.yml +conda activate prsclip +``` +### Preprocessing +To obtain the projected residual stream components for the ImageNet validation set, including the contributions from multi-head attentions and MLPs, please run one of the following instructions: + +```bash +python compute_prs.py --dataset imagenet --device cuda:0 --model ViT-H-14 --pretrained laion2b_s32b_b79k --data_path +python compute_prs.py --dataset imagenet --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k --data_path +python compute_prs.py --dataset imagenet --device cuda:0 --model ViT-B-16 --pretrained laion2b_s34b_b88k --data_path +``` + +To obtain the precomputed text representations of the ImageNet classes, please run: +```bash +python compute_text_projection.py --dataset imagenet --device cuda:0 --model ViT-H-14 --pretrained laion2b_s32b_b79k +python compute_text_projection.py --dataset imagenet --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k +python compute_text_projection.py --dataset imagenet --device cuda:0 --model ViT-B-16 --pretrained laion2b_s34b_b88k +``` + +### Mean-ablations +To verify that the MLPs and the attention from the class token to itself can be mean-ablated, please run: + +```bash +python compute_ablations.py --model ViT-H-14 +python compute_ablations.py --model ViT-L-14 +python compute_ablations.py --model ViT-B-16 +``` + +### Convert text labels to representation +To convert the text labels for TextSpan to CLIP text representations, please run: + +```bash +python compute_text_set_projection.py --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k --data_path text_descriptions/google_3498_english.txt +python compute_text_set_projection.py --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k --data_path text_descriptions/image_descriptions_general.txt +``` + +### ImageNet segmentation +Please download the dataset from [here](http://calvin-vision.net/bigstuff/proj-imagenet/data/gtsegs_ijcv.mat): + +```bash +mkdir imagenet_seg +cd imagenet_seg +wget http://calvin-vision.net/bigstuff/proj-imagenet/data/gtsegs_ijcv.mat +``` + +To get the evaluation results, please run: + +```bash +python compute_segmentations.py --device cuda:0 --model ViT-H-14 --pretrained laion2b_s32b_b79k --data_path imagenet_seg/gtsegs_ijcv.mat --save_img +python compute_segmentations.py --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k --data_path imagenet_seg/gtsegs_ijcv.mat --save_img +python compute_segmentations.py --device cuda:0 --model ViT-B-16 --pretrained laion2b_s34b_b88k --data_path imagenet_seg/gtsegs_ijcv.mat --save_img +``` +Save the results with the `--save_img` flag. + + +### TextSpan + +To find meaningful directions for all the attenion heads, run: +```bash +python compute_complete_text_set.py --device cuda:0 --model ViT-B-16 --texts_per_head 20 --num_of_last_layers 4 --text_descriptions image_descriptions_general +python compute_complete_text_set.py --device cuda:0 --model ViT-L-14 --texts_per_head 20 --num_of_last_layers 4 --text_descriptions image_descriptions_general +python compute_complete_text_set.py --device cuda:0 --model ViT-H-14 --texts_per_head 20 --num_of_last_layers 4 --text_descriptions image_descriptions_general +``` + +### Other datasets +To download the Waterbirds datasets, run: +```bash +wget https://nlp.stanford.edu/data/dro/waterbird_complete95_forest2water2.tar.gz +tar -xf waterbird_complete95_forest2water2.tar.gz +``` +To compute the overall accuracy, run: +```bash +python compute_prs.py --dataset binary_waterbirds --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k --data_path +python compute_text_projection.py --dataset binary_waterbirds --device cuda:0 --model ViT-L-14 --pretrained laion2b_s32b_b82k +python compute_use_specific_heads.py --model ViT-L-14 --dataset binary_waterbirds +``` + +### Spatial decomposition +Please see a demo for the spatial decomposition of CLIP in `demo.ipynb`. + + +### Nearest neighbors search +Please see the nearest neighbors search demo in `nns.ipynb`. + +### BibTeX + +```bibtex +@inproceedings{ + gandelsman2024interpreting, + title={Interpreting {CLIP}'s Image Representation via Text-Based Decomposition}, + author={Yossi Gandelsman and Alexei A. Efros and Jacob Steinhardt}, + booktitle={The Twelfth International Conference on Learning Representations}, + year={2024}, + url={https://openreview.net/forum?id=5Ca9sSzuDp} +} +``` diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/__init__.py b/concept_attention/binary_segmentation_baselines/clip_text_span/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_ablations.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_ablations.py new file mode 100644 index 0000000000000000000000000000000000000000..47abe2f49db1cb4a1c9b60e50b32411345c5c100 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_ablations.py @@ -0,0 +1,125 @@ +import numpy as np +import torch +import os.path +import argparse +import einops +from pathlib import Path + +import tqdm +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import accuracy + + +def get_args_parser(): + parser = argparse.ArgumentParser("Ablations part", add_help=False) + + # Model parameters + parser.add_argument( + "--model", + default="ViT-H-14", + type=str, + metavar="MODEL", + help="Name of model to use", + ) + # Dataset parameters + parser.add_argument("--num_workers", default=10, type=int) + parser.add_argument( + "--figures_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--input_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--dataset", + type=str, + default="imagenet", + help="imagenet, waterbirds, cub, binary_waterbirds", + ) + return parser + + +def main(args): + + attns = np.load(os.path.join(args.input_dir, f"{args.dataset}_attn_{args.model}.npy"), mmap_mode="r") # [b, l, h, d] + mlps = np.load(os.path.join(args.input_dir, f"{args.dataset}_mlp_{args.model}.npy"), mmap_mode="r") # [b, l+1, d] + with open( + os.path.join(args.input_dir, f"{args.dataset}_classifier_{args.model}.npy"), + "rb", + ) as f: + classifier = np.load(f) + if args.dataset == "imagenet": + labels = np.array([i // 50 for i in range(attns.shape[0])]) + else: + with open( + os.path.join(args.input_dir, f"{args.dataset}_labels.npy"), "rb" + ) as f: + labels = np.load(f) + baseline = attns.sum(axis=(1, 2)) + mlps.sum(axis=1) + baseline_acc = ( + accuracy( + torch.from_numpy(baseline @ classifier).float(), torch.from_numpy(labels) + )[0] + * 100 + ) + print("Baseline:", baseline_acc) + mlps_mean = einops.repeat(mlps.mean(axis=0), "l d -> b l d", b=attns.shape[0]) + mlps_ablation = attns.sum(axis=(1, 2)) + mlps_mean.sum(axis=1) + mlps_ablation_acc = ( + accuracy( + torch.from_numpy(mlps_ablation @ classifier).float(), + torch.from_numpy(labels), + )[0] + * 100 + ) + print("+ MLPs ablation:", mlps_ablation_acc) + mlps_no_layers = mlps.sum(axis=1) + attns_no_cls = attns.sum(axis=2) + with open( + os.path.join(args.input_dir, f"{args.dataset}_cls_attn_{args.model}.npy"), "rb" + ) as f: + cls_attn = np.load(f) # [b, l, d] + attns_no_cls = attns_no_cls - cls_attn + cls_attn.mean(axis=0)[np.newaxis, :, :] + no_cls_ablation = attns_no_cls.sum(axis=1) + mlps_no_layers + no_cls_acc = ( + accuracy( + torch.from_numpy(no_cls_ablation @ classifier).float(), + torch.from_numpy(labels), + )[0] + * 100 + ) + print("+ CLS ablation:", no_cls_acc) + mlp_and_no_cls_ablation = attns_no_cls.sum(axis=1) + mlps_mean.sum(axis=1) + mlp_and_no_cls_ablation_acc = ( + accuracy( + torch.from_numpy(mlp_and_no_cls_ablation @ classifier).float(), + torch.from_numpy(labels), + )[0] + * 100 + ) + print("+ MLPs + CLS ablation:", mlp_and_no_cls_ablation_acc) + no_heads_attentions = attns.sum(axis=(2)) + all_accuracies = [baseline_acc] + for layer in range(attns.shape[1]): + current_model = ( + np.sum( + np.mean(no_heads_attentions[:, :layer], axis=0, keepdims=True), axis=1 + ) + + np.mean(no_heads_attentions[:, layer], axis=0, keepdims=True) + + np.sum(no_heads_attentions[:, layer + 1 :], axis=1) + ) + current_accuracy = ( + accuracy( + torch.from_numpy((mlps_no_layers + current_model) @ classifier).float(), + torch.from_numpy(labels), + )[0] + * 100 + ) + all_accuracies.append(current_accuracy) + print("Attention ablations:", all_accuracies) + + +if __name__ == "__main__": + args = get_args_parser() + args = args.parse_args() + if args.figures_dir: + Path(args.figures_dir).mkdir(parents=True, exist_ok=True) + main(args) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_complete_text_set.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_complete_text_set.py new file mode 100644 index 0000000000000000000000000000000000000000..339affe2d75a255450ee186365c3881cc4c666c2 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_complete_text_set.py @@ -0,0 +1,189 @@ +import time +import numpy as np +import torch +from PIL import Image +import glob +import sys +import os +import einops +from torch.utils.data import DataLoader +import tqdm +import argparse +from torchvision.datasets import ImageNet +from pathlib import Path + +from clip_text_span.utils.misc import accuracy + + +@torch.no_grad() +def replace_with_iterative_removal(data, text_features, texts, iters, rank, device): + results = [] + u, s, vh = np.linalg.svd(data, full_matrices=False) + vh = vh[:rank] + text_features = ( + vh.T.dot(np.linalg.inv(vh.dot(vh.T)).dot(vh)).dot(text_features.T).T + ) # Project the text to the span of W_OV + data = torch.from_numpy(data).float().to(device) + mean_data = data.mean(dim=0, keepdim=True) + data = data - mean_data + reconstruct = einops.repeat(mean_data, "A B -> (C A) B", C=data.shape[0]) + reconstruct = reconstruct.detach().cpu().numpy() + text_features = torch.from_numpy(text_features).float().to(device) + for i in range(iters): + projection = data @ text_features.T + projection_std = projection.std(axis=0).detach().cpu().numpy() + top_n = np.argmax(projection_std) + results.append(texts[top_n]) + text_norm = text_features[top_n] @ text_features[top_n].T + reconstruct += ( + ( + (data @ text_features[top_n] / text_norm)[:, np.newaxis] + * text_features[top_n][np.newaxis, :] + ) + .detach() + .cpu() + .numpy() + ) + data = data - ( + (data @ text_features[top_n] / text_norm)[:, np.newaxis] + * text_features[top_n][np.newaxis, :] + ) + text_features = ( + text_features + - (text_features @ text_features[top_n] / text_norm)[:, np.newaxis] + * text_features[top_n][np.newaxis, :] + ) + return reconstruct, results + + +def get_args_parser(): + parser = argparse.ArgumentParser("Completeness part", add_help=False) + + # Model parameters + parser.add_argument( + "--model", + default="ViT-H-14", + type=str, + metavar="MODEL", + help="Name of model to use", + ) + # Dataset parameters + parser.add_argument("--num_workers", default=10, type=int) + parser.add_argument( + "--output_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--input_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--text_descriptions", + default="image_descriptions_per_class", + type=str, + help="name of the evalauted text set", + ) + parser.add_argument( + "--text_dir", + default="./text_descriptions", + type=str, + help="The folder with the text files", + ) + parser.add_argument( + "--dataset", type=str, default="imagenet", help="imagenet or waterbirds" + ) + parser.add_argument( + "--num_of_last_layers", + type=int, + default=8, + help="How many attention layers to replace.", + ) + parser.add_argument( + "--w_ov_rank", type=int, default=80, help="The rank of the OV matrix" + ) + parser.add_argument( + "--texts_per_head", + type=int, + default=10, + help="The number of text examples per head.", + ) + parser.add_argument("--device", default="cuda:0", help="device to use for testing") + return parser + + +def main(args): + with open( + os.path.join(args.input_dir, f"{args.dataset}_attn_{args.model}.npy"), "rb" + ) as f: + attns = np.load(f) # [b, l, h, d] + with open( + os.path.join(args.input_dir, f"{args.dataset}_mlp_{args.model}.npy"), "rb" + ) as f: + mlps = np.load(f) # [b, l+1, d] + with open( + os.path.join(args.input_dir, f"{args.dataset}_classifier_{args.model}.npy"), + "rb", + ) as f: + classifier = np.load(f) + print(f"Number of layers: {attns.shape[1]}") + all_images = set() + # Mean-ablate the other parts + for i in tqdm.trange(attns.shape[1] - args.num_of_last_layers): + for head in range(attns.shape[2]): + attns[:, i, head] = np.mean(attns[:, i, head], axis=0, keepdims=True) + # Load text: + with open( + os.path.join(args.input_dir, f"{args.text_descriptions}_{args.model}.npy"), "rb" + ) as f: + text_features = np.load(f) + with open(os.path.join(args.text_dir, f"{args.text_descriptions}.txt"), "r") as f: + lines = [i.replace("\n", "") for i in f.readlines()] + with open( + os.path.join( + args.output_dir, + f"{args.dataset}_completeness_{args.text_descriptions}_top_{args.texts_per_head}_heads_{args.model}.txt", + ), + "w", + ) as w: + for i in tqdm.trange(attns.shape[1] - args.num_of_last_layers, attns.shape[1]): + for head in range(attns.shape[2]): + results, images = replace_with_iterative_removal( + attns[:, i, head], + text_features, + lines, + args.texts_per_head, + args.w_ov_rank, + args.device, + ) + attns[:, i, head] = results + all_images |= set(images) + w.write(f"------------------\n") + w.write(f"Layer {i}, Head {head}\n") + w.write(f"------------------\n") + for text in images: + w.write(f"{text}\n") + + mean_ablated_and_replaced = mlps.sum(axis=1) + attns.sum(axis=(1, 2)) + projections = torch.from_numpy(mean_ablated_and_replaced).float().to( + args.device + ) @ torch.from_numpy(classifier).float().to(args.device) + labels = np.array([i // 50 for i in range(attns.shape[0])]) + current_accuracy = ( + accuracy(projections.cpu(), torch.from_numpy(labels))[0] * 100.0 + ) + print( + f"Current accuracy:", + current_accuracy, + "\nNumber of texts:", + len(all_images), + ) + w.write(f"------------------\n") + w.write( + f"Current accuracy: {current_accuracy}\nNumber of texts: {len(all_images)}" + ) + + +if __name__ == "__main__": + args = get_args_parser() + args = args.parse_args() + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + main(args) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_prs.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_prs.py new file mode 100644 index 0000000000000000000000000000000000000000..7b1236909ac2b4b2c0c14254b99306fcd7d91b7d --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_prs.py @@ -0,0 +1,120 @@ +import numpy as np +import torch +from PIL import Image +import os.path +import argparse +from pathlib import Path + +from torch.utils.data import DataLoader +import tqdm +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.binary_waterbirds import BinaryWaterbirds +from prs_hook import hook_prs_logger +from torchvision.datasets import CIFAR100, CIFAR10, ImageNet, ImageFolder + + +def get_args_parser(): + parser = argparse.ArgumentParser("Project Residual Stream", add_help=False) + parser.add_argument("--batch_size", default=2, type=int, help="Batch size") + # Model parameters + parser.add_argument( + "--model", + default="ViT-H-14", + type=str, + metavar="MODEL", + help="Name of model to use", + ) + parser.add_argument("--pretrained", default="laion2b_s32b_b79k", type=str) + # Dataset parameters + parser.add_argument( + "--data_path", default="/shared/group/ilsvrc", type=str, help="dataset path" + ) + parser.add_argument( + "--dataset", type=str, default="imagenet", help="imagenet, cub or waterbirds" + ) + parser.add_argument("--num_workers", default=10, type=int) + parser.add_argument( + "--output_dir", default="./output_dir", help="path where to save" + ) + parser.add_argument("--device", default="cuda:0", help="device to use for testing") + return parser + + +def main(args): + """Calculates the projected residual stream for a dataset.""" + model, _, preprocess = create_model_and_transforms( + args.model, pretrained=args.pretrained + ) + model.to(args.device) + model.eval() + context_length = model.context_length + vocab_size = model.vocab_size + + print( + "Model parameters:", + f"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}", + ) + print("Context length:", context_length) + print("Vocab size:", vocab_size) + print("Len of res:", len(model.visual.transformer.resblocks)) + + prs = hook_prs_logger(model, args.device) + + # Data: + if args.dataset == "imagenet": + ds = ImageNet(root=args.data_path, split="val", transform=preprocess) + elif args.dataset == "binary_waterbirds": + ds = BinaryWaterbirds(root=args.data_path, split="test", transform=preprocess) + elif args.dataset == "CIFAR100": + ds = CIFAR100( + root=args.data_path, download=True, train=False, transform=preprocess + ) + elif args.dataset == "CIFAR10": + ds = CIFAR10( + root=args.data_path, download=True, train=False, transform=preprocess + ) + else: + ds = ImageFolder(root=args.data_path, transform=preprocess) + dataloader = DataLoader( + ds, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers + ) + + attention_results = [] + mlp_results = [] + cls_to_cls_results = [] + for i, (image, _) in enumerate(tqdm.tqdm(dataloader)): + with torch.no_grad(): + prs.reinit() + representation = model.encode_image( + image.to(args.device), attn_method="head", normalize=False + ) + attentions, mlps = prs.finalize(representation) + attentions = attentions.detach().cpu().numpy() # [b, l, n, h, d] + mlps = mlps.detach().cpu().numpy() # [b, l+1, d] + attention_results.append( + np.sum(attentions, axis=2) + ) # Reduce the spatial dimension + mlp_results.append(mlps) + cls_to_cls_results.append( + np.sum(attentions[:, :, 0], axis=2) + ) # Store the cls->cls attention, reduce the heads + with open( + os.path.join(args.output_dir, f"{args.dataset}_attn_{args.model}.npy"), "wb" + ) as f: + np.save(f, np.concatenate(attention_results, axis=0)) + with open( + os.path.join(args.output_dir, f"{args.dataset}_mlp_{args.model}.npy"), "wb" + ) as f: + np.save(f, np.concatenate(mlp_results, axis=0)) + with open( + os.path.join(args.output_dir, f"{args.dataset}_cls_attn_{args.model}.npy"), "wb" + ) as f: + np.save(f, np.concatenate(cls_to_cls_results, axis=0)) + + +if __name__ == "__main__": + args = get_args_parser() + args = args.parse_args() + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + main(args) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_segmentations.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_segmentations.py new file mode 100644 index 0000000000000000000000000000000000000000..3511a311bb1d4a8d1e4975d1104dda902a1540ee --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_segmentations.py @@ -0,0 +1,307 @@ +import argparse +import torch +import numpy as np +import scipy +import torchvision.transforms as transforms +import torch.nn.functional as F +from torch.utils.data import DataLoader +from PIL import Image +import imageio +import cv2 +import os +from pathlib import Path +import tqdm +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.imagenet_segmentation import ImagenetSegmentation +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.segmentation_utils import ( + batch_pix_accuracy, + batch_intersection_union, + get_ap_scores, + Saver, +) +from sklearn.metrics import precision_recall_curve +from prs_hook import hook_prs_logger + + +# Args +def get_args_parser(): + parser = argparse.ArgumentParser(description="Segmentation scores") + parser.add_argument("--save_img", action="store_true", default=False, help="") + parser.add_argument( + "--train_dataset", + type=str, + default="imagenet_seg", + help="The name of the dataset", + ) + parser.add_argument( + "--classifier_dataset", + type=str, + default="imagenet", + help="The name of the classifier dataset", + ) + parser.add_argument("--image_size", default=224, type=int, help="Image size") + parser.add_argument("--thr", type=float, default=0.0, help="threshold") + parser.add_argument( + "--data_path", + default="imagenet_seg/gtsegs_ijcv.mat", + type=str, + help="dataset path", + ) + parser.add_argument("--num_workers", default=10, type=int) + parser.add_argument("--classifier_dir", default="./output_dir/") + parser.add_argument("--batch_size", default=1, type=int, help="Batch size") + # Model parameters + parser.add_argument( + "--model", + default="ViT-H-14", + type=str, + metavar="MODEL", + help="Name of model to use", + ) + parser.add_argument("--pretrained", default="laion2b_s32b_b79k", type=str) + parser.add_argument( + "--output_dir", default="./output_dir", help="path where to save" + ) + parser.add_argument("--device", default="cuda:0", help="device to use for testing") + return parser + + +@torch.no_grad() +def eval_batch(model, prs, image, labels, index, args, classifier, saver): + # Save input image + if args.save_img: + # Saves one image from each batch + img = image[0].permute(1, 2, 0).data.cpu().numpy() + img = 255 * (img - img.min()) / (img.max() - img.min()) + img = img.astype("uint8") + Image.fromarray(img, "RGB").save( + os.path.join(saver.results_dir, "input/{}_input.png".format(index)) + ) + Image.fromarray( + (labels.repeat(3, 1, 1).permute(1, 2, 0).data.cpu().numpy() * 255).astype( + "uint8" + ), + "RGB", + ).save(os.path.join(saver.results_dir, "input/{}_mask.png".format(index))) + + # Get the model attention maps: + prs.reinit() + representation = model.encode_image( + image.to(args.device), attn_method="head", normalize=False + ) + attentions, _ = prs.finalize(representation) + attentions = attentions.detach().cpu() # [b, l, n, h, d] + chosen_class = (representation.detach().cpu().numpy() @ classifier).argmax(axis=1) + patches = args.image_size // model.visual.patch_size[0] + attentions_collapse = attentions[:, :, 1:].sum(axis=(1, 3)) + class_heatmap = ( + attentions_collapse.detach().cpu().numpy() @ classifier + ) # [b, n, classes] + results = [] + for i in range(image.shape[0]): + normalized = class_heatmap[i, :, chosen_class[i]] - np.mean( + class_heatmap[i], axis=1 + ) + results.append(normalized) + + results = torch.from_numpy( + np.stack(results, axis=0).reshape((attentions.shape[0], patches, patches)) + ) + + Res = torch.nn.functional.interpolate( + results[:, np.newaxis], + scale_factor=model.visual.patch_size[0], + mode="bilinear" + ).to(args.device) + Res = torch.clip(Res, 0, Res.max()) + # threshold between FG and BG is the mean + Res = (Res - Res.min()) / (Res.max() - Res.min()) + + ret = Res.mean() + + Res_1 = Res.gt(ret).type(Res.type()) + Res_0 = Res.le(ret).type(Res.type()) + + Res_1_AP = Res + Res_0_AP = 1 - Res + + Res_1[Res_1 != Res_1] = 0 + Res_0[Res_0 != Res_0] = 0 + Res_1_AP[Res_1_AP != Res_1_AP] = 0 + Res_0_AP[Res_0_AP != Res_0_AP] = 0 + + # TEST + pred = Res.clamp(min=args.thr) / Res.max() + pred = pred.view(-1).data.cpu().numpy() + target = labels.view(-1).data.cpu().numpy() + + output = torch.cat((Res_0, Res_1), 1) + output_AP = torch.cat((Res_0_AP, Res_1_AP), 1) + + if args.save_img: + # Save predicted mask + mask = F.interpolate(Res_1, [args.image_size, args.image_size], mode="bilinear") + mask = mask[0].squeeze().data.cpu().numpy() + mask = 255 * mask + mask = mask.astype("uint8") + imageio.imsave( + os.path.join(args.exp_img_path, "mask_" + str(index) + ".jpg"), mask + ) + + relevance = F.interpolate(Res, [args.image_size, args.image_size], mode="bicubic") + relevance = relevance[0].permute(1, 2, 0).data.cpu().numpy() + hm = np.sum(relevance, axis=-1) + hm = np.clip(255.0 * hm / hm.max(), 0, 255.0).astype(np.uint8) + high = cv2.cvtColor(cv2.applyColorMap(hm, cv2.COLORMAP_JET), cv2.COLOR_BGR2RGB) + imageio.imsave( + os.path.join(args.exp_img_path, "heatmap_" + str(index) + ".jpg"), high + ) + + # Evaluate Segmentation + batch_inter, batch_union, batch_correct, batch_label = 0, 0, 0, 0 + batch_ap = 0 + + # Segmentation resutls + correct, labeled = batch_pix_accuracy(output[0].data.cpu(), labels[0]) + inter, union = batch_intersection_union(output[0].data.cpu(), labels[0], 2) + batch_correct += correct + batch_label += labeled + batch_inter += inter + batch_union += union + ap = np.nan_to_num(get_ap_scores(output_AP, labels)) + batch_ap += ap + + return batch_correct, batch_label, batch_inter, batch_union, batch_ap, pred, target + + +def _create_saver_and_folders(args): + saver = Saver(args) + saver.results_dir = os.path.join(saver.experiment_dir, "results") + if not os.path.exists(saver.results_dir): + os.makedirs(saver.results_dir) + if not os.path.exists(os.path.join(saver.results_dir, "input")): + os.makedirs(os.path.join(saver.results_dir, "input")) + if not os.path.exists(os.path.join(saver.results_dir, "explain")): + os.makedirs(os.path.join(saver.results_dir, "explain")) + + args.exp_img_path = os.path.join(saver.results_dir, "explain/img") + if not os.path.exists(args.exp_img_path): + os.makedirs(args.exp_img_path) + return saver + + +def main(args): + # Model + model, _, preprocess = create_model_and_transforms( + args.model, pretrained=args.pretrained + ) + model.to(args.device) + model.eval() + context_length = model.context_length + vocab_size = model.vocab_size + + print( + "Model parameters:", + f"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}", + ) + print("Context length:", context_length) + print("Vocab size:", vocab_size) + print("Len of res:", len(model.visual.transformer.resblocks)) + + prs = hook_prs_logger(model, args.device) + # Data + target_transform = transforms.Compose( + [ + transforms.Resize((args.image_size, args.image_size), Image.NEAREST), + ] + ) + + ds = ImagenetSegmentation( + args.data_path, transform=preprocess, target_transform=target_transform + ) + dl = DataLoader( + ds, + batch_size=args.batch_size, + shuffle=False, + num_workers=args.num_workers, + drop_last=False, + ) + iterator = tqdm.tqdm(dl) + # Saver + saver = _create_saver_and_folders(args) + # Classifier + with open( + os.path.join( + args.classifier_dir, + f"{args.classifier_dataset}_classifier_{args.model}.npy", + ), + "rb", + ) as f: + classifier = np.load(f) + # Eval in loop + total_inter, total_union, total_correct, total_label = ( + np.int64(0), + np.int64(0), + np.int64(0), + np.int64(0), + ) + total_ap = [] + + predictions, targets = [], [] + for batch_idx, (image, labels) in enumerate(iterator): + + images = image.to(args.device) + labels = labels.to(args.device) + + correct, labeled, inter, union, ap, pred, target = eval_batch( + model, prs, images, labels, batch_idx, args, classifier, saver + ) + + predictions.append(pred) + targets.append(target) + + total_correct += correct.astype("int64") + total_label += labeled.astype("int64") + total_inter += inter.astype("int64") + total_union += union.astype("int64") + total_ap += [ap] + pixAcc = ( + np.float64(1.0) + * total_correct + / (np.spacing(1, dtype=np.float64) + total_label) + ) + IoU = ( + np.float64(1.0) + * total_inter + / (np.spacing(1, dtype=np.float64) + total_union) + ) + mIoU = IoU.mean() + mAp = np.mean(total_ap) + iterator.set_description( + "pixAcc: %.4f, mIoU: %.4f, mAP: %.4f" % (pixAcc, mIoU, mAp) + ) + + predictions = np.concatenate(predictions) + targets = np.concatenate(targets) + pr, rc, thr = precision_recall_curve(targets, predictions) + np.save(os.path.join(saver.experiment_dir, "precision.npy"), pr) + np.save(os.path.join(saver.experiment_dir, "recall.npy"), rc) + + txtfile = os.path.join(saver.experiment_dir, "result_mIoU_%.4f.txt" % mIoU) + fh = open(txtfile, "w") + print("Mean IoU over %d classes: %.4f\n" % (2, mIoU)) + print("Pixel-wise Accuracy: %2.2f%%\n" % (pixAcc * 100)) + print("Mean AP over %d classes: %.4f\n" % (2, mAp)) + + fh.write("Mean IoU over %d classes: %.4f\n" % (2, mIoU)) + fh.write("Pixel-wise Accuracy: %2.2f%%\n" % (pixAcc * 100)) + fh.write("Mean AP over %d classes: %.4f\n" % (2, mAp)) + fh.close() + + +if __name__ == "__main__": + args = get_args_parser() + args = args.parse_args() + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + main(args) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_projection.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_projection.py new file mode 100644 index 0000000000000000000000000000000000000000..578f30094c99bb8a29633101a5c3d6646f20d9fa --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_projection.py @@ -0,0 +1,104 @@ +import time +import numpy as np +import torch +from PIL import Image +import glob +import sys +import os.path +import argparse +import datetime +import json +from pathlib import Path +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader +import tqdm +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.openai_templates import OPENAI_IMAGENET_TEMPLATES +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.imagenet_classes import imagenet_classes +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.cub_classes import cub_classes, waterbird_classes + + +def get_args_parser(): + parser = argparse.ArgumentParser('Get classifier weights', add_help=False) + # Model parameters + parser.add_argument('--model', default='ViT-H-14', type=str, metavar='MODEL', + help='Name of model to use') + parser.add_argument('--dataset', default='imagenet', help='waterbirds or imagenet') + parser.add_argument('--pretrained', default='laion2b_s32b_b79k', type=str) + # Dataset parameters + parser.add_argument('--output_dir', default='./output_dir', + help='path where to save') + parser.add_argument('--device', default='cuda:0', + help='device to use for testing') + return parser + + + +def zero_shot_classifier(model, tokenizer, classnames, templates, + device, amp=True, use_format=False): + """ + This function returns zero-shot vectors for each class in order + to use it for zero-shot classification. + + + model: + CLIP-like model with `encode_text` + + tokenizer: + text tokenizer, i.e. convert list of strings to torch.Tensor of integers + + classnames: list of str + name of classes + + templates: list of str + templates to use. + + Returns + ------- + + torch.Tensor of shape (N,C) where N is the number + of templates, and C is the number of classes. + """ + autocast = torch.cuda.amp.autocast + with torch.no_grad(), autocast(): + zeroshot_weights = [] + for classname in tqdm.tqdm(classnames): + texts = [template.format(c=classname) if use_format else template(classname) for template in templates] + texts = tokenizer(texts).to(device) # tokenize + class_embeddings = model.encode_text(texts) + class_embedding = F.normalize(class_embeddings, dim=-1).mean(dim=0) + class_embedding /= class_embedding.norm() + zeroshot_weights.append(class_embedding) + zeroshot_weights = torch.stack(zeroshot_weights, dim=1).to(device) + return zeroshot_weights + + +def main(args): + """Calculates the classifier projection weights.""" + model, _, preprocess = create_model_and_transforms(args.model, pretrained=args.pretrained) + tokenizer = get_tokenizer(args.model) + model.to(args.device) + model.eval() + context_length = model.context_length + vocab_size = model.vocab_size + + print("Model parameters:", f"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}") + print("Context length:", context_length) + print("Vocab size:", vocab_size) + classes = { + 'imagenet': imagenet_classes, + 'waterbirds': cub_classes, + 'binary_waterbirds': waterbird_classes, + 'cub': cub_classes}[args.dataset] + classifier = zero_shot_classifier(model, tokenizer, classes, OPENAI_IMAGENET_TEMPLATES, args.device) + with open(os.path.join(args.output_dir, f'{args.dataset}_classifier_{args.model}.npy'), 'wb') as f: + np.save(f, classifier.detach().cpu().numpy()) + + +if __name__ == '__main__': + args = get_args_parser() + args = args.parse_args() + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + main(args) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_set_projection.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_set_projection.py new file mode 100644 index 0000000000000000000000000000000000000000..3b272f24fb5059a9152966ae51b49f6d76d59788 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_text_set_projection.py @@ -0,0 +1,101 @@ +import time +import numpy as np +import torch +from PIL import Image +import glob +import sys +import os.path +import argparse +import datetime +import json +from pathlib import Path +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader +import tqdm + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer + + +def get_args_parser(): + parser = argparse.ArgumentParser('Get text list weights', add_help=False) + # Model parameters + parser.add_argument('--batch_size', default=2048, type=int, + help='Batch size') + parser.add_argument('--model', default='ViT-H-14', type=str, metavar='MODEL', + help='Name of model to use') + parser.add_argument('--pretrained', default='laion2b_s32b_b79k', type=str) + # Dataset parameters + parser.add_argument('--data_path', default='text_descriptions/image_descriptions_general.txt', + type=str, help='dataset path') + parser.add_argument('--num_workers', default=10, type=int) + parser.add_argument('--output_dir', default='./output_dir', + help='path where to save') + parser.add_argument('--device', default='cuda:0', + help='device to use for testing') + return parser + + + +def get_text_features(model, tokenizer, lines, + device, batch_size, amp=True, use_format=False): + """ + This function returns zero-shot vectors for each class in order + to use it for zero-shot classification. + + + model: + CLIP-like model with `encode_text` + + tokenizer: + text tokenizer, i.e. convert list of strings to torch.Tensor of integers + + lines: list of str + name of classes + + Returns + ------- + + torch.Tensor of shape (N,C) where N is the number + of templates, and C is the number of classes. + """ + autocast = torch.cuda.amp.autocast + with torch.no_grad(), autocast(): + zeroshot_weights = [] + for i in tqdm.trange(0, len(lines), batch_size): + texts = lines[i:i+batch_size] + texts = tokenizer(texts).to(device) # tokenize + class_embeddings = model.encode_text(texts) + class_embeddings = F.normalize(class_embeddings, dim=-1) + zeroshot_weights.append(class_embeddings.detach().cpu()) + zeroshot_weights = torch.concatenate(zeroshot_weights, dim=0) + return zeroshot_weights + + +def main(args): + """Calculates the classifier projection weights.""" + model, _, preprocess = create_model_and_transforms(args.model, pretrained=args.pretrained) + tokenizer = get_tokenizer(args.model) + model.to(args.device) + model.eval() + context_length = model.context_length + vocab_size = model.vocab_size + + print("Model parameters:", f"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}") + print("Context length:", context_length) + print("Vocab size:", vocab_size) + with open(args.data_path, 'r') as f: + lines = f.readlines() + base, name = os.path.split(args.data_path) + name = name.replace('.txt', '') + features = get_text_features(model, tokenizer, lines, args.device, args.batch_size) + with open(os.path.join(args.output_dir, f'{name}_{args.model}.npy'), 'wb') as f: + np.save(f, features.numpy()) + + +if __name__ == '__main__': + args = get_args_parser() + args = args.parse_args() + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + main(args) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/compute_use_specific_heads.py b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_use_specific_heads.py new file mode 100644 index 0000000000000000000000000000000000000000..3cbffdcc10c0eae4eb9d9637367eb5c283db9169 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/compute_use_specific_heads.py @@ -0,0 +1,129 @@ +import numpy as np +import torch +import os.path +import argparse +import einops +from pathlib import Path +import random +import tqdm +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import accuracy + + +def full_accuracy(preds, labels, locs_attributes): + locs_labels = labels.detach().cpu().numpy() + accs = {} + for i in [0, 1]: + for j in [0, 1]: + locs = np.logical_and(locs_labels == i, locs_attributes == j) + accs[f"({i}, {j})"] = accuracy(preds[locs], labels[locs])[0] * 100 + accs[f"full"] = accuracy(preds, labels)[0] * 100 + return accs + + +def get_args_parser(): + parser = argparse.ArgumentParser("Ablations part", add_help=False) + + # Model parameters + parser.add_argument( + "--model", + default="ViT-H-14", + type=str, + metavar="MODEL", + help="Name of model to use", + ) + # Dataset parameters + parser.add_argument("--num_workers", default=10, type=int) + parser.add_argument( + "--figures_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--input_dir", default="./output_dir", help="path where data is saved" + ) + parser.add_argument( + "--dataset", + type=str, + default="binary_waterbirds", + help="imagenet, waterbirds, waterbirds_binary or cub", + ) + return parser + + +def main(args): + if args.model == "ViT-H-14": + to_mean_ablate_setting = [(31, 12), (30, 11), (29, 4)] + to_mean_ablate_geo = [(31, 8), (30, 15), (30, 12), (30, 6), (29, 14), (29, 8)] + elif args.model == "ViT-L-14": + to_mean_ablate_geo = [(21, 1), (22, 12), (22, 13), (21, 11), (21, 14), (23, 6)] + to_mean_ablate_setting = [ + (21, 3), + (21, 6), + (21, 8), + (21, 13), + (22, 2), + (22, 12), + (22, 15), + (23, 1), + (23, 3), + (23, 5), + ] + elif args.model == "ViT-B-16": + to_mean_ablate_setting = [(11, 3), (10, 11), (10, 10), (9, 8), (9, 6)] + to_mean_ablate_geo = [(11, 6), (11, 0)] + else: + raise ValueError('model not analyzed') + to_mean_ablate_output = to_mean_ablate_geo + to_mean_ablate_setting + with open( + os.path.join(args.input_dir, f"{args.dataset}_attn_{args.model}.npy"), "rb" + ) as f: + attns = np.load(f) # [b, l, h, d] + with open( + os.path.join(args.input_dir, f"{args.dataset}_mlp_{args.model}.npy"), "rb" + ) as f: + mlps = np.load(f) # [b, l+1, d] + with open( + os.path.join(args.input_dir, f"{args.dataset}_classifier_{args.model}.npy"), + "rb", + ) as f: + classifier = np.load(f) + + if args.dataset == "imagenet": + labels = np.array([i // 50 for i in range(attns.shape[0])]) + else: + with open( + os.path.join(args.input_dir, f"{args.dataset}_labels.npy"), "rb" + ) as f: + labels = np.load(f) + labels = labels[:, :, 0] + baseline = attns.sum(axis=(1, 2)) + mlps.sum(axis=1) + baseline_acc = full_accuracy( + torch.from_numpy(baseline @ classifier).float(), + torch.from_numpy(labels[:, 0]), + labels[:, 1], + ) + print("Baseline:", baseline_acc) + for layer, head in to_mean_ablate_output: + attns[:, layer, head, :] = np.mean( + attns[:, layer, head, :], axis=0, keepdims=True + ) + for layer in range(attns.shape[1] - 4): + for head in range(attns.shape[2]): + attns[:, layer, head, :] = np.mean( + attns[:, layer, head, :], axis=0, keepdims=True + ) + for layer in range(mlps.shape[1]): + mlps[:, layer] = np.mean(mlps[:, layer], axis=0, keepdims=True) + ablated = attns.sum(axis=(1, 2)) + mlps.sum(axis=1) + ablated_acc = full_accuracy( + torch.from_numpy(ablated @ classifier).float(), + torch.from_numpy(labels[:, 0]), + labels[:, 1], + ) + print("Replaced:", ablated_acc) + + +if __name__ == "__main__": + args = get_args_parser() + args = args.parse_args() + if args.figures_dir: + Path(args.figures_dir).mkdir(parents=True, exist_ok=True) + main(args) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/demo.ipynb b/concept_attention/binary_segmentation_baselines/clip_text_span/demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f32c0c6b3da7d34c53e8d2cd877a946885f0ea07 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/demo.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "45da9875-f73a-4d20-94f0-8bb09288f159", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yossi_gandelsman/.local/lib/python3.10/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n" + ] + } + ], + "source": [ + "## Imports\n", + "import numpy as np\n", + "import torch\n", + "from PIL import Image\n", + "import os.path\n", + "import argparse\n", + "from pathlib import Path\n", + "import cv2\n", + "import heapq\n", + "from torch.nn import functional as F\n", + "from torch.utils.data import DataLoader\n", + "import tqdm\n", + "import einops\n", + "from torchvision.datasets import ImageNet\n", + "from torch.utils.data import DataLoader\n", + "from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer\n", + "from concept_attention.binary_segmentation_baselines.clip_text_span.utils.visualization import image_grid, visualization_preprocess\n", + "from prs_hook import hook_prs_logger\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c455c7a2-fdb8-446b-ad9b-d768939be423", + "metadata": {}, + "outputs": [], + "source": [ + "## Hyperparameters\n", + "\n", + "device = 'cuda:0'\n", + "pretrained = 'laion2b_s32b_b82k' # 'laion2b_s32b_b79k'\n", + "model_name = 'ViT-L-14' # 'ViT-H-14'\n", + "batch_size = 2 # only needed for the nn search\n", + "imagenet_path = '/datasets/ilsvrc_2024-01-04_1601/' # only needed for the nn search" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "00f170be-ab26-4405-bf49-c44f9c1644b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model parameters: 427,616,513\n", + "Context length: 77\n", + "Vocab size: 49408\n", + "Len of res: 24\n" + ] + } + ], + "source": [ + "## Loading Model\n", + "\n", + "model, _, preprocess = create_model_and_transforms(model_name, pretrained=pretrained)\n", + "model.to(device)\n", + "model.eval()\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "tokenizer = get_tokenizer(model_name)\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)\n", + "print(\"Len of res:\", len(model.visual.transformer.resblocks))\n", + "\n", + "prs = hook_prs_logger(model, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e1227de5-e3ee-41b3-be91-f5504e69e17c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Load image\n", + "\n", + "image_pil = Image.open('images/catdog.png')\n", + "image = preprocess(image_pil)[np.newaxis, :, :, :]\n", + "_ = plt.imshow(image_pil)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "513eebe1-d598-4c8f-a23d-45eff948cbce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 24, 257, 16, 1024])\n" + ] + } + ], + "source": [ + "## Run the image:\n", + "prs.reinit()\n", + "with torch.no_grad():\n", + " representation = model.encode_image(image.to(device), \n", + " attn_method='head', \n", + " normalize=False)\n", + " attentions, mlps = prs.finalize(representation) # attentions: [1, 32, 257, 16, 1024], mlps: [1, 33, 1024]" + ] + }, + { + "cell_type": "markdown", + "id": "85562f9b-65a6-4835-92ba-893e85db2407", + "metadata": {}, + "source": [ + "## Visualize token decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "76a28a34-4121-49bd-b69c-16d19e4989e2", + "metadata": {}, + "outputs": [], + "source": [ + "## Get the texts\n", + "lines = ['An image of a dog', 'An image of a cat']\n", + "texts = tokenizer(lines).to(device) # tokenize\n", + "class_embeddings = model.encode_text(texts)\n", + "class_embedding = F.normalize(class_embeddings, dim=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cbe8c7b8-cf07-4fcd-aa6f-afdcdb8794fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "An image of a dog\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "An image of a cat\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attention_map = attentions[0, :, 1:, :].sum(axis=(0,2)) @ class_embedding.T\n", + "\n", + "# An image of a dog:\n", + "attention_map = F.interpolate(einops.rearrange(attention_map, '(B N M) C -> B C N M', N=16, M=16, B=1), \n", + " scale_factor=model.visual.patch_size[0],\n", + " mode='bilinear').to(device)\n", + "attention_map = attention_map[0].detach().cpu().numpy()\n", + "print(lines[0])\n", + "plt.imshow(attention_map[0] - np.mean(attention_map,axis=0))\n", + "\n", + "v = attention_map[0] - attention_map[1] # np.mean(attention_map,axis=0)\n", + "min_ = min((attention_map[0] - attention_map[1]).min(), (attention_map[1] - attention_map[0]).min())\n", + "max_ = max((attention_map[0] - attention_map[1]).max(), (attention_map[1] - attention_map[1]).max())\n", + "v = v - min_\n", + "v = np.uint8((v / (max_-min_))*255)\n", + "high = cv2.cvtColor(cv2.applyColorMap(v, cv2.COLORMAP_JET), cv2.COLOR_BGR2RGB)\n", + "plt.colorbar()\n", + "plt.axis('off')\n", + "plt.show()\n", + "print(lines[1])\n", + "plt.imshow(attention_map[1] - np.mean(attention_map,axis=0),)\n", + "\n", + "v = attention_map[1] - attention_map[0]\n", + "v = v - min_\n", + "v = np.uint8((v / (max_-min_))*255)\n", + "high = cv2.cvtColor(cv2.applyColorMap(v, cv2.COLORMAP_JET), cv2.COLOR_BGR2RGB)\n", + "plt.colorbar()\n", + "plt.axis('off')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/environment.yml b/concept_attention/binary_segmentation_baselines/clip_text_span/environment.yml new file mode 100644 index 0000000000000000000000000000000000000000..a8049685ac15405c9b30cd0a70790f17d89569fd --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/environment.yml @@ -0,0 +1,19 @@ +name: prsclip +channels: + - pytorch + - nvidia +dependencies: + - python >= 3.8 + - pytorch >= 1.13 + - torchvision + - pytorch-cuda=11.7 + - pip: + - timm + - einops + - ftfy + - scipy + - imageio + - h5py + - scikit-image + - scikit-learn + - opencv-python \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/nns.ipynb b/concept_attention/binary_segmentation_baselines/clip_text_span/nns.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..71507f75f4037307fb3e45e6e9a40a2dca6862f3 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/nns.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ce479d0c-554a-42ee-b365-84a4d9ab81f7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yossi_gandelsman/.local/lib/python3.10/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n" + ] + } + ], + "source": [ + "## Imports\n", + "import numpy as np\n", + "import torch\n", + "from PIL import Image\n", + "import os.path\n", + "import argparse\n", + "from pathlib import Path\n", + "import cv2\n", + "import heapq\n", + "from torch.nn import functional as F\n", + "from torch.utils.data import DataLoader\n", + "import tqdm\n", + "import einops\n", + "from torchvision.datasets import ImageNet\n", + "from torch.utils.data import DataLoader\n", + "from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer\n", + "from concept_attention.binary_segmentation_baselines.clip_text_span.utils.visualization import image_grid, visualization_preprocess\n", + "from prs_hook import hook_prs_logger\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ee675770-3be8-40bf-8659-31e2d2a811ce", + "metadata": {}, + "outputs": [], + "source": [ + "## Hyperparameters\n", + "\n", + "device = 'cuda:0'\n", + "pretrained = 'laion2b_s32b_b82k' # 'laion2b_s32b_b79k'\n", + "model_name = 'ViT-L-14' # 'ViT-H-14'\n", + "batch_size = 8 # only needed for the nn search\n", + "imagenet_path = '/datasets/ilsvrc_2024-01-04_1601/' # only needed for the nn search" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "93db3598-0d7d-47a4-b6c6-8d02f4902e1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model parameters: 427,616,513\n", + "Context length: 77\n", + "Vocab size: 49408\n", + "Len of res: 24\n" + ] + } + ], + "source": [ + "## Loading Model\n", + "\n", + "model, _, preprocess = create_model_and_transforms(model_name, pretrained=pretrained)\n", + "model.to(device)\n", + "model.eval()\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "tokenizer = get_tokenizer(model_name)\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)\n", + "print(\"Len of res:\", len(model.visual.transformer.resblocks))\n", + "\n", + "prs = hook_prs_logger(model, device, spatial=False) # This makes things faster!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "76f51611-710d-45b9-a797-85a958cc047f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Load image\n", + "\n", + "image_pil = Image.open('images/catdog.png')\n", + "image = preprocess(image_pil)[np.newaxis, :, :, :]\n", + "_ = plt.imshow(image_pil)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2a9b8153-73a3-4f30-bc1d-eddef413df06", + "metadata": {}, + "outputs": [], + "source": [ + "## Run the image:\n", + "prs.reinit()\n", + "with torch.no_grad():\n", + " representation = model.encode_image(image.to(device), \n", + " attn_method='head_no_spatial', \n", + " normalize=False)\n", + " attentions, mlps = prs.finalize(representation) # attentions: [1, 32, 16, 1024], mlps: [1, 33, 1024]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0b17d1c8-2a1a-41c5-9e83-d6a1d51c4007", + "metadata": {}, + "outputs": [], + "source": [ + "## Create the pool for the nn search\n", + "\n", + "ds_vis = ImageNet(root=imagenet_path, split=\"val\", transform=visualization_preprocess) # For showing images\n", + "ds = ImageNet(root=imagenet_path, split=\"val\", transform=preprocess) # For running the model\n", + "dataloader = DataLoader(\n", + " ds, batch_size=batch_size, shuffle=False, num_workers=8\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "47cd5725-eee2-4b58-9d72-6e4477f38d0d", + "metadata": {}, + "outputs": [], + "source": [ + "## Define the head for which you want to search (e.g. \"counting\" head)\n", + "\n", + "search_head = (20, 4) # (layer, head), try also - (23, 8) for color head\n", + "\n", + "query = attentions[0, search_head[0], search_head[1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b35af648-38e0-4715-b5ec-db8dbc56c77a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "6250it [16:23, 6.36it/s]\n" + ] + } + ], + "source": [ + "## Go over and search greedily (alternatively, use the precomputed values)\n", + "\n", + "db = [(-float(\"inf\"), None) for _ in range(15)]\n", + "for index, (images, _) in tqdm.tqdm(enumerate(dataloader)):\n", + " images = images.to(device)\n", + " with torch.no_grad():\n", + " prs.reinit()\n", + " current_representation = model.encode_image(images, \n", + " attn_method='head_no_spatial', \n", + " normalize=False)\n", + " current_attentions, _ = prs.finalize(current_representation) # attentions: [batch_size, layers, heads, repr_size]\n", + " scores = current_attentions[:, search_head[0], search_head[1]] @ query\n", + " for i in range(min(batch_size, images.shape[0])):\n", + " heapq.heappushpop(db, (scores[i], batch_size * index + i))\n", + "db = sorted(db, key=lambda x: -x[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "83aa2e00-4690-4a8b-93c3-833ebb6fe0ca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Plot the top images in a grid:\n", + "images = []\n", + "for image_index in db:\n", + " images.append(ds_vis[image_index[1]][0])\n", + "image_grid(images, 3, 5)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/output_dir/binary_waterbirds_labels.npy b/concept_attention/binary_segmentation_baselines/clip_text_span/output_dir/binary_waterbirds_labels.npy new file mode 100644 index 0000000000000000000000000000000000000000..57ed32db91e79386ecbbff85b4b41c2d7562b9ab Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/clip_text_span/output_dir/binary_waterbirds_labels.npy differ diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/prs_hook.py b/concept_attention/binary_segmentation_baselines/clip_text_span/prs_hook.py new file mode 100644 index 0000000000000000000000000000000000000000..dbbc45a97440a92576dc3f7e01c2981cf85adab6 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/prs_hook.py @@ -0,0 +1,183 @@ +import time +import numpy as np +import torch +from PIL import Image +import glob +import sys +import argparse +import datetime +import json +from pathlib import Path + + +class PRSLogger(object): + def __init__(self, model, device, spatial: bool = True): + self.current_layer = 0 + self.device = device + self.attentions = [] + self.mlps = [] + self.spatial = spatial + self.post_ln_std = None + self.post_ln_mean = None + self.model = model + + @torch.no_grad() + def compute_attentions_spatial(self, ret): + assert len(ret.shape) == 5, "Verify that you use method=`head` and not method=`head_no_spatial`" # [b, n, m, h, d] + assert self.spatial, "Verify that you use method=`head` and not method=`head_no_spatial`" + bias_term = self.model.visual.transformer.resblocks[ + self.current_layer + ].attn.out_proj.bias + self.current_layer += 1 + return_value = ret[:, 0].detach().cpu() # This is only for the cls token + self.attentions.append( + return_value + + bias_term[np.newaxis, np.newaxis, np.newaxis].cpu() + / (return_value.shape[1] * return_value.shape[2]) + ) # [b, n, h, d] + return ret + + @torch.no_grad() + def compute_attentions_non_spatial(self, ret): + assert len(ret.shape) == 4, "Verify that you use method=`head_no_spatial` and not method=`head`" # [b, n, h, d] + assert not self.spatial, "Verify that you use method=`head_no_spatial` and not method=`head`" + bias_term = self.model.visual.transformer.resblocks[ + self.current_layer + ].attn.out_proj.bias + self.current_layer += 1 + return_value = ret[:, 0].detach().cpu() # This is only for the cls token + self.attentions.append( + return_value + + bias_term[np.newaxis, np.newaxis].cpu() + / (return_value.shape[1]) + ) # [b, h, d] + return ret + + @torch.no_grad() + def compute_mlps(self, ret): + self.mlps.append(ret[:, 0].detach().cpu()) # [b, d] + return ret + + @torch.no_grad() + def log_post_ln_mean(self, ret): + self.post_ln_mean = ret.detach().cpu() # [b, 1] + return ret + + @torch.no_grad() + def log_post_ln_std(self, ret): + self.post_ln_std = ret.detach().cpu() # [b, 1] + return ret + + def _normalize_mlps(self): + len_intermediates = self.attentions.shape[1] + self.mlps.shape[1] + # This is just the normalization layer: + mean_centered = ( + self.mlps + - self.post_ln_mean[:, :, np.newaxis].to(self.device) / len_intermediates + ) + weighted_mean_centered = ( + self.model.visual.ln_post.weight.detach().to(self.device) * mean_centered + ) + weighted_mean_by_std = weighted_mean_centered / self.post_ln_std[ + :, :, np.newaxis + ].to(self.device) + bias_term = ( + self.model.visual.ln_post.bias.detach().to(self.device) / len_intermediates + ) + post_ln = weighted_mean_by_std + bias_term + return post_ln @ self.model.visual.proj.detach().to(self.device) + + def _normalize_attentions_spatial(self): + len_intermediates = self.attentions.shape[1] + self.mlps.shape[1] # 2*l + 1 + normalization_term = ( + self.attentions.shape[2] * self.attentions.shape[3] + ) # n * h + # This is just the normalization layer: + mean_centered = self.attentions - self.post_ln_mean[ + :, :, np.newaxis, np.newaxis, np.newaxis + ].to(self.device) / (len_intermediates * normalization_term) + weighted_mean_centered = ( + self.model.visual.ln_post.weight.detach().to(self.device) * mean_centered + ) + weighted_mean_by_std = weighted_mean_centered / self.post_ln_std[ + :, :, np.newaxis, np.newaxis, np.newaxis + ].to(self.device) + bias_term = self.model.visual.ln_post.bias.detach().to(self.device) / ( + len_intermediates * normalization_term + ) + post_ln = weighted_mean_by_std + bias_term + return post_ln @ self.model.visual.proj.detach().to(self.device) + + def _normalize_attentions_non_spatial(self): + len_intermediates = self.attentions.shape[1] + self.mlps.shape[1] # 2*l + 1 + normalization_term = ( + self.attentions.shape[2] + ) # h + # This is just the normalization layer: + mean_centered = self.attentions - self.post_ln_mean[ + :, :, np.newaxis, np.newaxis + ].to(self.device) / (len_intermediates * normalization_term) + weighted_mean_centered = ( + self.model.visual.ln_post.weight.detach().to(self.device) * mean_centered + ) + weighted_mean_by_std = weighted_mean_centered / self.post_ln_std[ + :, :, np.newaxis, np.newaxis + ].to(self.device) + bias_term = self.model.visual.ln_post.bias.detach().to(self.device) / ( + len_intermediates * normalization_term + ) + post_ln = weighted_mean_by_std + bias_term + return post_ln @ self.model.visual.proj.detach().to(self.device) + + @torch.no_grad() + def finalize(self, representation): + """We calculate the post-ln scaling, project it and normalize by the last norm.""" + self.attentions = torch.stack(self.attentions, axis=1).to( + self.device + ) # [b, l, n, h, d] + self.mlps = torch.stack(self.mlps, axis=1).to(self.device) # [b, l + 1, d] + if self.spatial: + projected_attentions = self._normalize_attentions_spatial() + else: + projected_attentions = self._normalize_attentions_non_spatial() + projected_mlps = self._normalize_mlps() + norm = representation.norm(dim=-1).detach() + if self.spatial: + return ( + projected_attentions + / norm[:, np.newaxis, np.newaxis, np.newaxis, np.newaxis], + projected_mlps / norm[:, np.newaxis, np.newaxis], + ) + return ( + projected_attentions + / norm[:, np.newaxis, np.newaxis, np.newaxis], + projected_mlps / norm[:, np.newaxis, np.newaxis], + ) + + def reinit(self): + self.current_layer = 0 + self.attentions = [] + self.mlps = [] + self.post_ln_mean = None + self.post_ln_std = None + torch.cuda.empty_cache() + + +def hook_prs_logger(model, device, spatial: bool = True): + """Hooks a projected residual stream logger to the model.""" + prs = PRSLogger(model, device, spatial=spatial) + if spatial: + model.hook_manager.register( + "visual.transformer.resblocks.*.attn.out.post", prs.compute_attentions_spatial + ) + else: + model.hook_manager.register( + "visual.transformer.resblocks.*.attn.out.post", prs.compute_attentions_non_spatial + ) + model.hook_manager.register( + "visual.transformer.resblocks.*.mlp.c_proj.post", prs.compute_mlps + ) + model.hook_manager.register("visual.ln_pre_post", prs.compute_mlps) + model.hook_manager.register("visual.ln_post.mean", prs.log_post_ln_mean) + model.hook_manager.register("visual.ln_post.sqrt_var", prs.log_post_ln_std) + return prs diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/google_3498_english.txt b/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/google_3498_english.txt new file mode 100644 index 0000000000000000000000000000000000000000..8237738b84fcdc12fbe929ff167a9ddaa8c8bf92 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/google_3498_english.txt @@ -0,0 +1,3498 @@ +the +of +and +to +a +in +for +is +on +that +by +this +with +i +you +it +not +or +be +are +from +at +as +your +all +have +new +more +an +was +we +will +home +can +us +about +if +page +my +has +search +free +but +our +one +other +do +no +information +time +they +site +he +up +may +what +which +their +news +out +use +any +there +see +only +so +his +when +contact +here +business +who +web +also +now +help +get +pm +view +online +c +e +first +am +been +would +how +were +me +s +services +some +these +click +its +like +service +x +than +find +price +date +back +top +people +had +list +name +just +over +state +year +day +into +email +two +health +n +world +re +next +used +go +b +work +last +most +products +music +buy +data +make +them +should +product +system +post +her +city +t +add +policy +number +such +please +available +copyright +support +message +after +best +software +then +jan +good +video +well +d +where +info +rights +public +books +high +school +through +m +each +links +she +review +years +order +very +privacy +book +items +company +r +read +group +sex +need +many +user +said +de +does +set +under +general +research +university +january +mail +full +map +reviews +program +life +know +games +way +days +management +p +part +could +great +united +hotel +real +f +item +international +center +ebay +must +store +travel +comments +made +development +report +off +member +details +line +terms +before +hotels +did +send +right +type +because +local +those +using +results +office +education +national +car +design +take +posted +internet +address +community +within +states +area +want +phone +dvd +shipping +reserved +subject +between +forum +family +l +long +based +w +code +show +o +even +black +check +special +prices +website +index +being +women +much +sign +file +link +open +today +technology +south +case +project +same +pages +uk +version +section +own +found +sports +house +related +security +both +g +county +american +photo +game +members +power +while +care +network +down +computer +systems +three +total +place +end +following +download +h +him +without +per +access +think +north +resources +current +posts +big +media +law +control +water +history +pictures +size +art +personal +since +including +guide +shop +directory +board +location +change +white +text +small +rating +rate +government +children +during +usa +return +students +v +shopping +account +times +sites +level +digital +profile +previous +form +events +love +old +john +main +call +hours +image +department +title +description +non +k +y +insurance +another +why +shall +property +class +cd +still +money +quality +every +listing +content +country +private +little +visit +save +tools +low +reply +customer +december +compare +movies +include +college +value +article +york +man +card +jobs +provide +j +food +source +author +different +press +u +learn +sale +around +print +course +job +canada +process +teen +room +stock +training +too +credit +point +join +science +men +categories +advanced +west +sales +look +english +left +team +estate +box +conditions +select +windows +photos +gay +thread +week +category +note +live +large +gallery +table +register +however +june +october +november +market +library +really +action +start +series +model +features +air +industry +plan +human +provided +tv +yes +required +second +hot +accessories +cost +movie +forums +march +la +september +better +say +questions +july +yahoo +going +medical +test +friend +come +dec +server +pc +study +application +cart +staff +articles +san +feedback +again +play +looking +issues +april +never +users +complete +street +topic +comment +financial +things +working +against +standard +tax +person +below +mobile +less +got +blog +party +payment +equipment +login +student +let +programs +offers +legal +above +recent +park +stores +side +act +problem +red +give +memory +performance +social +q +august +quote +language +story +sell +options +experience +rates +create +key +body +young +america +important +field +few +east +paper +single +ii +age +activities +club +example +girls +additional +password +z +latest +something +road +gift +question +changes +night +ca +hard +texas +oct +pay +four +poker +status +browse +issue +range +building +seller +court +february +always +result +audio +light +write +war +nov +offer +blue +groups +al +easy +given +files +event +release +analysis +request +fax +china +making +picture +needs +possible +might +professional +yet +month +major +star +areas +future +space +committee +hand +sun +cards +problems +london +washington +meeting +rss +become +interest +id +child +keep +enter +california +porn +share +similar +garden +schools +million +added +reference +companies +listed +baby +learning +energy +run +delivery +net +popular +term +film +stories +put +computers +journal +reports +co +try +welcome +central +images +president +notice +god +original +head +radio +until +cell +color +self +council +away +includes +track +australia +discussion +archive +once +others +entertainment +agreement +format +least +society +months +log +safety +friends +sure +faq +trade +edition +cars +messages +marketing +tell +further +updated +association +able +having +provides +david +fun +already +green +studies +close +common +drive +specific +several +gold +feb +living +sep +collection +called +short +arts +lot +ask +display +limited +powered +solutions +means +director +daily +beach +past +natural +whether +due +et +electronics +five +upon +period +planning +database +says +official +weather +mar +land +average +done +technical +window +france +pro +region +island +record +direct +microsoft +conference +environment +records +st +district +calendar +costs +style +url +front +statement +update +parts +aug +ever +downloads +early +miles +sound +resource +present +applications +either +ago +document +word +works +material +bill +apr +written +talk +federal +hosting +rules +final +adult +tickets +thing +centre +requirements +via +cheap +nude +kids +finance +true +minutes +else +mark +third +rock +gifts +europe +reading +topics +bad +individual +tips +plus +auto +cover +usually +edit +together +videos +percent +fast +function +fact +unit +getting +global +tech +meet +far +economic +en +player +projects +lyrics +often +subscribe +submit +germany +amount +watch +included +feel +though +bank +risk +thanks +everything +deals +various +words +linux +jul +production +commercial +james +weight +town +heart +advertising +received +choose +treatment +newsletter +archives +points +knowledge +magazine +error +camera +jun +girl +currently +construction +toys +registered +clear +golf +receive +domain +methods +chapter +makes +protection +policies +loan +wide +beauty +manager +india +position +taken +sort +listings +models +michael +known +half +cases +step +engineering +florida +simple +quick +none +wireless +license +paul +friday +lake +whole +annual +published +later +basic +sony +shows +corporate +google +church +method +purchase +customers +active +response +practice +hardware +figure +materials +fire +holiday +chat +enough +designed +along +among +death +writing +speed +html +countries +loss +face +brand +discount +higher +effects +created +remember +standards +oil +bit +yellow +political +increase +advertise +kingdom +base +near +environmental +thought +stuff +french +storage +oh +japan +doing +loans +shoes +entry +stay +nature +orders +availability +africa +summary +turn +mean +growth +notes +agency +king +monday +european +activity +copy +although +drug +pics +western +income +force +cash +employment +overall +bay +river +commission +ad +package +contents +seen +players +engine +port +album +regional +stop +supplies +started +administration +bar +institute +views +plans +double +dog +build +screen +exchange +types +soon +sponsored +lines +electronic +continue +across +benefits +needed +season +apply +someone +held +ny +anything +printer +condition +effective +believe +organization +effect +asked +eur +mind +sunday +selection +casino +pdf +lost +tour +menu +volume +cross +anyone +mortgage +hope +silver +corporation +wish +inside +solution +mature +role +rather +weeks +addition +came +supply +nothing +certain +usr +executive +running +lower +necessary +union +jewelry +according +dc +clothing +mon +com +particular +fine +names +robert +homepage +hour +gas +skills +six +bush +islands +advice +career +military +rental +decision +leave +british +teens +pre +huge +sat +woman +facilities +zip +bid +kind +sellers +middle +move +cable +opportunities +taking +values +division +coming +tuesday +object +lesbian +appropriate +machine +logo +length +actually +nice +score +statistics +client +ok +returns +capital +follow +sample +investment +sent +shown +saturday +christmas +england +culture +band +flash +ms +lead +george +choice +went +starting +registration +fri +thursday +courses +consumer +hi +airport +foreign +artist +outside +furniture +levels +channel +letter +mode +phones +ideas +wednesday +structure +fund +summer +allow +degree +contract +button +releases +wed +homes +super +male +matter +custom +virginia +almost +took +located +multiple +asian +distribution +editor +inn +industrial +cause +potential +song +cnet +ltd +los +hp +focus +late +fall +featured +idea +rooms +female +responsible +inc +communications +win +associated +thomas +primary +cancer +numbers +reason +tool +browser +spring +foundation +answer +voice +eg +friendly +schedule +documents +communication +purpose +feature +bed +comes +police +everyone +independent +ip +approach +cameras +brown +physical +operating +hill +maps +medicine +deal +hold +ratings +chicago +forms +glass +happy +tue +smith +wanted +developed +thank +safe +unique +survey +prior +telephone +sport +ready +feed +animal +sources +mexico +population +pa +regular +secure +navigation +operations +therefore +ass +simply +evidence +station +christian +round +paypal +favorite +understand +option +master +valley +recently +probably +thu +rentals +sea +built +publications +blood +cut +worldwide +improve +connection +publisher +hall +larger +anti +networks +earth +parents +nokia +impact +transfer +introduction +kitchen +strong +tel +carolina +wedding +properties +hospital +ground +overview +ship +accommodation +owners +disease +tx +excellent +paid +italy +perfect +hair +opportunity +kit +classic +basis +command +cities +william +express +anal +award +distance +tree +peter +assessment +ensure +thus +wall +ie +involved +el +extra +especially +interface +pussy +partners +budget +rated +guides +success +maximum +ma +operation +existing +quite +selected +boy +amazon +patients +restaurants +beautiful +warning +wine +locations +horse +vote +forward +flowers +stars +significant +lists +technologies +owner +retail +animals +useful +directly +manufacturer +ways +est +son +providing +rule +mac +housing +takes +iii +gmt +bring +catalog +searches +max +trying +mother +authority +considered +told +xml +traffic +programme +joined +input +strategy +feet +agent +valid +bin +modern +senior +ireland +sexy +teaching +door +grand +testing +trial +charge +units +instead +canadian +cool +normal +wrote +enterprise +ships +entire +educational +md +leading +metal +positive +fl +fitness +chinese +opinion +mb +asia +football +abstract +uses +output +funds +mr +greater +likely +develop +employees +artists +alternative +processing +responsibility +resolution +java +guest +seems +publication +pass +relations +trust +van +contains +session +multi +photography +republic +fees +components +vacation +century +academic +assistance +completed +skin +graphics +indian +prev +ads +mary +il +expected +ring +grade +dating +pacific +mountain +organizations +pop +filter +mailing +vehicle +longer +consider +int +northern +behind +panel +floor +german +buying +match +proposed +default +require +iraq +boys +outdoor +deep +morning +otherwise +allows +rest +protein +plant +reported +hit +transportation +mm +pool +mini +politics +partner +disclaimer +authors +boards +faculty +parties +fish +membership +mission +eye +string +sense +modified +pack +released +stage +internal +goods +recommended +born +unless +richard +detailed +japanese +race +approved +background +target +except +character +usb +maintenance +ability +maybe +functions +ed +moving +brands +places +php +pretty +trademarks +phentermine +spain +southern +yourself +etc +winter +rape +battery +youth +pressure +submitted +boston +incest +debt +keywords +medium +television +interested +core +break +purposes +throughout +sets +dance +wood +msn +itself +defined +papers +playing +awards +fee +studio +reader +virtual +device +established +answers +rent +las +remote +dark +programming +external +apple +le +regarding +instructions +min +offered +theory +enjoy +remove +aid +surface +minimum +visual +host +variety +teachers +isbn +martin +manual +block +subjects +agents +increased +repair +fair +civil +steel +understanding +songs +fixed +wrong +beginning +hands +associates +finally +az +updates +desktop +classes +paris +ohio +gets +sector +capacity +requires +jersey +un +fat +fully +father +electric +saw +instruments +quotes +officer +driver +businesses +dead +respect +unknown +specified +restaurant +mike +trip +pst +worth +mi +procedures +poor +teacher +xxx +eyes +relationship +workers +farm +fucking +georgia +peace +traditional +campus +tom +showing +creative +coast +benefit +progress +funding +devices +lord +grant +sub +agree +fiction +hear +sometimes +watches +careers +beyond +goes +families +led +museum +themselves +fan +transport +interesting +blogs +wife +evaluation +accepted +former +implementation +ten +hits +zone +complex +th +cat +galleries +references +die +presented +jack +flat +flow +agencies +literature +respective +parent +spanish +michigan +columbia +setting +dr +scale +stand +economy +highest +helpful +monthly +critical +frame +musical +definition +secretary +angeles +networking +path +australian +employee +chief +gives +kb +bottom +magazines +packages +detail +francisco +laws +changed +pet +heard +begin +individuals +colorado +royal +clean +switch +russian +largest +african +guy +titles +relevant +guidelines +justice +connect +bible +dev +cup +basket +applied +weekly +vol +installation +described +demand +pp +suite +vegas +na +square +chris +attention +advance +skip +diet +army +auction +gear +lee +os +difference +allowed +correct +charles +nation +selling +lots +piece +sheet +firm +seven +older +illinois +regulations +elements +species +jump +cells +module +resort +facility +random +pricing +dvds +certificate +minister +motion +looks +fashion +directions +visitors +documentation +monitor +trading +forest +calls +whose +coverage +couple +giving +chance +vision +ball +ending +clients +actions +listen +discuss +accept +automotive +naked +goal +successful +sold +wind +communities +clinical +situation +sciences +markets +lowest +highly +publishing +appear +emergency +developing +lives +currency +leather +determine +milf +temperature +palm +announcements +patient +actual +historical +stone +bob +commerce +ringtones +perhaps +persons +difficult +scientific +satellite +fit +tests +village +accounts +amateur +ex +met +pain +xbox +particularly +factors +coffee +www +settings +cum +buyer +cultural +steve +easily +oral +ford +poster +edge +functional +root +au +fi +closed +holidays +ice +pink +zealand +balance +monitoring +graduate +replies +shot +nc +architecture +initial +label +thinking +scott +llc +sec +recommend +canon +hardcore +league +waste +minute +bus +provider +optional +dictionary +cold +accounting +manufacturing +sections +chair +fishing +effort +phase +fields +bag +fantasy +po +letters +motor +va +professor +context +install +shirt +apparel +generally +continued +foot +mass +crime +count +breast +techniques +ibm +rd +johnson +sc +quickly +dollars +websites +religion +claim +driving +permission +surgery +patch +heat +wild +measures +generation +kansas +miss +chemical +doctor +task +reduce +brought +himself +nor +component +enable +exercise +bug +santa +mid +guarantee +leader +diamond +israel +se +processes +soft +servers +alone +meetings +seconds +jones +arizona +keyword +interests +flight +congress +fuel +username +walk +fuck +produced +italian +paperback +classifieds +wait +supported +pocket +saint +rose +freedom +argument +competition +creating +jim +drugs +joint +premium +providers +fresh +characters +attorney +upgrade +di +factor +growing +thousands +km +stream +apartments +pick +hearing +eastern +auctions +therapy +entries +dates +generated +signed +upper +administrative +serious +prime +samsung +limit +began +louis +steps +errors +shops +bondage +del +efforts +informed +ga +ac +thoughts +creek +ft +worked +quantity +urban +practices +sorted +reporting +essential +myself +tours +platform +load +affiliate +labor +immediately +admin +nursing +defense +machines +designated +tags +heavy +covered +recovery +joe +guys +integrated +configuration +cock +merchant +comprehensive +expert +universal +protect +drop +solid +cds +presentation +languages +became +orange +compliance +vehicles +prevent +theme +rich +im +campaign +marine +improvement +vs +guitar +finding +pennsylvania +examples +ipod +saying +spirit +ar +claims +porno +challenge +motorola +acceptance +strategies +mo +seem +affairs +touch +intended +towards +sa +goals +hire +election +suggest +branch +charges +serve +affiliates +reasons +magic +mount +smart +talking +gave +ones +latin +multimedia +xp +tits +avoid +certified +manage +corner +rank +computing +oregon +element +birth +virus +abuse +interactive +requests +separate +quarter +procedure +leadership +tables +define +racing +religious +facts +breakfast +kong +column +plants +faith +chain +developer +identify +avenue +missing +died +approximately +domestic +sitemap +recommendations +moved +houston +reach +comparison +mental +viewed +moment +extended +sequence +inch +attack +sorry +centers +opening +damage +lab +reserve +recipes +cvs +gamma +plastic +produce +snow +placed +truth +counter +failure +follows +eu +weekend +dollar +camp +ontario +automatically +des +minnesota +films +bridge +native +fill +williams +movement +printing +baseball +owned +approval +draft +chart +played +contacts +cc +jesus +readers +clubs +lcd +wa +jackson +equal +adventure +matching +offering +shirts +profit +leaders +posters +institutions +assistant +variable +ave +dj +advertisement +expect +parking +headlines +yesterday +compared +determined +wholesale +workshop +russia +gone +codes +kinds +extension +seattle +statements +golden +completely +teams +fort +cm +wi +lighting +senate +forces +funny +brother +gene +turned +portable +tried +electrical +applicable +disc +returned +pattern +ct +hentai +boat +named +theatre +laser +earlier +manufacturers +sponsor +classical +icon +warranty +dedicated +indiana +direction +harry +basketball +objects +ends +delete +evening +assembly +nuclear +taxes +mouse +signal +criminal +issued +brain +sexual +wisconsin +powerful +dream +obtained +false +da +cast +flower +felt +personnel +passed +supplied +identified +falls +pic +soul +aids +opinions +promote +stated +stats +hawaii +professionals +appears +carry +flag +decided +nj +covers +hr +em +advantage +hello +designs +maintain +tourism +priority +newsletters +adults +clips +savings +iv +graphic +atom +payments +rw +estimated +binding +brief +ended +winning +eight +anonymous +iron +straight +script +served +wants +miscellaneous +prepared +void +dining +alert +integration +atlanta +dakota +tag +interview +mix +framework +disk +installed +queen +vhs +credits +clearly +fix +handle +sweet +desk +criteria +pubmed +dave +massachusetts +diego +hong +vice +associate +ne +truck +behavior +enlarge +ray +frequently +revenue +measure +changing +votes +du +duty +looked +discussions +bear +gain +festival +laboratory +ocean +flights +experts +signs +lack +depth +iowa +whatever +logged +laptop +vintage +train +exactly +dry +explore +maryland +spa +concept +nearly +eligible +checkout +reality +forgot +handling +origin +knew +gaming +feeds +billion +destination +scotland +faster +intelligence +dallas +bought +con +ups +nations +route +followed +specifications +broken +tripadvisor +frank +alaska +zoom +blow +battle +residential +anime +speak +decisions +industries +protocol +query +clip +partnership +editorial +nt +expression +es +equity +provisions +speech +wire +principles +suggestions +rural +shared +sounds +replacement +tape +strategic +judge +spam +economics +acid +bytes +cent +forced +compatible +fight +apartment +height +null +zero +speaker +filed +gb +netherlands +obtain +bc +consulting +recreation +offices +designer +remain +managed +pr +failed +marriage +roll +korea +banks +fr +participants +secret +bath +aa +kelly +leads +negative +austin +favorites +toronto +theater +springs +missouri +andrew +var +perform +healthy +translation +estimates +font +assets +injury +mt +joseph +ministry +drivers +lawyer +figures +married +protected +proposal +sharing +philadelphia +portal +waiting +birthday +beta +fail +gratis +banking +officials +brian +toward +won +slightly +assist +conduct +contained +lingerie +shemale +legislation +calling +parameters +jazz +serving +bags +profiles +miami +comics +matters +houses +doc +postal +relationships +tennessee +wear +controls +breaking +combined +ultimate +wales +representative +frequency +introduced +minor +finish +departments +residents +noted +displayed +mom +reduced +physics +rare +spent +performed +extreme +samples +davis +daniel +bars +reviewed +row +oz +forecast +removed +helps +singles +administrator +cycle +amounts +contain +accuracy +dual +rise +usd +sleep +mg +bird +pharmacy +brazil +creation +static +scene +hunter +addresses +lady +crystal +famous +writer +chairman +violence +fans +oklahoma +speakers +drink +academy +dynamic +gender +eat +permanent +agriculture +dell +cleaning +constitutes +portfolio +practical +delivered +collectibles +infrastructure +exclusive +seat +concerns +colour +vendor +originally +intel +utilities +philosophy +regulation +officers +reduction +aim +bids +referred +supports +nutrition +recording +regions +junior +toll +les +cape +ann +rings +meaning +tip +secondary +wonderful +mine +ladies +henry +ticket +announced +guess +agreed +prevention +whom +ski +soccer +math +import +posting +presence +instant +mentioned +automatic +healthcare +viewing +maintained +ch +increasing +majority +connected +christ +dan +dogs +sd +directors +aspects +austria +ahead +moon +participation +scheme +utility +preview +fly +manner +matrix +containing +combination +devel +amendment +despite +strength +guaranteed +turkey +libraries +proper +distributed +degrees +singapore +enterprises +delta +fear +seeking +inches +phoenix +rs +convention +shares +principal +daughter +standing +voyeur +comfort +colors +wars +cisco +ordering +kept +alpha +appeal +cruise +bonus +certification +previously +hey +bookmark +buildings +specials +beat +disney +household +batteries +adobe +smoking +bbc +becomes +drives +arms +alabama +tea +improved +trees +avg +achieve +positions +dress +subscription +dealer +contemporary +sky +utah +nearby +rom +carried +happen +exposure +panasonic +hide +permalink +signature +gambling +refer +miller +provision +outdoors +clothes +caused +luxury +babes +frames +viagra +certainly +indeed +newspaper +toy +circuit +layer +printed +slow +removal +easier +src +liability +trademark +hip +printers +faqs +nine +adding +kentucky +mostly +eric +spot +taylor +trackback +prints +spend +factory +interior +revised +grow +americans +optical +promotion +relative +amazing +clock +dot +hiv +identity +suites +conversion +feeling +hidden +reasonable +victoria +serial +relief +revision +broadband +influence +ratio +pda +importance +rain +onto +dsl +planet +webmaster +copies +recipe +zum +permit +seeing +proof +dna +diff +tennis +bass +prescription +bedroom +empty +instance +hole +pets +ride +licensed +orlando +specifically +tim +bureau +maine +sql +represent +conservation +pair +ideal +specs +recorded +don +pieces +finished +parks +dinner +lawyers +sydney +stress +cream +ss +runs +trends +yeah +discover +sexo +ap +patterns +boxes +louisiana +hills +javascript +fourth +nm +advisor +mn +marketplace +nd +evil +aware +wilson +shape +evolution +irish +certificates +objectives +stations +suggested +gps +op +remains +acc +greatest +firms +concerned +euro +operator +structures +generic +encyclopedia +usage +cap +ink +charts +continuing +mixed +census +interracial +peak +tn +competitive +exist +wheel +transit +dick +suppliers +salt +compact +poetry +lights +tracking +angel +bell +keeping +preparation +attempt +receiving +matches +accordance +width +noise +engines +forget +array +discussed +accurate +stephen +elizabeth +climate +reservations +pin +playstation +alcohol +greek +instruction +managing +annotation +sister +raw +differences +walking +explain +smaller +newest +establish +gnu +happened +expressed +jeff +extent +sharp +lesbians +ben +lane +paragraph +kill +mathematics +aol +compensation +ce +export +managers +aircraft +modules +sweden +conflict +conducted +versions +employer +occur +percentage +knows +mississippi +describe +concern +backup +requested +citizens +connecticut +heritage +personals +immediate +holding +trouble +spread +coach +kevin +agricultural +expand +supporting +audience +assigned +jordan +collections +ages +participate +plug +specialist +cook +affect +virgin +experienced +investigation +raised +hat +institution +directed +dealers +searching +sporting +helping +perl +affected +lib +bike +totally +plate +expenses +indicate +blonde +ab +proceedings +favourite +transmission +anderson +utc +characteristics +der +lose +organic +seek +experiences +albums +cheats +extremely +verzeichnis +contracts +guests +hosted +diseases +concerning +developers +equivalent +chemistry +tony +neighborhood +nevada +kits +thailand +variables +agenda +anyway +continues +tracks +advisory +cam +curriculum +logic +template +prince +circle +soil +grants +anywhere +psychology +responses +atlantic +wet +circumstances +edward +investor +identification +ram +leaving +wildlife +appliances +matt +elementary +cooking +speaking +sponsors +fox +unlimited +respond +sizes +plain +exit +entered +iran +arm +keys +launch +wave +checking +costa +belgium +printable +holy +acts +guidance +mesh +trail +enforcement +symbol +crafts +highway +buddy +hardcover +observed +dean +setup +poll +booking +glossary +fiscal +celebrity +styles +denver +unix +filled +bond +channels +ericsson +appendix +notify +blues +chocolate +pub +portion +scope +hampshire +supplier +cables +cotton +bluetooth +controlled +requirement +authorities +biology +dental +killed +border +ancient +debate +representatives +starts +pregnancy +causes +arkansas +biography +leisure +attractions +learned +transactions +notebook +explorer +historic +attached +opened +tm +husband +disabled +authorized +crazy +upcoming +britain +concert +retirement +scores +financing +efficiency +sp +comedy +adopted +efficient +weblog +linear +commitment +specialty +bears +jean +hop +carrier +edited +constant +visa +mouth +jewish +meter +linked +portland +interviews +concepts +nh +gun +reflect +pure +deliver +wonder +hell +lessons +fruit +begins +qualified +reform +lens +alerts +treated +discovery +draw +mysql +classified +relating +assume +confidence +alliance +fm +confirm +warm +neither +lewis +howard +offline +leaves +engineer +lifestyle +consistent +replace +clearance +connections +inventory +converter +suck +organisation +babe +checks +reached +becoming +blowjob +safari +objective +indicated +sugar +crew +legs +sam +stick +securities +allen +pdt +relation +enabled +genre +slide +montana +volunteer +tested +rear +democratic +enhance +switzerland +exact +bound +parameter +adapter +processor +node +formal +dimensions +contribute +lock +hockey +storm +micro +colleges +laptops +mile +showed +challenges +editors +mens +threads +bowl +supreme +brothers +recognition +presents +ref +tank +submission +dolls +estimate +encourage +navy +kid +regulatory +inspection +consumers +cancel +limits +territory +transaction +manchester +weapons +paint +delay +pilot +outlet +contributions +continuous +db +czech +resulting +cambridge +initiative +novel +pan +execution +disability +increases +ultra +winner +idaho +contractor +ph +episode +examination +potter +dish +plays +bulletin +ia +pt +indicates +modify +oxford +adam +truly +epinions +painting +committed +extensive +affordable +universe +candidate +databases +patent +slot +psp +outstanding +ha +eating +perspective +planned +watching +lodge +messenger +mirror \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/image_descriptions_general.txt b/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/image_descriptions_general.txt new file mode 100644 index 0000000000000000000000000000000000000000..1c4d1b953440de494e21e4d2a06c6caabbad574f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/text_descriptions/image_descriptions_general.txt @@ -0,0 +1,3498 @@ +A badge +A bag +A ball +A bamboo +Abandoned factory space +Abandoned spaces +A barbed wire design +A barcode +A basket +A beam +A beautiful photo +A belt +A bicycle +A blade +A blade (of a fan or a saw) +A blade (of grass or a knife) +A blanket +A blurry image +A bolt +A bonnet +A book +A bookmark +A boot +A bottle +A bowl +A bracelet +A branch +A breeze +A brick +A brush +Abstract acrylic painting +Abstract artwork with concentric circles +Abstract artwork with cross-hatching +Abstract artwork with splatter paint +Abstract artwork with swirls +Abstract composition +Abstract expressionist artwork +Abstract form +Abstract geometric patterns +abstract geometric shapes +abstract graffiti +Abstract oil painting +Abstract patterns +Abstract reflections +A bubble +A building +A bulb +A burst of rays +A button +A cable +A cactus +A calligraphy +A camera +A candle +A canopy +A capacitor +A card +A caricature +A cascade +A cascading waterfall +A cat +A caterpillar +A cathedral +A cellular pattern +A chair +A charcoal gray color +A cheap object +A checkerboard pattern +A checker pattern +A circle +A circuit +A circuit board +A circuitry +A clip +A clock +A close up of food +A close-up shot +A cloud +A clover +A cloverleaf +A coat +A cobweb +A coil +A compass +A concentric circle +A cone +A constellation +A cookie +A coral +A cracked surface texture +A crescent +A crescent moon +A cross +A crown +Action shot +A cube +A cup +A curvilinear shape +A cushion +A cylinder +A decagon +A deck +A diamond +A digital glitch design +A dodecagon +A dog +A dome +A door +A dramatic image +A drawing +A dreamcatcher +A dress +A drone +A droplet +A droplet in motion +advanced artificial intelligence +advanced biotechnology +advanced drone technology +advanced renewable energy +advanced robotics +advanced robotic technology +advanced space exploration +advanced transportation +advanced transport system +Adventurous explorations +Advertisment +A earring +Aerial landscape photography +Aerial perspective +Aerial view +Aerial view of a bay +Aerial view of a bustling metropolis +Aerial view of a cityscape +Aerial view of a coastal area +Aerial view of a construction site +Aerial view of a coral reef +Aerial view of a countryside +Aerial view of a desert oasis +Aerial view of a farmland +Aerial view of a hamlet +Aerial view of a harbor +Aerial view of a inlet +Aerial view of a marketplace +Aerial view of a mountain range +Aerial view of an agricultural field +Aerial view of an archaeological site +Aerial view of a natural landscape +Aerial view of an industrial area +Aerial view of an island +Aerial view of an ocean coastline +Aerial view of an urban skyline +Aerial view of a paradise +Aerial view of a promenade +Aerial view of a river or stream +Aerial view of a serene countryside +Aerial view of a serene meadow +Aerial view of a snowy landscape +Aerial view of a teeming rainforest +Aerial view of a town +Aerial view of a village +Aerial view of a vineyard +Aerial view of natural wonder +Aesthetic pleasure +Aesthetic resonance +A face +A fake image +A family photo +A fan +A feather +A fern +Affectionate smiling facial expression +A filter +A fin +A flag +A floor +A floral motif +A flower +A folded paper shape +A fork +A fractal +A fractal snowflake +A fractured glass texture +A frame from a movie +A freeform organic shape +A fruit +A galaxy +A garden +A gazebo +A gear +A gem +A gemstone +A geometric tessellation +A geyser +A glacier +A glass texture +A globe +A glove +A gold color +A graffiti +A graffiti with a sentence +A grey color +Agricultural fields +A grid-like structure +A group photo +A hand +A handle +A hanger +A happy feeling +A hat +A heart shape +A helix +A helmet +A heptagon +A hexagon +A hexagram +A high-resolution image +A honeycomb pattern +A hoop +A horseshoe +A houndstooth texture +A jacket +A joystick +A kaleidoscopic pattern +A keyboard +A kite +A labyrinth +A ladder +A lake +A lamp +A lantern +A laptop +A lattice design +A leaf +A leg +A lens +A lever +A lighthouse +A lightning bolt shape +A lily +A low-resolution image +A magnet +A magnolia +A marbled texture +A marsh +A mask +A maze +A meadow +A meandering river +A megaphone +A meteor +A microphone +A mirror +A modular structure +A mosaic arrangement +A motor +A mountain +A mountain peak +A mural +Amused facial expression +An acute triangle +An advertisement +An aesthetic photo +An amber color +An animal +A napkin +An arch +Ancient and weathered artifact +Ancient and weathered stone carving +Ancient and weathered stone structure +Ancient castle walls +Ancient historical site +Ancient ruins +Ancient temple ruins +A necklace +A needle +An elegant photo +An elephant +An ellipse +An equilateral hexagon +An equilateral pentagon +An equilateral triangle +A net +A network of veins +An expensive object +An eye +Angry facial expression +An illustration of an animal +An image capturing an interaction between subjects +An image of a Accountant +An image of a Actor +An image of a Aerospace Engineer +An image of a Animal Trainer +An image of a Arborist +An image of a Archaeologist +An image of a Architect +An image of a Art Historian +An image of a Artist +An image of a Astronomer +An image of a Athlete +An image of a Attorney +An image of a Auto Mechanic +An image of a Ballet Dancer +An image of a Basketball Player +An image of a Biologist +An image of a body +An image of a Carpenter +An image of a Chef +An image of a Chef de Cuisine +An image of a Chiropractor +An image of a Civil Engineer +An image of a Composer +An image of a couple +An image of a Dentist +An image of a Dermatologist +An image of a desert +An image of a Detective +An image of a dish +An image of a Doctor +An image of a Economist +An image of a Electrician +An image of a Emergency Medical Technician (EMT) +An image of a Engineer +An image of a entree +An image of a face +An image of a family +An image of a Farmer +An image of a Fashion Designer +An image of a Film Director +An image of a Financial Analyst +An image of a Firefighter +An image of a Flight Attendant +An image of a Florist +An image of a Gardener +An image of a Graphic Designer +An image of a Gymnast +An image of a Hair Stylist +An image of a head +An image of a Illustrator +An image of a Investment Banker +An image of a IT Specialist +An image of a Journalist +An image of a Judge +An image of a king +An image of a lake +An image of a Landscaper +An image of a Lawyer +An image of a Librarian +An image of a main course +An image of a Marine Biologist +An image of a Mechanic +An image of a Mechanical Engineer +An image of a Musician +An image of a Music Producer +An image of Andorra +An image of a News Anchor +An image of an interior of a room +An image of a Novelist +An image of a Nurse +An image of a Orthopedic Surgeon +An image of a Painter +An image of a Paramedic +An image of a parent and child +An image of a Pediatrician +An image of a Pharmacist +An image of a Photographer +An image of a Pilot +An image of a Plumber +An image of a Podiatrist +An image of a Police Detective +An image of a Police Officer +An image of a Preschool Teacher +An image of a Private Investigator +An image of a Professor +An image of a Psychologist +An image of a queen +An image of a Radiologist +An image of a Scientist +An image of a Screenwriter +An image of a side dish +An image of a Social Worker +An image of a Software Developer +An image of a Surgeon +An image of a Swimmer +An image of a Systems Analyst +An image of a Teacher +An image of a Veterinarian +An image of a Veterinary Technician +An image of a Waiter/Waitress +An image of a Welder +An image of a Writer +An image of a Zoologist +An image of Barcelona +An image of cheeks +An image of Dublin +An image of ears +An image of Fiji +An image of fish +An image of friends hanging out +an image of glasgow +An image of hands +An image of Kenya +An image of legs +an image of liechtenstein +An image of Luxembourg +an image of monaco +an image of namibia +An image of one subject +an image of portsmouth +an image of samoa +An image of sports +An image of the ground +An image of the number 0 +An image of the number 1 +An image of the number 10 +An image of the number 2 +An image of the number 3 +An image of the number 4 +An image of the number 5 +An image of the number 6 +An image of the number 7 +An image of the number 8 +An image of the number 9 +An image of three subjects +An image of tools +An image of two subjects +An image with a airplane +An image with a moving object +An image with a static object +An image with a tractor +An image with bikes +An image with boats +An image with cats +An image with cold green tones +An image with dogs +An image with insects +An image with pedestrians +An image with poultry +An image with seagulls +An image with sheep +An image with sunglasses +An image with two moving objects +An image with two static objects +Animated background +Animated foreground +Animated photo +Animated scene +Anime style image +An inverted triangle +An irregular heptagon +An irregular hexagon +An irregular octagon +An irregular pentagon +An irregular polygon +An irregular shape +An islamic calligraphy +An isosceles triangle +An object centric photo +An oblong shape +An obtuse triangle +An octagon +A noisy photo +An old photo +A notebook +An oval +Antique architectural detail +Antique architectural element +Antique artistic creation +Antique craftsmanship +Antique decorative element +Antique furniture piece +Antique historical artifact +Antique religious icon +Antique sculptural element +Antique textures +Antique timepiece +An ugly photo +A nut +Anxious facial expression +A paddle +A painting +A palette +A palm +A parabola +A parallelogram +A party hat +A pasture +A paw +A pearl +A pebble +A pedal +A pen +A pendant +A pendulum +A pentagon +A pentagram +A phone +A photograph of a big object +A photograph of a medium-size object +A photograph of a small object +A photo of a bustling marketplace +A photo of a calm ocean +A photo of a city +A photo of a garden +A photo of a man +A photo of an adult +A photo of an old person +A photo of a quaint village +A photo of a serene forest +A photo of a serene mountain range +A photo of a teenager +A photo of a tranquil garden +A photo of a tranquil lake +A photo of a tranquil river +A photo of a vibrant carnival +A photo of a vibrant festival +A photo of a village +A photo of a woman +A photo of a young person +a photo of cardiff +A photo of Cardiff +A photo of food +A photo of Glasgow +A photo of Illinois +A photo of Manchester +A photo of Monaco +A photo of serene countryside +A photo taken at twilight +A photo taken in the fall +A photo taken in the spring +A photo taken in the summer +A photo taken in the winter +A photo with a texture of mammals +A photo with a wave pattern +A photo with high contrast +A photo with low contrast +A photo with motion blur +A photo with the letter A +A photo with the letter B +A photo with the letter C +A photo with the letter D +A photo with the letter E +A photo with the letter F +A photo with the letter G +A photo with the letter H +A photo with the letter I +A photo with the letter J +A photo with the letter K +A photo with the letter L +A photo with the letter M +A photo with the letter N +A photo with the letter O +A photo with the letter P +A photo with the letter Q +A photo with the letter R +A photo with the letter S +A photo with the letter T +A photo with the letter U +A photo with the letter V +A photo with the letter W +A photo with the letter X +A photo with the letter Y +A photo with the letter Z +A picture of a baby +A picture of a bridge +A picture of a middle-aged person +A picture of an elderly person +a picture of illinois +A picture of liechtenstein +A picture of Samoa +A picture of South Korea +a picture of taiwan +A picture of Taiwan +A picture of Wisconsin +A pillow +A pin +A pine tree +A pixelated pattern +A plank +A plant +A plate +A platinum silver color +A polka dot +A polygon +A polygon with many sides +A portrait +A prism +A propeller +A puck +A puddle +A puppet +A pyramid +A quadrilateral +A quasar +A quilt +A quilted texture +A quilt pattern +Arabic script calligraphy +A racetrack +A racket +A radial symmetry +A rail +A rainbow +Architectural arches +Architectural authenticity +Architectural compositions +Architectural contrast +Architectural contrasts +Architectural details +Architectural dialogues +Architectural elegance +Architectural expressions +Architectural ink sketch +Architectural intrigue +Architectural lines +Architectural marvel +Architectural marvels +Architectural reflections +Architectural revelations +Architectural rhythm +Architectural secrets +Architectural stories +Architectural symmetry +Architectural symmetry and precision +Architectural symphony +A real image +A rectangle +A reed +A regular octagon +A rhombus +A ribbon +A right trapezoid +A right triangle +A ring +A ripple effect +A river +Arms +A robot +A rock +A roof +A rope +Artificial lighting +Artistic abstractions +Artistic blur +Artistic interpretation +Artistic self-portrait +Artistic still life +Art Nouveau-inspired design +Artwork featuring 8-bit pixel art +Artwork featuring abstract fractal patterns +Artwork featuring abstract wave patterns +Artwork featuring barcode arrangement +Artwork featuring barcode-like lines +Artwork featuring barcodes +Artwork featuring circuit board motifs +Artwork featuring crossword grid pattern +Artwork featuring crossword-like motifs +Artwork featuring cubist elements +Artwork featuring digital glitch patterns +Artwork featuring Escher-like patterns +Artwork featuring geometric tessellation +Artwork featuring graffiti-like designs +Artwork featuring herringbone pattern +Artwork featuring labyrinthine design +Artwork featuring labyrinthine maze patterns +Artwork featuring Morse code typography +Artwork featuring overlapping scribbles +Artwork featuring retro TV test patterns +Artwork featuring shattered glass effect +Artwork featuring shattered glass patterns +Artwork featuring typographic patterns +Artwork featuring zebra stripe motifs +Artwork with abstract fractal patterns +Artwork with chaotic abstract patterns +Artwork with fractal recursion motifs +Artwork with glitch art aesthetics +Artwork with intricate filigree patterns +Artwork with kaleidoscopic patterns +Artwork with Mondrian-like grids +Artwork with mosaic arrangement +Artwork with mosaic tile arrangement +Artwork with optical illusion effects +Artwork with pixelated patterns +Artwork with pointillism technique +Artwork with retro pixel patterns +Artwork with retro video game graphics +Artwork with spiraling fractal motifs +Artwork with stained glass window design +Artwork with stippling technique +Artwork with woven basket design +A rug +A sad feeling +A sail +A satellite +A scalene quadrilateral +A scalene triangle +A scarf +A scorpion +A screen +A sculpture +A seagull +A seal +A seashell +A semi-circle +A semicircular arch +A sensor +A shadow +A shattered mirror effect +A shelf +A shell +A shell (of a snail or a nut) +A shield +A shirt +A shoe +A shoelace +A shuttle +A silhouette +A silver color +A skirt +A sky +A skyscraper +A smoky plume +A smooth texture +A snail +A snake +A snowflake +A sock +A socket +A sphere +A spiky texture +A spiral +A spire +A spirograph-like shape +A spoon +A spring +A square +A staircase +A star +A starburst +A statue +A stem +A stick +A stone +Astonished facial expression +A stretcher +A string +A suit +A sunburst design +A sunrise +A sunset +A swarm +A swirling eddy +A swirling vortex +A swirl of smoke +A switch +Asymmetrical arrangement +A table +A tablet +A tail +A tailfin +A tea +A teardrop shape +A telescope +A thimble +A thistle +A thread +A tie +A tire +atmospheric cityscape +atmospheric day scene +Atmospheric haze +Atmospheric mood +atmospheric night scene +atmospheric night setting +atmospheric twilight ambiance +atmospheric twilight setting +atmospheric urban backdrop +A tornado +A traffic cone +A trampoline +A trapezoid +A tree +A triangle +A trunk +A trunk (of a tree or an elephant) +A tulip +A tunnel +A turban +A umbrella +A valve +A vase +A vegetable +A vine +A violin +A volcano +A wallet +A watch +A waterfall +A wavy pattern +A web-like structure +awe-inspiring ancient structure +awe-inspiring architectural detail +awe-inspiring mountain landscape +awe-inspiring mountain peak +awe-inspiring natural formation +awe-inspiring natural wonder +awe-inspiring sky +A whirligig +A whirlpool +A whirlwind +A whisk +A whisker +A window +A wing +A wire +A wizard's hat +A wolf +A woven fabric pattern +A zebra stripe pattern +A zephyr +A zigzag pattern +A zoomed in photo +A zoomed out photo +Balanced asymmetry +Balanced composition +Bewildered facial expression +Birds-eye view +Black and white candid street photography +Black and white vintage photo +Blissful facial expression +Blossoming springtime blooms +Blurred abstraction +Blurred boundaries +Bokeh effect +Bokeh lights +Bold composition +Bold geometric shapes +Bold graffiti +Bold graffiti art +Bold text +Bold words +Bored facial expression +Breathtaking aurora borealis +Breathtaking canyons +Breathtaking vista +Breathtaking vistas +Bursting fireworks display +Burst of color +Burst of colorful confetti +Burst of motion +Bustling and colorful food market +Bustling city from above +Bustling city intersection +Bustling city nightlife +Bustling cityscape at night +Bustling city square +Bustling city traffic +Bustling city waterfront +bustling cultural market +Busy airport terminal +Busy and cluttered scene +Busy market square +Busy train station +Buzzing market square +Calm contemplation +calming forest scene +calming garden retreat +calming riverbank scene +calming seascape +Candid city commuter +Candid documentary photography +Candid expression +Candid expressions +Candid interactions +Candid moment +Candid portrait photography +Candid street moments +Candid street photography +Candid wildlife moment +Candid wildlife shot +Captivating authenticity +Captivating city life +Captivating city pulse +Captivating cityscape +Captivating cityscapes +Captivating connections +Captivating curves +Captivating details +Captivating encounters +Captivating focus +Captivating macro floral detail +Captivating moments +Captivating motion +Captivating negative space +Captivating patterns +Captivating reflections +Captivating scenes +Captivating silhouettes +captivating starry night +Captivating street life +Captivating textures +Captivating twilight +Captivating wildlife interactions +Caricature of a cartoon character +Caricature of a celebrated composer +Caricature of a celebrity +Caricature of a famous activist +Caricature of a famous artist +Caricature of a famous movie character +Caricature of a famous philosopher +Caricature of a famous revolutionary +Caricature of a fictional character +Caricature of a fictional creature +Caricature of a historical figure +Caricature of a king +Caricature of a literary character +Caricature of a mythological figure +Caricature of an iconic actor +Caricature of an iconic artist +Caricature of an iconic composer +Caricature of an iconic explorer +Caricature of an iconic historical figure +Caricature of an iconic inventor +Caricature of an iconic musician +Caricature of an iconic philosopher +Caricature of an iconic playwright +Caricature of an iconic poet +Caricature of an iconic scientist +Caricature of an iconic writer +Caricature of an influential leader +Caricature of an influential philosopher +Caricature of a person +Caricature of a political leader +Caricature of a queen +Caricature of a renowned scientist +Caricature of a sports figure +Cartoon style image +Cascading waterfall +Cautious facial expression +Celebratory atmosphere +Central focal point +Charming rural scene +Checkered design +Cheerful adolescents +Cinematic framing +Cinematic portrait with dramatic lighting +Circular object +City lights reflected +Cityscape under the stars +classic artistic masterpiece +Classic black and white cityscape +classic fine art piece +Clear sky +Close-up of a food item +Close-up of a textured animal fur +Close-up of a textured bark +Close-up of a textured ceramic +Close-up of a textured concrete surface +Close-up of a textured fabric +Close-up of a textured feather +Close-up of a textured fur +Close-up of a textured insect +Close-up of a textured leather +Close-up of a textured material +Close-up of a textured mesh +Close-up of a textured metal +Close-up of a textured metal surface +Close-up of a textured paper surface +Close-up of a textured plant leaf +Close-up of a textured plastic +Close-up of a textured plastic material +Close-up of a textured reptile skin +Close-up of a textured rock +Close-up of a textured rubber +Close-up of a textured seashell +Close-up of a textured seashore +Close-up of a textured silk +Close-up of a textured stone surface +Close-up of a textured surface +Close-up of a textured synthetic ceramic +Close-up of a textured synthetic fabric +Close-up of a textured synthetic fur +Close-up of a textured synthetic leather +Close-up of a textured synthetic material +Close-up of a textured synthetic mesh +Close-up of a textured synthetic metal +Close-up of a textured synthetic plastic +Close-up of a textured synthetic rubber +Close-up of a textured synthetic silk +Close-up of a textured synthetic wood +Close-up of a textured wood +Close-up of a textured wood grain +Close-up of textures +Close-up view +clouds +Cloudy sky +coastal landscape +Coastal lighthouse beacon +coastal view +Collage of textures +Collage of vintage magazine clippings +colorful celebration +colorful ceremony +colorful display +Colorful diversity +colorful event +colorful exhibition +Colorful expressions +colorful festival +colorful graffiti art +Colorful hot air balloons +Colorful image +colorful performance +colorful procession +colorful representation +colorful spectacle +colorful underwater world +Colorful urban art +competitive sports moment +Conceptual abstraction +Conceptual exploration +Conceptual representation +Concerned facial expression +Confused facial expression +Connection with nature +contemplative cityscape +contemplative coastal scene +contemplative coastal view +contemplative countryside scene +contemplative introspection +contemplative landscape +contemplative moment +Contemplative monochrome portrait +contemplative mountain view +contemplative ocean view +contemplative rural scene +Contemplative solitude +Contemplative stillness +contemplative urban scene +contemplative urban view +Contemporary abstract painting +Content facial expression +Contrasting elements +Contrasting textures +Controlled chaos +Cosmic landscapes +countryside view +Cozy and intimate atmosphere +cozy bedroom atmosphere +cozy cabin interior +cozy café ambiance +cozy café environment +cozy coffee shop +cozy countryside cottage +cozy fireplace setting +cozy home interior +cozy home library +Cozy interiors +cozy interior space +Cozy living room ambiance +cozy living space +cozy outdoor picnic +cozy outdoor seating +cozy outdoor setting +cozy reading nook +Crashing ocean waves +Creative imagination +Crisp autumn leaves +Crowded and bustling scene +Crowded event +Crumbling ancient ruins +Crumbling and abandoned building +Cubist composition +Cubist still life painting +cultural celebration +Cultural celebrations +cultural ceremony +Cultural dialogues +cultural display +Cultural diversity +cultural event +cultural exhibition +Cultural expressions +cultural festival +Cultural interactions +Cultural juxtapositions +Cultural mosaic +cultural performance +cultural procession +Cultural reflections +cultural representation +Cultural representation +Cultural richness +cultural spectacle +Cultural stories +Cultural tapestry +Cultural traditions +Cultural treasures +Curious wildlife +cutting-edge robotic innovation +cutting-edge technology +Cynical facial expression +Dappled sunlight +Daytime illumination +Daytime scene +Daytime shot +Delicate and intricate floral patterns +Delicate and intricate lace patterns +delicate ceramic patterns +Delicate embroidery +Delicate flower petals +delicate lacework +delicate pottery design +delicate soap bubble +delicate soap bubble creation +delicate soap bubble display +delicate soap bubble pattern +delicate soap bubble play +delicate textile patterns +Depth of field +Deserted coastal pier +desert landscape +Desert oasis palm trees +Desert rock formations +Desert sand dunes +Desert sandstorm +desert vista +Despondent facial expression +detailed amphibian close-up +detailed animal close-up +detailed arachnid close-up +detailed architectural carving +detailed architectural design +detailed botanical macro +Detailed charcoal sketch +Detailed illustration +Detailed illustration of a body of water +Detailed illustration of a building +Detailed illustration of a celestial body +Detailed illustration of a futuristic AI-human connection +Detailed illustration of a futuristic AI-human integration +Detailed illustration of a futuristic AI-human interaction +Detailed illustration of a futuristic AI-human interface +Detailed illustration of a futuristic biome +Detailed illustration of a futuristic bioreactor +Detailed illustration of a futuristic biotechnology +Detailed illustration of a futuristic brain-computer interface +Detailed illustration of a futuristic city +Detailed illustration of a futuristic computer +Detailed illustration of a futuristic energy generator +Detailed illustration of a futuristic energy source +Detailed illustration of a futuristic medical breakthrough +Detailed illustration of a futuristic medical technology +Detailed illustration of a futuristic nanotechnology +Detailed illustration of a futuristic quantum realm +Detailed illustration of a futuristic quantum technology +Detailed illustration of a futuristic robotics +Detailed illustration of a futuristic technology +Detailed illustration of a futuristic vehicle +Detailed illustration of a futuristic virtual reality +Detailed illustration of a futuristic virtual realm +Detailed illustration of a geological formation +Detailed illustration of a historical scene +Detailed illustration of a landscape +Detailed illustration of a machinery +Detailed illustration of an advanced AI +Detailed illustration of an advanced artificial intelligence +Detailed illustration of an advanced energy source +Detailed illustration of an advanced machinery +Detailed illustration of an advanced medical technology +Detailed illustration of an advanced robotics +Detailed illustration of an advanced space exploration +Detailed illustration of an alien world +Detailed illustration of a natural scene +Detailed illustration of an otherworldly landscape +Detailed illustration of a piece of clothing +Detailed illustration of a piece of jewelry +Detailed illustration of a prehistoric scene +Detailed illustration of a vehicle +detailed insect close-up +detailed insect macro +detailed macro shot +detailed mosaic design +detailed reptile close-up +Determined facial expression +Diagonal composition +Disappointed facial expression +Distant horizons +Distant viewpoint +Distorted perspective +Diverse flora +Double exposure effect +Dramatic chiaroscuro +Dramatic chiaroscuro photography +Dramatic cliffside view +Dramatic clouds +Dramatic contrast +Dramatic shadows +Dramatic silhouette +Dramatic skies +Dramatic sunset +Dramatic volcanic eruption +Dramatic weather +Dreamlike haze +Dreamy and surreal landscape +Dreamy haze +Dreamy misty morning +Dreamy or surreal appearance +Dynamic action +Dynamic action scenes +Dynamic and energetic dance performance +Dynamic and energetic dance routine +Dynamic and energetic festival celebration +Dynamic and exhilarating concert performance +Dynamic and high-energy concert +Dynamic and high-energy dance competition +Dynamic and high-energy dance performance +Dynamic and high-energy dance routine +Dynamic and high-energy live concert +Dynamic and high-energy music concert +Dynamic and high-energy music festival +Dynamic and high-energy music performance +Dynamic and high-energy stage performance +Dynamic and powerful dance performance +Dynamic architecture +Dynamic atmospheres +Dynamic balance +Dynamic burst of color +Dynamic city life +Dynamic cityscape +Dynamic cityscapes +Dynamic compositions +dynamic cultural festival +Dynamic cultures +Dynamic encounters +Dynamic energy +Dynamic evolution +Dynamic expressions +Dynamic fluidity +Dynamic forms +Dynamic horizons +Dynamic humanity +Dynamic impressions +Dynamic interactions +Dynamic interplay +Dynamic landscapes +Dynamic leading lines +Dynamic modern urban architecture +Dynamic moments +Dynamic motion blur +Dynamic movement +Dynamic patterns +Dynamic reflections +Dynamic scene +Dynamic shadows +Dynamic silhouettes +Dynamic sports action shot +Dynamic street life +Dynamic streetscapes +Dynamic symmetry +Dynamic tension +Dynamic textures +Dynamic urban geometry +Dynamic wildlife shot +Earthy color tones +Eccentric fashion shot +Eclectic street scenes +Elated facial expression +Elegant Victorian architecture +Elemental fusion +Emotional and genuine human connection +Emotional and heartfelt connection +Emotional and heartfelt embrace +Emotional and heartfelt familial bond +Emotional and heartfelt family interaction +Emotional and heartfelt friendship +Emotional and heartfelt human connection +Emotional and heartfelt human embrace +Emotional and heartfelt interaction +emotional candid embrace +emotional candid expression +emotional candid gaze +emotional candid interaction +emotional candid moment +emotional candid snapshot +Emotional connections +emotional dance movement +emotional dance performance +emotional dance pose +Emotional depth +Emotional echoes +Emotional expression +Emotional expressions +Emotional fragments +Emotional journey +Emotional nuances +emotional portrait +Emotional reflections +Emotional resonance +Emotional resonances +Emotional revelation +Emotional storytelling +Emotional whispers +Emotion-filled gaze +Enchanted atmosphere +Enchanted twilight +Enchanting celestial display +Enchanting dreamlike setting +Enchanting fantasy realm +Enchanting fantasy world +Enchanting forest glade +enchanting forest glen +Enchanting forest nymph aesthetic +Enchanting forest scene +Enchanting forest setting +Enchanting magical-tale scene +Enchanting moonlit night +Enchanting mystical realm +Enchanting starry night +Enchanting starry night sky +Enchanting twilight sky +Endearing childhood +Endless horizons +enduring classic artwork +enduring cultural artifact +enduring historical artifact +enduring historical monument +enduring literary work +Energetic and lively dance performance +Energetic and passionate music performance +Energetic children +Energetic motion +Energetic motion blur +Energetic music festival crowd +Energetic street scene +Engaging curiosity +Engaging dialogue +Engaging interaction +Engaging perspective +Enigmatic allure +enigmatic ambiance +enigmatic atmosphere +Enigmatic atmosphere +Enigmatic city life +Enigmatic city lights +Enigmatic cityscapes +Enigmatic dialogues +Enigmatic encounters +Enigmatic figure +Enigmatic forms +Enigmatic horizons +Enigmatic mist-covered lake +Enigmatic pathways +Enigmatic perspectives +Enigmatic silhouettes +Enigmatic streets +Enigmatic tones +enigmatic urban ambiance +Enigmatic vistas +Enriching complexity +Enthusiastic facial expression +Enthusiastic youngsters +Ephemeral beauty +Ephemeral blossoms +Ephemeral encounters +Ephemeral glimmers +Ephemeral light +Ephemeral moment +Ephemeral movement +Ephemeral soap bubble +Ephemeral soap bubble art +Ephemeral soap bubble creation +Ephemeral soap bubble display +Ephemeral soap bubble pattern +Ephemeral soap bubble play +Ephemeral soap bubble play +Ethereal atmosphere +Ethereal beauty +Ethereal charm +Ethereal city life +Ethereal city lights +Ethereal city pulse +Ethereal cityscapes +Ethereal connection +Ethereal dawns +Ethereal double exposure photography +Ethereal glow +Ethereal horizons +Ethereal impressions +Ethereal landscapes +Ethereal light +Ethereal mist +Ethereal moments +Ethereal quality +Ethereal reflections +Ethereal tones +Ethereal vistas +Everyday moments +Evocative ambience +Evocative beauty +Evocative candid embrace +Evocative candid expression +Evocative candid gaze +Evocative candid interaction +Evocative candid moment +Evocative candid snapshot +Evocative city life +Evocative city lights +Evocative cityscapes +Evocative colors +Evocative dance movement +Evocative dance performance +Evocative dance pose +Evocative designs +Evocative details +Evocative dialogues +Evocative emotion +Evocative encounters +Evocative forms +Evocative fragments +Evocative horizons +Evocative humanity +Evocative immersion +Evocative interplay +Evocative light +Evocative light and shadow +Evocative mood +Evocative moods +Evocative patterns +Evocative perspectives +Evocative portrait +Evocative scenes +Evocative shadows +Evocative silhouettes +Evocative storytelling +Evocative streets +Evocative textures +Evolving change +Evolving colors +Excited facial expression +Excited youth +Exotic and bustling bazaar +Expressive articulation +Expressive emotions +Expressive gesture +Expressive movement +Exquisite fine art painting +Eyes +Facial close-up +Fading memories +Family bonds +fantastical imagination +fantastical scene +Fast-paced race car blur +Fast-paced urban nightlife +Film noir-inspired tones +fleeting soap bubble +fleeting soap bubble art +Flowers +Flowing lines +Flowing water bodies +Flustered facial expression +focused athlete +Focused facial expression +Focused subject +fog +forest view +Framed by nature +Frame within a frame +Framing element +Frozen in time +Frozen memories +Frozen wilderness +Futuristic aesthetics +Futuristic architectural design +Futuristic architecture +Futuristic artificial intelligence +Futuristic biotechnology +Futuristic cityscapes +Futuristic design concept +Futuristic digital artwork +Futuristic digital cityscape +Futuristic drone technology +Futuristic-edge robotic innovation +Futuristic-edge technology +Futuristic engineering design +Futuristic innovations +Futuristic robotics +Futuristic robotic technology +Futuristic scientific advancement +Futuristic scientific discovery +Futuristic skyline +Futuristic space exploration +Futuristic technological breakthrough +Futuristic technological concept +Futuristic technology +Futuristic technology display +Futuristic technology showcase +Futuristic transportation +Futuristic transport system +Geometric shapes +Geometric tessellation +Giddy facial expression +Glimmering lights +Glimpse of life +Glimpse of the past +Glistening dew-covered foliage +Glowing embers +Glowing neon cityscape +Golden hour glow +Golden hour lighting +Graceful ballet performance +Graceful swimming fish +Graceful wings in motion +Graffiti and street art +Grand and imposing structure +Grand and opulent palace +Grand architecture +Grand cathedral interior +Grayscale image +Grayscale urban cityscape +Gritty realism +Gritty urban landscapes +Gritty urban realism +Gritty urban street scene +Grumpy facial expression +Hands in an embrace +Harmonic arrangement +Harmonic progression +Harmonic symmetry +Harmonious coexistence +Harmonious color scheme +Harmonious synthesis +Hauntingly still +Heartfelt emotion +Heartwarming bonds +Herringbone pattern +Hidden identity +Hidden meaning +Hidden narratives +Hidden passage +High-contrast black and white +High contrast lighting +High dynamic range +High-key contrast +High-key lighting +High-rise city architecture +High saturation +Historical photograph +Historical significance +Historic cobblestone streets +Honeycomb design +Human connection +Human diversity +Hypnotic spiral patterns +Iconic landmarks +Ikat design +Illuminated cityscape +Illustration of a dreamlike realm +Illustration of a futuristic city +Illustration of a futuristic transportation system +Illustration of a hidden ancient city +Illustration of a hidden ancient realm +Illustration of a hidden ancient ruin +Illustration of a hidden ancient script +Illustration of a hidden celestial portal +Illustration of a hidden celestial realm +Illustration of a hidden enchanted castle +Illustration of a hidden ethereal dimension +Illustration of a hidden ethereal palace +Illustration of a hidden ethereal portal +Illustration of a hidden fantasy castle +Illustration of a hidden fantasy oasis +Illustration of a hidden fantasy realm +Illustration of a hidden fantasy sanctuary +Illustration of a hidden fantasy world +Illustration of a hidden lost city +Illustration of a hidden mystical scene +Illustration of a historical event +Illustration of a mystical forest +Illustration of a mythical creature +Illustration of an alien landscape +Illustration of an alternate dimension +Illustration of an ancient civilization +Illustration of an ancient myth +Illustration of an astronomical phenomenon +Illustration of a natural disaster +Illustration of an enchanted forest +Illustration of an ethereal dreamscape +Illustration of an intergalactic voyage +Illustration of a parallel universe +Illustration of a scientific concept +Illustration of a technological advancement +Illustration of a underwater scene +Illustration of a utopian society +Illustration with English letters +Illustration with Roman numerals +Image captured in a forest +Image captured in a rainforest +Image captured in the Arabian desert +Image captured in the Arabian dunes +Image captured in the Australian bushlands +Image captured in the Australian Outback +Image captured in the Brazilian carnival +Image captured in the Californian coastline +Image captured in the Egyptian hieroglyphs +Image captured in the Egyptian pyramids +Image captured in the Greek islands +Image captured in the Hawaiian beaches +Image captured in the Icelandic glaciers +Image captured in the Japanese cherry blossoms +Image captured in the Japanese tea gardens +Image captured in the Japanese temples +Image captured in the Patagonian wilderness +Image captured in the Peruvian Andes +Image captured in the Swiss countryside +Image of a bicycle +Image of a boat +Image of a bus +Image of a car +Image of a construction vehicle +Image of a delivery van +Image of a garbage truck +Image of a helicopter +Image of a horse-drawn carriage +Image of a hot air balloon +Image of a motorcycle +Image of an airplane +Image of an ambulance +Image of a police car +Image of a policeman +Image of a rocket +Image of a scooter +image of a sheep +image of a ship +Image of a skateboard +Image of a submarine +Image of a tractor +Image of a train +Image of a truck +Image of street markets +Image shot in the Indonesian rainforest +Image showing prairie grouse +Image snapped in Spain +Image snapped in the Alaskan wilderness +Image snapped in the Australian coral reef +Image snapped in the Australian desert +Image snapped in the Australian Outback +Image snapped in the Australian rainforest +Image snapped in the Californian vineyards +Image snapped in the Canadian lakes +Image snapped in the Canadian tundra +Image snapped in the Colorado Rockies +Image snapped in the French vineyards +Image snapped in the Italian vineyards +Image snapped in the Japanese tea gardens +Image snapped in the Maldivian paradise +Image snapped in the Peruvian Andes +Image snapped in the Swiss Alps +Image snapped in the Swiss chocolate factories +Image snapped in the Thailand +Image taken from a distance +Image taken in Alps +Image taken in Andes Mountains +Image taken in Appalachian Mountains +Image taken in Arizona, USA +Image taken in Bora Bora +Image taken in Brazil +Image taken in California, USA +Image taken in Canada +Image taken in Caribbean +Image taken in Central or South America +Image taken in Chile +Image taken in French Polynesia +Image taken in Grand Canyon +Image taken in Great Wall of China +Image taken in Greece +Image taken in Machu Picchu +Image taken in Maldives +Image taken in Mexico +Image taken in Mongolia +Image taken in Morocco +Image taken in Namibia +Image taken in New England +Image taken in New Zealand +Image taken in Norway +Image taken in Pacific Islands +Image taken in Patagonia +Image taken in Peru +Image taken in Scottish Highlands +Image taken in South Africa +Image taken in South Korea +Image taken in Swiss Alps +Image taken in Thailand +Image taken in the Alaskan mountains +Image taken in the Alaskan wilderness +Image taken in the Andes Mountains +Image taken in the Australian coral reef +Image taken in the Brazilian carnival +Image taken in the Californian coastline +Image taken in the Californian redwoods +Image taken in the Canadian lakes +Image taken in the Egyptian pyramids +Image taken in the Florida Everglades +Image taken in the Indian spice markets +Image taken in the Namibian desert +Image taken in the Norwegian fjords +Image taken in the Spanish tapas bars +Image taken in the Thai beaches +Image taken in the Thai street markets +Image taken in the Thai temples +Image with a bee +Image with a black color +Image with a blue color +Image with Aboriginal dot painting style +Image with a broken mirror reflection +Image with a brown color +Image with a bunch of subjects +Image with a butterfly +Image with a caterpillar +Image with a cattle +Image with a cloudy sky +Image with a cluster of subjects +Image with a complementary color scheme +Image with a contrasting color combination +Image with a cool color palette +Image with a couple of subjects +Image with a crowd of subjects +Image with a cyclone +Image with a donkey +Image with a double exposure effect +Image with a dragonfly +Image with a dramatic thunderstorm +Image with a duo of partners +Image with a five people +Image with a foggy atmosphere +Image with a four people +Image with African tribal motifs +Image with a full moon in the frame +Image with a futuristic AI-controlled city +Image with a futuristic AI-human interface +Image with a futuristic AI-human symbiosis +Image with a futuristic augmented reality scene +Image with a futuristic bioengineered organism +Image with a futuristic biomechanical design +Image with a futuristic cityscape +Image with a futuristic industrial complex +Image with a futuristic interdimensi onal gateway +Image with a futuristic interdimensional portal +Image with a futuristic interstellar voyage +Image with a futuristic laboratory +Image with a futuristic metropolis +Image with a futuristic nanobot swarm +Image with a futuristic nanotechnology experiment +Image with a futuristic nanotechnology laboratory +Image with a futuristic neural interface +Image with a futuristic neural network +Image with a futuristic skyscraper +Image with a futuristic space colony +Image with a futuristic space habitat +Image with a futuristic spaceport +Image with a futuristic space station +Image with a futuristic space-time rift +Image with a futuristic terraforming experiment +Image with a futuristic terraforming process +Image with a futuristic terraforming project +Image with a futuristic time dilation effect +Image with a futuristic time distortion effect +Image with a futuristic time manipulation device +Image with a futuristic time manipulation experiment +Image with a futuristic time travel device +Image with a futuristic transportation hub +Image with a futuristic underwater habitat +Image with a futuristic wormhole +Image with a gradient of colors +Image with a gray color +Image with a green color +Image with a group of friends +Image with a group of people +Image with a group of subjects +Image with a handful of subjects +Image with a handwritten letter +Image with a harmonious color combination +Image with a hawk +Image with a high-contrast color palette +Image with a hurricane or typhoon +Image with a labyrinth or maze +Image with a ladybug +Image with a lightning storm +Image with a long road or path +Image with a lunar eclipse +Image with a maze-like structure +Image with a monochromatic color scheme +Image with a muted color palette +Image with an ant +Image with ancient hieroglyphic motifs +Image with an optical illusion +Image with an owl +Image with a orange color +Image with a pair of subjects +Image with a pastel color +Image with a penguin +Image with a pink color +Image with a printed advertisement +Image with a purple color +Image with a rainbow in the sky +Image with a range of subjects +Image with a red color +Image with a reflection in a mirror +Image with a reflection in water +Image with argyle patterns +Image with a sand dune landscape +Image with a sandstone formation +Image with a sandstorm +Image with a seagull +Image with a seamless white background +Image with a selection of subjects +Image with a set of subjects +Image with a seven people +Image with a shattered glass effect +Image with a shattered mosaic pattern +Image with a shattered or broken object +Image with a shattered reflection in water +Image with a sheep +Image with a silhouette +Image with a single dominant color +Image with a single road sign +Image with a single subject +Image with a single tree +Image with a six people +Image with a snowstorm +Image with a snowy mountain peak +Image with a spider +Image with a spiraling pattern +Image with a spiral staircase +Image with a starry night sky +Image with a sunset in the background +Image with asymmetrical composition +Image with a team of players +Image with a team of subjects +Image with a tornado +Image with a tornado forming in the distance +Image with a trio of friends +Image with a trio of subjects +Image with a variety of colors +Image with a vibrant color +Image with a volcanic eruption +Image with a volcanic lava flow +Image with a vortex of water +Image with a warm color palette +Image with a whirlpool in the ocean +Image with a whirlpool in the sky +Image with a whirlpool of brimstone +Image with a whirlpool of fire +Image with a whirlpool or vortex +Image with a white color +Image with a winding path or trail +Image with a yellow color +Image with a zebra +Image with Aztec-inspired patterns +Image with calligraphy writing +Image with camouflage pattern +Image with camouflage print +Image with Celtic knotwork patterns +Image with Celtic spiral designs +Image with chevron patterns +Image with circuit board arrangements +Image with circuitry patterns +Image with cloud-like patterns +Image with colors +Image with constellations +Image with cosmic energy +Image with cosmic energy and colors +Image with cosmic energy and light +Image with cosmic energy and space +Image with cracked earth textures +Image with damask patterns +Image with double exposure effect +Image with elaborate filigree +Image with elemental forces +Image with elemental magic +Image with elemental magic and air +Image with elemental magic and fire +Image with elemental magic and water +Image with fire +Image with five subjects +Image with floral patterns +Image with gingham patterns +Image with graffiti art +Image with graffiti-inspired design +Image with Greek key patterns +Image with handwritten text in it +Image with harlequin patterns +Image with holographic city lights +Image with holographic cityscapes +Image with holographic cyber aesthetics +Image with holographic cyberpunk aesthetics +Image with holographic cyberspace +Image with holographic digital art +Image with holographic digital rain +Image with holographic elements +Image with holographic holograms +Image with holographic holography +Image with holographic illusions +Image with holographic landscapes +Image with holographic neon lights +Image with holographic patterns +Image with holographic projections +Image with holographic reflections +Image with holographic retro aesthetics +Image with holographic retro arcade aesthetics +Image with holographic retro-futurism +Image with holographic retro gaming aesthetics +Image with holographic retro synthwave aesthetics +Image with holographic retro vaporwave aesthetics +Image with holographic text +Image with holographic urban environments +Image with holographic virtual reality +Image with honeycomb patterns +Image with horizontal lines +Image with horizontal symmetry +Image with houndstooth patterns +Image with indigenous tribal motifs +Image with interlocking hexagon patterns +Image with intricate Islamic patterns +Image with intricate mandala patterns +Image with intricate mehndi designs +Image with leaves +Image with leopard print patterns +Image with light +Image with lightning in the background +Image with many subjects +Image with marbled paper texture +Image with marbleized effects +Image with Mayan-inspired designs +Image with Morse code arrangement +Image with Morse code motifs +Image with multiple subjects +Image with Native American motifs +Image with neon lights +Image with numbers in it +Image with numerous subjects +Image with octagon tessellation +Image with opulent rococo design +Image with ornate arabesque patterns +Image with ornate Victorian motifs +Image with overlapping geometric shapes +Image with paisley designs +Image with paisley patterns +Image with petals +Image with pointillism technique +Image with polka dot patterns +Image with quilted fabric patterns +Image with quilted patchwork design +Image with recurrent patterns +Image with sand +Image with sand and dust +Image with scribble-like designs +Image with several subjects +Image with shattered crystal sculptures +Image with shattered crystal shards +Image with shattered crystal structures +Image with shattered glass art installation +Image with shattered glass fragments +Image with shattered glass mosaic +Image with shattered glass patterns +Image with shattered glass reflections +Image with shattered glass sculptures +Image with shattered glass shards +Image with shattered glass skyscrapers +Image with shattered ice or frost +Image with shattered mirror effect +Image with shattered mosaic tiles +Image with shattered porcelain patterns +Image with shattered pottery fragments +Image with shattered stained glass +Image with shattered stained glass fragments +Image with shattered stained glass windows +Image with six subjects +Image with smoke +Image with spiral patterns +Image with stardust +Image with stardust +Image with stardust and galaxies +Image with symmetrical composition +Image with tartan patterns +Image with texture of fabric +Image with the artistic style of impressionists +Image with three people +Image with tie-dye patterns +Image with traditional African motifs +Image with tribal patterns +Image with tribal tattoo-like designs +Image with two subjects +Image with vertical lines +Image with vertical symmetry +Image with vintage typography +Image with water and mist +Image with woven basket textures +Image with woven fabric design +Image with zigzag patterns +imaginative childhood fantasy +imaginative dreamlike atmosphere +imaginative dream world +imaginative fantasy scene +imaginative storybook scene +Impatient facial expression +imposing mountain range +Impressionist landscape painting +Impressionist portrait painting +Impressionist style +Impressionist-style digital artwork +Impressionist-style digital painting +Indifferent facial expression +Indoor environment +Indoor setting +Industrial backdrop +Industrial construction site +Industrial environment +Industrial factory machinery +Industrial landscapes +Industrial warehouse setting +Innocent laughter +innovative architectural design +innovative design concept +innovative engineering design +innovative robotic technology +innovative scientific advancement +innovative scientific discovery +innovative technological breakthrough +innovative technological concept +innovative technology showcase +Inquisitive facial expression +Intense athlete +Intense athletic competition +Intense competitive sport +Intense determination +Intense extreme sports moment +Intense facial expression +Intense macro detail +Intense motorsport action +Intense motorsport race +Intense racing event +Intense sporting challenge +Intense sports action +Intense sports challenge +Intense sports event +Intense sports moment +Intense water sports moment +Intentional lens flare +Interactive engagement +Interplay of elements +Intertwined destinies +Intertwined forms +Intertwined tree branches +Intimate and candid conversation +Intimate cafe corner +Intimate close-up +Intimate connection +Intimate connections +Intimate moment +Intimate portrait +Intrica cathedralte +Intricate architectural carving +Intricate architectural design +Intricate calligraphy +Intricate ceramic patterns +intricate clock mechanism +intricate clockwork gears +Intricate craftsmanship +intricate crystal arrangement +intricate crystal formation +Intricate detail +Intricate detailing +Intricate details +intricate fractal pattern +intricate gemstone arrangement +intricate gemstone cut +intricate gemstone display +intricate jewelry design +intricate kaleidoscope design +intricate kaleidoscope pattern +Intricate lacework +intricate mandala artwork +intricate mechanical components +intricate mechanical gears +intricate mechanical parts +intricate mosaic artwork +intricate mosaic design +Intricate mosaic design +Intricate pencil drawing +intricate pocket watch +Intricate pottery design +Intricate stained glass design +Intricate textile patterns +Intricate textile patterns +intricate timekeeping mechanism +intricate watch gears +intricate watch mechanism +Intrica wood carvingte +Intrigued facial expression +Intriguing and enigmatic forest scene +Intriguing and enigmatic passageway +Intriguing and mysterious alley scene +Intriguing and mysterious alleyway +Intriguing and mysterious forest pathway +Intriguing and mysterious forest setting +Intriguing and mysterious forest trail +Intriguing and mysterious forest view +Intriguing and mysterious passage +Intriguing and mysterious pathway +intriguing atmosphere +Intriguing perspective +Intuitive connection +Inviting bedroom atmosphere +Inviting cabin interior +Inviting café ambiance +Inviting café environment +Inviting coffee shop +Inviting countryside cottage +Inviting exploration +Inviting fireplace setting +inviting home interior +Inviting home interior +Inviting home library +Inviting interior space +Inviting living space +Inviting openness +Inviting outdoor picnic +Inviting outdoor seating +Inviting outdoor setting +Inviting reading nook +Irritated facial expression +Isolated mountain retreat +Isolated subject +italic text +italic words +Joyful celebration +Joyful facial expression +Joyful family picnic scene +Joyful toddlers +Jubilant facial expression +Kinetic and lively dance performance +Kinetic energy +Landscape view +Leading lines +Lively amusement park scene +Lively and colorful parade +Lively and dynamic music performance +Lively and energetic festival celebration +Lively carnival atmosphere +Lively carnival scene +Lively city parade +Lively city pulse +Lively coastal fishing port +Lively fairground scene +Lively market scene +Lively parade +Lively urban culture +Lone subject in vastness +Long exposure +long text with a lot of words +Loose brushwork +Low-angle perspective +Low contrast +Low-key lighting +Low-light conditions +Luminous city nights +Lush rainforest canopy +Lush tropical vegetation +Macro botanical photography +Macro details +Macro focus +Macro shot +magical celestial display +magical dreamlike setting +magical fairy-tale scene +magical fantasy realm +magical fantasy world +magical forest glade +magical forest scene +magical forest setting +magical moonlit night +magical mystical realm +magical twilight sky +Majestic ancient structure +Majestic animal +Majestic architectural detail +Majestic architecture +Majestic canyon vista +Majestic galloping horses +Majestic mountain +Majestic mountain landscape +Majestic mountains +Majestic mountain vista +Majestic natural formation +Majestic skyscrapers +Majestic soaring birds +Manmade object +Man-made pattern +Marbleized design +Melancholic beauty +Mesmerizing desert landscape +mesmerizing fractal design +Mesmerizing kinetic sculpture +mesmerizing mosaic design +Meticulously arranged flowerbed +meticulous medical procedure +meticulous surgical procedure +Miniature diorama photography +Minimal color palette +Minimalist architectural photography +Minimalist composition +Minimalist design +Minimalist lines +Minimalist urban geometry +Minimalist white backdrop +mist +Misty forest glade +misty forest path +Modern airport terminal +Modern office workspace +Modern skyscraper facade +Monochromatic color scheme +Monochromatic tones +Moody lighting +moody urban setting +Motion blur +Motion freeze +mountain landscape +Mountainous terrain +Mountain peak sunrise +mountain range +mountain vista +Mouth +Multilayered depth +Multilayered narrative +Multiple subjects in the image +Muted color palette +Muted elegance +Muted reflections +Muted tones +Muted urban tones +Mysterious ambiance +Mysterious atmosphere +Mysterious cityscape +Mysterious day scene +Mysterious forest glen +Mysterious forest path +Mysterious forests +Mysterious misty forest +Mysterious night scene +Mysterious night setting +Mysterious pathways +Mysterious twilight ambiance +Mysterious twilight setting +Mysterious urban ambiance +Mysterious urban backdrop +Mysterious urban setting +Mystical fog +Mystical moonlit scenes +Natural beauty +Natural harmony +Natural integration +Natural interplay +Natural landscape +Natural landscapes +Natural lighting +Natural pattern +Natural symmetry +Natural wonders +Nature macro photography +Nature's embrace +Nature's palette +Nature's textures +Negative space +Nighttime illumination +Nighttime scene +Nighttime shot +Nonchalant facial expression +Nonplussed facial expression +Nose +Nostalgic alleyways +Nostalgic atmospheres +Nostalgic authenticity +Nostalgic charm +Nostalgic city lights +Nostalgic city pulse +Nostalgic city scenes +Nostalgic encounters +Nostalgic expressions +Nostalgic fragments +Nostalgic gazes +Nostalgic glances +Nostalgic horizons +Nostalgic landscapes +Nostalgic moments +Nostalgic mood +Nostalgic narratives +Nostalgic nuances +Nostalgic pathways +Nostalgic perspectives +Nostalgic reflections +Nostalgic scenes +Nostalgic spectres +Nostalgic streets +Nostalgic streetscapes +Nostalgic textures +Nostalgic tones +Nostalgic traditions +Nostalgic vibe +Nostalgic vignette +Nostalgic visions +Objects with high proximity +Ocean +ocean horizon +Oceanic coral reef +Ocean sunset silhouette +Old-world charm +Open ocean expanse +open plains +Optical illusion artwork +Optical illusion design +orderly mathematical formula +Organic shapes +Organized chaos +ornate architectural detail +ornate architectural element +ornate cathedral +ornate craftsmanship +ornate decorative element +ornate furniture piece +ornate historical artifact +ornate timepiece +ornate wood carving +Outdoor environment +Overlapping elements +Overwhelmed facial expression +Panoramic view +Patchwork design +Patchwork quilt design +peaceful countryside view +peaceful forest clearing +peaceful garden hideaway +peaceful garden pond +peaceful lake scene +peaceful lakeside retreat +peaceful lakeside scene +peaceful meadow landscape +peaceful meditation +peaceful park setting +Peaceful rural farmland +Peaceful village alleyway +peaceful waterfront scene +Pensive facial expression +Pensive mood +Persian rug design +Photo captured in the Alaskan mountains +Photo captured in the Arizona desert +Photo captured in the Peruvian rainforest +Photo captured in the Swiss Alps +Photo featuring a bustling airport +Photo featuring a bustling city street +Photo featuring a bustling food market +Photo featuring a bustling market +Photo featuring a bustling street market +Photo featuring a busy transportation hub +Photo featuring a historic monument +Photo featuring a lively beach party +Photo featuring a lively carnival +Photo featuring a lively city parade +Photo featuring a lively festival +Photo featuring a lively sports match +Photo featuring a lively street festival +Photo featuring a market scene +Photo featuring a modern architecture +Photo featuring a serene countryside +Photo featuring a vibrant city nightlife +Photo featuring a vibrant cultural carnival +Photo featuring a vibrant cultural celebration +Photo featuring a vibrant cultural exhibition +Photo featuring a vibrant cultural fair +Photo featuring a vibrant cultural festival +Photo featuring a vibrant cultural parade +Photo featuring a vibrant cultural performance +Photo featuring a vibrant cultural procession +Photo featuring a vibrant cultural ritual +Photo featuring a vibrant cultural showcase +Photo featuring a vibrant cultural street fair +Photo featuring a vibrant masquerade ball +Photo featuring a vibrant music concert +Photo featuring a vibrant street graffiti +Photo featuring a vibrant street performance +Photo featuring a vibrant urban graffiti +Photograph capturing friendship +Photograph capturing relaxation +Photograph conveying anger +Photograph conveying confusion +Photograph depicting anticipation +Photograph depicting contemplation +Photograph displaying courage +Photograph displaying curiosity +Photograph evoking nostalgia +Photograph evoking wonder +Photograph expressing love +Photograph of a mammal +Photograph of a rodent +Photograph portraying excitement +Photograph revealing determination +Photograph revealing frustration +Photograph revealing pride +Photograph showcasing innocence +Photograph showcasing laughter +Photograph showcasing sadness +Photograph showcasing smiles +Photograph showcasing surprise +Photograph showcasing vulnerability +Photograph taken during autumn season +Photograph taken during spring season +Photograph taken during winter season +Photograph taken in a antique shop +Photograph taken in a arcade +Photograph taken in a bakery +Photograph taken in a barber shop +Photograph taken in a bookstore +Photograph taken in a cafe +Photograph taken in a candlelit setting +Photograph taken in a car +Photograph taken in a charming cottage +Photograph taken in a cinema +Photograph taken in a city alleyway +Photograph taken in a cozy cabin +Photograph taken in a cozy cafe +Photograph taken in a cozy interior +Photograph taken in a dimly lit room +Photograph taken in a fashion boutique +Photograph taken in a foggy atmosphere +Photograph taken in a gloomy weather +Photograph taken in a jazz club +Photograph taken in a misty environment +Photograph taken in a music store +Photograph taken in a rainy weather +Photograph taken in a record shop +Photograph taken in a record store +Photograph taken in a retro arcade +Photograph taken in a retro diner +Photograph taken in a rustic barn +Photograph taken in a soda shop +Photograph taken in a stormy weather +Photograph taken in a sunny weather +Photograph taken in a toy store +Photograph taken in a train station +Photograph taken indoors with low light +Photograph with a blue color palette +Photograph with a brown color palette +Photograph with abstract geometric overlay +Photograph with a green color palette +Photograph with a high contrast +Photograph with a purple color palette +Photograph with a red color palette +Photograph with a yellow color palette +Photograph with glitch art aesthetic +Photograph with the artistic style of abstract expressionism +Photograph with the artistic style of chiaroscuro +Photograph with the artistic style of collage +Photograph with the artistic style of color splatter +Photograph with the artistic style of cubism +Photograph with the artistic style of digital collage +Photograph with the artistic style of digital manipulation +Photograph with the artistic style of digital painting +Photograph with the artistic style of double exposure +Photograph with the artistic style of fisheye lens +Photograph with the artistic style of freeze-frame +Photograph with the artistic style of ink wash painting +Photograph with the artistic style of kaleidoscope +Photograph with the artistic style of lens flare +Photograph with the artistic style of light leaks +Photograph with the artistic style of light painting +Photograph with the artistic style of light trails +Photograph with the artistic style of long exposure +Photograph with the artistic style of minimalism +Photograph with the artistic style of mixed media +Photograph with the artistic style of motion blur +Photograph with the artistic style of motion graphics +Photograph with the artistic style of neon glow +Photograph with the artistic style of photomontage +Photograph with the artistic style of photorealism +Photograph with the artistic style of pointillism +Photograph with the artistic style of pop art +Photograph with the artistic style of realism +Photograph with the artistic style of slow shutter +Photograph with the artistic style of split toning +Photograph with the artistic style of stop motion +Photograph with the artistic style of surrealism +Photograph with the artistic style of tilt-shift +Photograph with the artistic style of time lapse +Photo of a fireworks display +Photo of a furry animal +Photo of a person +Photo of a reptile +Photo of dynamic streets +Photo taken at noon +Photo taken from above +Photo taken in Alaska +Photo taken in Amazon Rainforest +Photo taken in a museum +Photo taken in Australia +Photo taken in Bangkok, Thailand +Photo taken in Barcelona, Spain +Photo taken in Beijing, China +Photo taken in Bora Bora +Photo taken in Bora Bora, French Polynesia +Photo taken in Borneo +Photo taken in Cairo, Egypt +Photo taken in Canada +Photo taken in Canadian Rockies +Photo taken in Cape Town, South Africa +Photo taken in Egypt +Photo taken in Galápagos Islands +Photo taken in Grand Canyon +Photo taken in Great Barrier Reef +Photo taken in Havana, Cuba +Photo taken in Kilimanjaro +Photo taken in Kyoto +Photo taken in Kyoto, Japan +Photo taken in Machu Picchu +Photo taken in Machu Picchu, Peru +Photo taken in Monument Valley +Photo taken in Namib Desert +Photo taken in Namibia +Photo taken in Nepal +Photo taken in New England +Photo taken in New York City, USA +Photo taken in New Zealand +Photo taken in Okavango Delta +Photo taken in Paris, France +Photo taken in Patagonia +Photo taken in Peru +Photo taken in Rio de Janeiro, Brazil +Photo taken in Rioja, Spain +Photo taken in Rocky Mountains +Photo taken in Rome, Italy +Photo taken in Sahara Desert +Photo taken in Santander, Spain +Photo taken in Santorini, Greece +Photo taken in Scottish Highlands +Photo taken in Seoul, South Korea +Photo taken in Serengeti +Photo taken in South Africa +Photo taken in Swiss Alps +Photo taken in Sydney, Australia +Photo taken in the African grasslands +Photo taken in the African Sahara +Photo taken in the African savanna +Photo taken in the Alaskan mountains +Photo taken in the Amazon Rainforest +Photo taken in the Australian beaches +Photo taken in the Australian bushlands +Photo taken in the Australian coral reef +Photo taken in the Australian deserts +Photo taken in the Australian rainforest +Photo taken in the Brazilian beaches +Photo taken in the Brazilian carnival +Photo taken in the Brazilian rainforest +Photo taken in the Brazilian samba parade +Photo taken in the Californian coastline +Photo taken in the Californian redwoods +Photo taken in the Californian vineyards +Photo taken in the Egyptian hieroglyphs +Photo taken in the Egyptian pyramids +Photo taken in the French châteaux +Photo taken in the French lavender fields +Photo taken in the Greek ruins +Photo taken in the Hawaiian beaches +Photo taken in the Hawaiian volcanoes +Photo taken in the Himalayan mountains +Photo taken in the Indian spice markets +Photo taken in the Italian coastal towns +Photo taken in the Italian pizzerias +Photo taken in the Italian vineyards +Photo taken in the Japanese tea gardens +Photo taken in the Kenyan savanna +Photo taken in the Kenyan wildlife +Photo taken in the Mongolian steppes +Photo taken in the Moroccan desert +Photo taken in the Norwegian fjords +Photo taken in the Peruvian Andes +Photo taken in the Peruvian ruins +Photo taken in the Rocky Mountains +Photo taken in the Rub' al Khali (Empty Quarter) +Photo taken in the Sahara Desert +Photo taken in the Serengeti National Park +Photo taken in the Swiss chocolate factories +Photo taken in the Thai floating markets +Photo taken in the Thai street markets +Photo taken in Tokyo, Japan +Photo taken in Venice, Italy +Photo that captures a candid moment +Photo that is taken outdoors +Photo with a dreamy, soft focus effect +Photo with a monochromatic color scheme +Photo with a washed-out vintage look +Photo with bold, contrasting tones +Photo with bold, high contrast black and white tones +Photo with calming, pastel tones +Photo with cool, misty tones +Photo with cool, moonlit tones +Photo with cool, twilight tones +Photo with crisp, monochrome tones +Photo with cross-processing effect +Photo with dramatic lighting +Photo with dreamy soft focus +Photo with faded, nostalgic colors +Photo with grainy, old film effect +Photo with high contrast black and white tones +Photo with high key lighting +Photo with low key lighting +Photo with muted, desaturated tones +Photo with retro color filters +Photo with sepia-toned vintage style +Photo with soft, dreamy tones +Photo with soft, muted tones +Photo with soft, pastel colors +Photo with vibrant, contrasting colors +Photo with vibrant, saturated colors +Photo with vintage film grain effect +Photo with warm, golden hour lighting +Photo with warm, golden hour tones +Photo with warm lighting +Photo with warm, misty tones +Photo with warm, nostalgic tones +Photo with warm, rustic tones +Photo with warm tones +Picture captured in the Alaskan wilderness +Picture captured in the Australian Outback +Picture captured in the Brazilian carnival +Picture captured in the Canadian lakeside +Picture captured in the Canadian maple forests +Picture captured in the Canadian Rockies +Picture captured in the Dutch tulip fields +Picture captured in the Egyptian pyramids +Picture captured in the Greek islands +Picture captured in the Icelandic glaciers +Picture captured in the Italian coastal towns +Picture captured in the Japanese cherry blossoms +Picture captured in the Japanese tea gardens +Picture captured in the New York skyline +Picture captured in the Norwegian fjords +Picture captured in the Scottish highlands +Picture captured in the Spanish vineyards +Picture captured in the Swiss ski resorts +Picture captured in the Thai temples +Picture of a beach +Picture of a dance +Picture of a feline +Picture of animals +Picture of colors +Picture of fast food +Picture of Italian food +Picture of mammels +Picture of plants +Picture of trees +Picture snapped in Brazil +Picture snapped in Italy +Picture snapped in the Alaskan mountains +Picture snapped in the Australian coral reef +Picture snapped in the Australian deserts +Picture snapped in the Australian Outback +Picture snapped in the Californian coastline +Picture snapped in the Canadian maple forests +Picture snapped in the Canadian wilderness +Picture snapped in the Egyptian hieroglyphs +Picture snapped in the Greek islands +Picture snapped in the Greek ruins +Picture snapped in the Icelandic glaciers +Picture snapped in the Irish countryside +Picture snapped in the New Zealand mountains +Picture snapped in the Norwegian fjords +Picture snapped in the Peruvian rainforest +Picture snapped in the Scottish moors +Picture snapped in the South African safari +Picture snapped in the Swiss Alps +picturesque countryside +Picture taken at sunset or sunrise +Picture taken in a bustling bazaar +Picture taken in a city park +Picture taken in a coastal area +Picture taken in a coastal lighthouse +Picture taken in a cozy mountain cabin +Picture taken in a desert landscape +Picture taken in a forest +Picture taken in a grand theater +Picture taken in a historical site +Picture taken in Alberta, Canada +Picture taken in Amazon Rainforest +Picture taken in an amusement park +Picture taken in an art gallery +Picture taken in an underwater world +Picture taken in a peaceful monastery +Picture taken in Argentina +Picture taken in Arizona, USA +Picture taken in a rural village +Picture taken in a sacred place +Picture taken in a serene lakeside cabin +Picture taken in a serene lakeside cottage +Picture taken in a serene lakeside hideaway +Picture taken in a serene lakeside resort +Picture taken in a serene lakeside retreat +Picture taken in a serene lakeside sanctuary +Picture taken in a serene meditation space +Picture taken in a serene mountain retreat +Picture taken in a sunny day +Picture taken in a tranquil garden +Picture taken in a tranquil lakeside +Picture taken in Australia +Picture taken in a zoo or wildlife sanctuary +Picture taken in Bavaria, Germany +Picture taken in Bhutan +Picture taken in Brazil +Picture taken in British Columbia, Canada +Picture taken in California, USA +Picture taken in Canada +Picture taken in China +Picture taken in Costa Rica +Picture taken in Cyprus +Picture taken in Ecuador +Picture taken in Egypt +Picture taken in Fiji +Picture taken in France +Picture taken in French Polynesia +Picture taken in Galápagos Islands +Picture taken in Greece +Picture taken in Hungary +Picture taken in Iceland +Picture taken in India +Picture taken in Indonesia +Picture taken in Ireland +Picture taken in Italy +Picture taken in Japan +Picture taken in Kenya +Picture taken in Laos +Picture taken in Madagascar +Picture taken in Malaysia +Picture taken in Maldives +Picture taken in Mongolia +Picture taken in Morocco +Picture taken in Namibia +Picture taken in Nepal +Picture taken in New Caledonia +Picture taken in New England +Picture taken in New South Wales, Australia +Picture taken in New Zealand +Picture taken in Norway +Picture taken in Ontario, Canada +Picture taken in Outback +Picture taken in Pakistan +Picture taken in Patagonia +Picture taken in Peru +Picture taken in Portugal +Picture taken in Rome +Picture taken in rural Australia +Picture taken in Rwanda +Picture taken in Saudi Arabia +Picture taken in Scotland +Picture taken in Scottish Highlands +Picture taken in Serengeti +Picture taken in Seychelles +Picture taken in South Africa +Picture taken in South Korea +Picture taken in Spain +Picture taken in Sumatra +Picture taken in Swiss Alps +Picture taken in Switzerland +Picture taken in Tanzania +Picture taken in Texas, USA +Picture taken in Thailand +Picture taken in the African desert +Picture taken in the African grasslands +Picture taken in the African savanna +Picture taken in the Alaskan wilderness +Picture taken in the Arabian desert +Picture taken in the Arabian dunes +Picture taken in the Australian beaches +Picture taken in the Australian deserts +Picture taken in the Australian Outback +Picture taken in the Australian rainforest +Picture taken in the Brazilian beaches +Picture taken in the Brazilian carnival +Picture taken in the Brazilian rainforest +Picture taken in the Californian redwoods +Picture taken in the Californian vineyards +Picture taken in the Canadian lakes +Picture taken in the Canadian maple forests +Picture taken in the Canadian Rockies +Picture taken in the Egyptian pyramids +Picture taken in the English countryside +Picture taken in the French châteaux +Picture taken in the French Riviera +Picture taken in the geographical location of Australia +Picture taken in the geographical location of Spain +Picture taken in the Greek islands +Picture taken in the Hawaiian beaches +Picture taken in the Hawaiian volcanoes +Picture taken in the Icelandic glaciers +Picture taken in the Indian spice markets +Picture taken in the Indonesian rice fields +Picture taken in the Italian pasta kitchens +Picture taken in the Italian pizzerias +Picture taken in the Italian vineyards +Picture taken in the Japanese cherry blossoms +Picture taken in the Japanese temples +Picture taken in the Kenyan savanna +Picture taken in the Kenyan wildlife +Picture taken in the Nepalese mountains +Picture taken in the Netherlands +Picture taken in the Norwegian fjords +Picture taken in the Patagonian fjords +Picture taken in the Peruvian rainforest +Picture taken in the Peruvian ruins +Picture taken in the Scotland countryside +Picture taken in the Scottish castles +Picture taken in the Scottish highlands +Picture taken in the Scottish Highlands +Picture taken in the Scottish moors +Picture taken in the South African safari +Picture taken in the southeastern United States +Picture taken in the Spanish Flamenco festivals +Picture taken in the Spanish olive groves +Picture taken in the Swiss Alps +Picture taken in the Swiss chocolate factories +Picture taken in the Swiss ski resorts +Picture taken in the Thai beaches +Picture taken in the Thai street markets +Picture taken in the Thai temples +Picture taken in Uganda +Picture taken in Vietnam +Picture taken in Zimbabwe +Picture taken underwater +Picture with a close-up of a flower +Picture with airplanes +Picture with a single domesticated animal +Picture with a wild animal +Picture with boats +Picture with cars +Picture with multiple domesticated animals +Picture with multiple wild animals +Picture with trains +Picture with water +Picture with wooden texture +Plaid pattern +Playful adults +Playful animals +Playful authenticity +Playful children's playground +playful children's scene +Playful city life +Playful cityscapes +Playful colors +Playful compositions +Playful connections +Playful designs +Playful details +Playful encounters +Playful escapade +Playful escapades +Playful facial expression +Playful horizons +Playful hues +Playful humanity +Playful interaction +Playful interactions +Playful juxtaposition +Playful moments +Playful narratives +Playful nuances +Playful perspectives +Playful reflections +Playful scenes +Playful siblings +Playful silhouettes +Playful spontaneity +Playful textures +Playful urban scenes +Playful winking facial expression +Playful zoo animal interactions +Play of light +Play of light and shadow +Play of shadows +Play of symmetry +Point of view from above +Point of view from below +Pop art colors +Portrait of a person +Portraits in black and white +Posed shot +Powerful and emotive dance +powerful athletic competition +Precise clock mechanism +Precise clockwork gears +Precise mechanical components +Precise mechanical gears +Precise mechanical parts +Precise medical equipment +Precise medical procedure +Precise pocket watch +Precise scientific equipment +Precise surgical procedure +Precise timekeeping mechanism +Precise watch gears +Precise watch mechanism +Precis mathematical formula +Pristine and untouched beach +Pristine and untouched wilderness +pristine forest scene +Pristine snowy landscape +Pristine woodland clearing +Psychedelic color swirls +Pulsating concert light show +Quaint cottage garden +Quaint countryside barn +Quaint countryside lane +Quaint seaside village +Quaint villages +Quiet and serene scene +Quiet forest stream +Quiet grazing cattle +Quiet rural farmhouse +Quiet simplicity +Quiet solitude +Quilted design +Quirky street art +Quirky street performer +Radiant facial expression +Rectangular object +Reflection in water +Reflection or mirror effect +Reflections +Reflections on water +Reflective and calm lake surface +Reflective and introspective self-portrait +Reflective cityscape +Reflective cityscape at twilight +Reflective coastal scene +Reflective coastal view +Reflective countryside scene +Reflective introspection +Reflective introspection +Reflective landscape +Reflective modern glass facade +Reflective moment +Reflective moments +Reflective mountain view +Reflective ocean view +Reflective pond scene +Reflective rural scene +Reflective stillness +Reflective surface +Reflective surfaces +Reflective urban scene +Reflective urban view +regal architecture +Regretful facial expression +Relatable narrative +Relaxed facial expression +Relieved facial expression +Remote alpine chalet +Remote Arctic tundra +Remote desolation +Remote hilltop hut +Remote island paradise +Remote mountain cabin +Repetitive elements +Resonant harmony +Retro-style poster design +Rich and opulent interior decor +Rich textures +Roaring fireplace warmth +Rolling countryside farmland +Rolling countryside hills +Rolling vineyard landscapes +Rolling wheat fields +Romantic mood +Rugged mountain terrain +Rule of thirds +Rural setting +Rural windmill silhouette +Rustic architecture +Rustic authenticity +Rustic beauty +Rustic charm +Rustic countryside charm +Rustic landscapes +Rustic marketplace +Rustic scene +Rustic simplicity +Rustic warmth +Rustic wooden textures +Rustling autumn leaves +Sad facial expression +Sandy beach shores +Sarcastic facial expression +Sarcastic raised eyebrow facial expression +Saturated landscape +sea horizon +Seaside view +Secluded beach cove +Secluded forest cabin +Secluded island cove +Secluded retreat +Secluded tropical beach +Secret rendezvous +Sepia-toned photograph +Serendipitous discovery +Serendipitous moment +Serene an countryside +Serene atmospheres +Serene beach sunset +Serene city life +Serene city lights +Serene cityscapes +Serene city scenes +Serene compositions +Serene countryside sunrise +Serene countryside view +Serene dialogues +Serene encounters +Serene escapes +Serene forest clearing +serene forest glade +serene forest haven +serene forest refuge +Serene garden hideaway +serene garden oasis +Serene garden pond +Serene horizons +Serene impressions +Serene interludes +serene Japanese garden +Serene Japanese garden +Serene lake scene +Serene lakeside retreat +Serene lakeside scene +Serene landscapes +Serene meadow landscape +serene meditation setting +Serene moments +Serene moonlight +serene mountain refuge +serene mountain retreat +serene mountain scenery +Serene nature +serene oceanside retreat +serene oceanside scene +Serene park setting +Serene perspectives +Serene reflection +Serene retreats +serene riverside scene +Serene solitude +Serene streets +Serene sunrise or sunset +Serene tranquility +Serene vistas +serene waterfall scene +Serene waterfront scene +Serene waters +Serene waterscapes +Serene waterside +Serene wilderness +Serene winter wonderland +serene woodland refuge +serene woodland retreat +Serious facial expression +Shadow play +Sharp focus +Sharp object +Shattered reality +short text +Shy facial expression +Silent communication +Silhouette +Silhouetted subject +Skeptical facial expression +Skyscrapers touching clouds +Smiling facial expression +Snapshot of a marsupial +Snow-covered mountain peaks +Snowy forest trail +Soft focus +Soft natural tones +Soft pastel hues +Soft pastel tones +Solitary figure +Soothing beach sunset +soothing meditation retreat +soothing meditation scene +Spatial depth +Spirited performance +Spirited sportsmanship +Stained glass design +Stark and minimalist urban scene +Stark minimalism +Still life composition +Stirring symbolism +Street art expression +Street art-inspired design +Street art-inspired mural painting +Street lit by neon signs +Striking and vibrant fashion portrait +Striking architectural contrast +Striking contemporary sculpture +Striking fashion attire +Striking fashion moment +Striking fashion portrait +Striking fashion pose +Striking fashion presentation +Striking fashion runway moment +Striking fashion shot +Striking fashion show +Striking fashion silhouette +Striking fashion stance +Striking fashion statement +Striking juxtaposition +Striped design +Strong backlighting +Strong leading lines +Structural foundation +Subdued atmospheres +Subdued authenticity +Subdued beauty +Subdued charm +Subdued city life +Subdued city pulse +Subdued cityscapes +Subdued city scenes +Subdued details +Subdued dialogues +Subdued elegance +Subdued emotions +Subdued expressions +Subdued grandeur +Subdued horizons +Subdued hues +Subdued humanity +Subdued landscapes +Subdued memories +Subdued moments +Subdued moods +Subdued reflections +Subdued saturation +Subdued scenes +Subdued tranquility +Subdued vitality +Sublime and majestic waterfall +Sublime and serene mountain lake +Sublime grandeur +Sublime skies +Submerged underwater scene +Subtle contrast +Subtle emotion +Subtle emotion portrayal +Subtle emotions +Subtle gestures +Subtle gradation +Subtle human presence +Subtle monochrome +Subtle natural light +Subtle nuance +Subtle texture +Subtle textures +Subtle tonality +Sunlit foliage +Sunlit meadow path +Sunrise or sunset +Surprised facial expression +Surreal artwork with floating elements +Surreal digital collage +Surreal dreamscape +Surreal elements +Surrealist artwork with dreamlike elements +Surrealist collage artwork +Surreal photo manipulation +Swirling aurora borealis +Symmetrical arrangement +Symmetrical composition +Symmetrical object +Symmetry disrupted +Textured variation +Texture of a feather +Texture of hair +Texture of skin +The number eight +The number eleven +The number fifteen +The number five +The number four +The number fourteen +The number nine +The number seven +The number six +The number thirty +The number three +The number twelve +The number twenty +The number twenty-five +The number two +Thoughtful facial expression +Thought-provoking content +thrilling competitive sport +thrilling extreme sports moment +thrilling motorsport action +thrilling motorsport race +thrilling racing event +thrilling sporting challenge +thrilling sports action +thrilling sports challenge +thrilling sports event +thrilling water sports moment +Tie-dye design +Time-honored craftsmanship +Time-honored tradition +Time-honored traditions +Time-lapse effect +Time-lapse image +Time-lapse trails +Timeless artistic masterpiece +Timeless beauty +Timeless black and white +Timeless black and white portrait +Timeless classic artwork +Timeless clock tower +Timeless cultural artifact +Timeless elegance +Timeless fine art piece +Timeless historical artifact +Timeless historical monument +Timeless literary work +Time-worn and antique artifact +Time-worn artifacts +Time-worn beauty +Time-worn stone structure +Towering redwood forest +towering skyscrapers +Towering skyscrapers +Traditional cultural ceremony +Traditional festive celebration +Tranquil Asian temple +Tranquil atmospheres +tranquil beach sunset +Tranquil boating on a lake +Tranquil cityscapes +Tranquil contemplation +Tranquil countryside +Tranquil dialogues +Tranquil escapes +Tranquil forest glade +Tranquil forest haven +Tranquil forest refuge +Tranquil forest scene +Tranquil forest scene +Tranquil forest waterfall +Tranquil garden oasis +Tranquil garden pathway +Tranquil garden retreat +Tranquil horizons +Tranquil interlude +Tranquil interludes +Tranquil intersections +Tranquility +Tranquil Japanese garden +Tranquil lakeside pier +Tranquil lakeside view +Tranquil landscapes +Tranquil meadows +Tranquil meditation +Tranquil meditation retreat +Tranquil meditation retreat +Tranquil meditation scene +Tranquil meditation setting +Tranquil moments +Tranquil morning mist +Tranquil mountain refuge +Tranquil mountain retreat +Tranquil mountain scenery +Tranquil oceanside retreat +Tranquil oceanside scene +Tranquil passages +Tranquil reflection +Tranquil reflections +Tranquil retreat +Tranquil retreats +Tranquil riverbank scene +Tranquil river bend +Tranquil riverside +Tranquil riverside scene +Tranquil sanctuary +Tranquil seascape +Tranquil seclusion +Tranquil temple courtyard +Tranquil village pond +Tranquil vistas +Tranquil waterfall scene +Tranquil waterscape +Tranquil waterscapes +Tranquil waterside +Tranquil woodland refuge +Tranquil woodland retreat +Transformative impact +Transformative journey +Translucent materials +triangular object +Twinkling starlit sky +Unconventional beauty +Underwater scene +Unexpected symmetry +Unique styling +Universal appeal +Universal significance +Unpredictable pattern +Unpredictable weather +Unspoiled beauty +Untamed wilderness +Unusual angle +Urban alleyway +Urban and expressive graffiti art +Urban and expressive street expression +Urban and expressive street mural +Urban and expressive street performance +Urban and gritty street art +Urban and vibrant street art +Urban and vibrant street scene +Urban architecture photography +Urban authenticity +Urban cityscape +Urban complexity +Urban connections +Urban contrasts +Urban decay +Urban diversity +Urban dreams +Urban dreamscape +Urban exploration +Urban explorations +Urban graffiti art +Urban hustle +Urban hustle and bustle +Urban interactions +Urban intersection +Urban journeys +Urban labyrinth +Urban landscapes +Urban life +Urban mosaic +Urban nostalgia +Urban park greenery +Urban perspectives +Urban pulse +Urban reflections +Urban rhythm +Urban rooftop panorama +Urban sanctuary +Urban setting +Urban skyscraper skyline +Urban solitude +Urban soul +Urban spectacles +Urban street corner +Urban street fashion +Urban subway station +Urban symphony +Urban tapestry +Urban vibrancy +Urban vitality +Vast desert dunes +vast natural landscape +Vast open sky +Vibrant and bustling city market +Vibrant and bustling city street +Vibrant autumn foliage +Vibrant celebrations +Vibrant city alley +Vibrant city nightlife +Vibrant city pulse +Vibrant city skyline +Vibrant colors +Vibrant cultural heritage +Vibrant cultures +Vibrant encounters +Vibrant energy +Vibrant festivals +Vibrant floral arrangement +Vibrant humanity +Vibrant Indian market scene +Vibrant market life +Vibrant marketplace +Vibrant marketplaces +Vibrant marketplace stalls +Vibrant market scenes +Vibrant market stalls +Vibrant outdoor market +Vibrant storytelling +Vibrant street life +Vibrant street scene +Vibrant traditions +Vibrant urban culture +Vibrant urban energy +Vibrant urban life +Vibrant vitality +Vibrant watercolor painting +Vintage filter +Vintage nostalgia +Vintage or aged look +Vintage retro styling +Vintage sepia tones +Vintage style photo +Visual rhythm +Vivid cultural celebration +Vivid cultural ceremony +Vivid cultural display +Vivid cultural event +Vivid cultural exhibition +Vivid cultural festival +Vivid cultural market +Vivid cultural performance +Vivid cultural procession +Vivid cultural representation +Vivid cultural spectacle +Vivid underwater life +Vivid underwater world +Warm and cozy indoor scene +Warm home interior +weathered architectural detail +Weathered architecture +weathered artistic creation +Weathered authenticity +Weathered beauty +Weathered character +Weathered charm +Weathered city life +Weathered cityscape +Weathered cityscapes +Weathered facades +weathered historical artifact +Weathered horizons +Weathered humanity +Weathered pathways +weathered religious icon +weathered sculptural element +Weathered stories +Weathered structures +Weathered textures +Weather-worn textures +wheat fields +Whimsicachildren's scenel +Whimsical childhood fantasy +Whimsical children's play +Whimsical composition +Whimsical conceptual photography +Whimsical details +Whimsical dreamlike atmosphere +Whimsical dream world +Whimsical fantasy +Whimsical fantasy scene +Whimsical imagination +Whimsical scene +Whimsical scenes +Whimsical storybook scene +Whirling amusement park ride +Whirling carousel at a fair +Whispering city lights +Whispering cityscapes +Whispering city scenes +Whispering facades +Whispering foliage +Whispering horizons +Whispering landscapes +Whispering leaves +Whispering memories +Whispering narratives +Whispering passages +Whispering pathways +Whispering perspectives +Whispering streets +Whispering streetscapes +Whispering waters +Whispering waterscapes +Whispering waves +Whispering winds +Whispers of history +Whispers of motion +Whispers of nature +Whispers of time +Wide-angle perspective +Wide open spaces +Wildlife in their natural habitat +Windswept landscape +Wind-swept vistas +Wistful facial expression +Woven textile design \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/__init__.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5ce9ff2ddb53f400b7ce4f45a9c9a5a542b23193 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/__init__.py @@ -0,0 +1,8 @@ +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model, create_model_and_transforms, create_model_from_pretrained, get_tokenizer, create_loss +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import list_models, add_model_config, get_model_config, load_checkpoint +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.pretrained import list_pretrained, list_pretrained_models_by_tag, list_pretrained_tags_by_model, \ + get_pretrained_url, download_pretrained_from_url, is_pretrained_cfg, get_pretrained_cfg, download_pretrained +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.tokenizer import SimpleTokenizer, tokenize, decode +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.transform import image_transform, AugmentationCfg +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.openai_templates import OPENAI_IMAGENET_TEMPLATES \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/binary_waterbirds.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/binary_waterbirds.py new file mode 100644 index 0000000000000000000000000000000000000000..2d0a37e4fdcf79ec4260275dd97e45b1d9b183cc --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/binary_waterbirds.py @@ -0,0 +1,52 @@ +import os +import os.path +from typing import Any, Callable, cast, Dict, List, Optional, Tuple +from typing import Union + +from PIL import Image +import pandas as pd +from torchvision.datasets import VisionDataset +import torch + + +def pil_loader(path: str) -> Image.Image: + # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835) + with open(path, "rb") as f: + img = Image.open(f) + return img.convert("RGB") + +class BinaryWaterbirds(VisionDataset): + def __init__( + self, + root: str, + split: str, + loader: Callable[[str], Any] = pil_loader, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + ) -> None: + super().__init__(root, transform=transform, target_transform=target_transform) + + self.loader = loader + csv = pd.read_csv(os.path.join(root, 'metadata.csv')) + split = {'test': 2, 'valid': 1, 'train': 0}[split] + csv = csv[csv['split'] == split] + self.samples = [(os.path.join(root, csv.iloc[i]['img_filename']), csv.iloc[i]['y']) for i in range(len(csv))] + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + """ + Args: + index (int): Index + Returns: + tuple: (sample, target) where target is class_index of the target class. + """ + path, target = self.samples[index] + sample = self.loader(path) + if self.transform is not None: + sample = self.transform(sample) + if self.target_transform is not None: + target = self.target_transform(target) + + return sample, target + + def __len__(self) -> int: + return len(self.samples) diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/constants.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..bdd90dc5ff9139d62345aabf611b1f4861b66de5 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/constants.py @@ -0,0 +1,2 @@ +OPENAI_DATASET_MEAN = (0.48145466, 0.4578275, 0.40821073) +OPENAI_DATASET_STD = (0.26862954, 0.26130258, 0.27577711) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/cub_classes.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/cub_classes.py new file mode 100644 index 0000000000000000000000000000000000000000..b27ebcd4ae0af5152411933797499dc092adaace --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/cub_classes.py @@ -0,0 +1,2 @@ +cub_classes = ['Black footed Albatross', 'Laysan Albatross', 'Sooty Albatross', 'Groove billed Ani', 'Crested Auklet', 'Least Auklet', 'Parakeet Auklet', 'Rhinoceros Auklet', 'Brewer Blackbird', 'Red winged Blackbird', 'Rusty Blackbird', 'Yellow headed Blackbird', 'Bobolink', 'Indigo Bunting', 'Lazuli Bunting', 'Painted Bunting', 'Cardinal', 'Spotted Catbird', 'Gray Catbird', 'Yellow breasted Chat', 'Eastern Towhee', 'Chuck will Widow', 'Brandt Cormorant', 'Red faced Cormorant', 'Pelagic Cormorant', 'Bronzed Cowbird', 'Shiny Cowbird', 'Brown Creeper', 'American Crow', 'Fish Crow', 'Black billed Cuckoo', 'Mangrove Cuckoo', 'Yellow billed Cuckoo', 'Gray crowned Rosy Finch', 'Purple Finch', 'Northern Flicker', 'Acadian Flycatcher', 'Great Crested Flycatcher', 'Least Flycatcher', 'Olive sided Flycatcher', 'Scissor tailed Flycatcher', 'Vermilion Flycatcher', 'Yellow bellied Flycatcher', 'Frigatebird', 'Northern Fulmar', 'Gadwall', 'American Goldfinch', 'European Goldfinch', 'Boat tailed Grackle', 'Eared Grebe', 'Horned Grebe', 'Pied billed Grebe', 'Western Grebe', 'Blue Grosbeak', 'Evening Grosbeak', 'Pine Grosbeak', 'Rose breasted Grosbeak', 'Pigeon Guillemot', 'California Gull', 'Glaucous winged Gull', 'Heermann Gull', 'Herring Gull', 'Ivory Gull', 'Ring billed Gull', 'Slaty backed Gull', 'Western Gull', 'Anna Hummingbird', 'Ruby throated Hummingbird', 'Rufous Hummingbird', 'Green Violetear', 'Long tailed Jaeger', 'Pomarine Jaeger', 'Blue Jay', 'Florida Jay', 'Green Jay', 'Dark eyed Junco', 'Tropical Kingbird', 'Gray Kingbird', 'Belted Kingfisher', 'Green Kingfisher', 'Pied Kingfisher', 'Ringed Kingfisher', 'White breasted Kingfisher', 'Red legged Kittiwake', 'Horned Lark', 'Pacific Loon', 'Mallard', 'Western Meadowlark', 'Hooded Merganser', 'Red breasted Merganser', 'Mockingbird', 'Nighthawk', 'Clark Nutcracker', 'White breasted Nuthatch', 'Baltimore Oriole', 'Hooded Oriole', 'Orchard Oriole', 'Scott Oriole', 'Ovenbird', 'Brown Pelican', 'White Pelican', 'Western Wood Pewee', 'Sayornis', 'American Pipit', 'Whip poor Will', 'Horned Puffin', 'Common Raven', 'White necked Raven', 'American Redstart', 'Geococcyx', 'Loggerhead Shrike', 'Great Grey Shrike', 'Baird Sparrow', 'Black throated Sparrow', 'Brewer Sparrow', 'Chipping Sparrow', 'Clay colored Sparrow', 'House Sparrow', 'Field Sparrow', 'Fox Sparrow', 'Grasshopper Sparrow', 'Harris Sparrow', 'Henslow Sparrow', 'Le Conte Sparrow', 'Lincoln Sparrow', 'Nelson Sharp tailed Sparrow', 'Savannah Sparrow', 'Seaside Sparrow', 'Song Sparrow', 'Tree Sparrow', 'Vesper Sparrow', 'White crowned Sparrow', 'White throated Sparrow', 'Cape Glossy Starling', 'Bank Swallow', 'Barn Swallow', 'Cliff Swallow', 'Tree Swallow', 'Scarlet Tanager', 'Summer Tanager', 'Artic Tern', 'Black Tern', 'Caspian Tern', 'Common Tern', 'Elegant Tern', 'Forsters Tern', 'Least Tern', 'Green tailed Towhee', 'Brown Thrasher', 'Sage Thrasher', 'Black capped Vireo', 'Blue headed Vireo', 'Philadelphia Vireo', 'Red eyed Vireo', 'Warbling Vireo', 'White eyed Vireo', 'Yellow throated Vireo', 'Bay breasted Warbler', 'Black and white Warbler', 'Black throated Blue Warbler', 'Blue winged Warbler', 'Canada Warbler', 'Cape May Warbler', 'Cerulean Warbler', 'Chestnut sided Warbler', 'Golden winged Warbler', 'Hooded Warbler', 'Kentucky Warbler', 'Magnolia Warbler', 'Mourning Warbler', 'Myrtle Warbler', 'Nashville Warbler', 'Orange crowned Warbler', 'Palm Warbler', 'Pine Warbler', 'Prairie Warbler', 'Prothonotary Warbler', 'Swainson Warbler', 'Tennessee Warbler', 'Wilson Warbler', 'Worm eating Warbler', 'Yellow Warbler', 'Northern Waterthrush', 'Louisiana Waterthrush', 'Bohemian Waxwing', 'Cedar Waxwing', 'American Three toed Woodpecker', 'Pileated Woodpecker', 'Red bellied Woodpecker', 'Red cockaded Woodpecker', 'Red headed Woodpecker', 'Downy Woodpecker', 'Bewick Wren', 'Cactus Wren', 'Carolina Wren', 'House Wren', 'Marsh Wren', 'Rock Wren', 'Winter Wren', 'Common Yellowthroat'] +waterbird_classes = ['landbird', 'waterbird'] \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/factory.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/factory.py new file mode 100644 index 0000000000000000000000000000000000000000..aa528ae46d36202088ea08a5d139d7474a3ab3ce --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/factory.py @@ -0,0 +1,382 @@ +import json +import logging +import os +import pathlib +import re +from copy import deepcopy +from pathlib import Path +from typing import Any, Dict, Optional, Tuple, Union + +import torch + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.model import CLIP, convert_to_custom_text_state_dict,\ + resize_pos_embed, get_cast_dtype +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.openai_models import load_openai_model +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.pretrained import is_pretrained_cfg, get_pretrained_cfg, download_pretrained,\ + list_pretrained_tags_by_model, download_pretrained_from_hf +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.transform import image_transform, AugmentationCfg +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.tokenizer import HFTokenizer, tokenize + + +HF_HUB_PREFIX = 'hf-hub:' +_MODEL_CONFIG_PATHS = [Path(__file__).parent / f"model_configs/"] +_MODEL_CONFIGS = {} # directory (model_name: config) of model architecture configs + + +def _natural_key(string_): + return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_.lower())] + + +def _rescan_model_configs(): + global _MODEL_CONFIGS + + config_ext = ('.json',) + config_files = [] + for config_path in _MODEL_CONFIG_PATHS: + if config_path.is_file() and config_path.suffix in config_ext: + config_files.append(config_path) + elif config_path.is_dir(): + for ext in config_ext: + config_files.extend(config_path.glob(f'*{ext}')) + + for cf in config_files: + with open(cf, 'r') as f: + model_cfg = json.load(f) + if all(a in model_cfg for a in ('embed_dim', 'vision_cfg', 'text_cfg')): + _MODEL_CONFIGS[cf.stem] = model_cfg + + _MODEL_CONFIGS = {k: v for k, v in sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))} + + +_rescan_model_configs() # initial populate of model config registry + + +def list_models(): + """ enumerate available model architectures based on config files """ + return list(_MODEL_CONFIGS.keys()) + + +def add_model_config(path): + """ add model config path or file and update registry """ + if not isinstance(path, Path): + path = Path(path) + _MODEL_CONFIG_PATHS.append(path) + _rescan_model_configs() + + +def get_model_config(model_name): + if model_name in _MODEL_CONFIGS: + return deepcopy(_MODEL_CONFIGS[model_name]) + else: + return None + + +def get_tokenizer(model_name): + if model_name.startswith(HF_HUB_PREFIX): + tokenizer = HFTokenizer(model_name[len(HF_HUB_PREFIX):]) + else: + config = get_model_config(model_name) + tokenizer = HFTokenizer( + config['text_cfg']['hf_tokenizer_name']) if 'hf_tokenizer_name' in config['text_cfg'] else tokenize + return tokenizer + + +def load_state_dict(checkpoint_path: str, map_location='cpu'): + checkpoint = torch.load(checkpoint_path, map_location=map_location) + if isinstance(checkpoint, dict) and 'state_dict' in checkpoint: + state_dict = checkpoint['state_dict'] + else: + state_dict = checkpoint + if next(iter(state_dict.items()))[0].startswith('module'): + state_dict = {k[7:]: v for k, v in state_dict.items()} + return state_dict + + +def load_checkpoint(model, checkpoint_path, strict=True): + state_dict = load_state_dict(checkpoint_path) + # detect old format and make compatible with new format + if 'positional_embedding' in state_dict and not hasattr(model, 'positional_embedding'): + state_dict = convert_to_custom_text_state_dict(state_dict) + resize_pos_embed(state_dict, model) + incompatible_keys = model.load_state_dict(state_dict, strict=strict) + return incompatible_keys + + +def create_model( + model_name: str, + pretrained: Optional[str] = None, + precision: str = 'fp32', + device: Union[str, torch.device] = 'cpu', + jit: bool = False, + force_quick_gelu: bool = False, + force_custom_text: bool = False, + force_patch_dropout: Optional[float] = None, + force_image_size: Optional[Union[int, Tuple[int, int]]] = None, + pretrained_image: bool = False, + pretrained_hf: bool = True, + cache_dir: Optional[str] = None, + output_dict: Optional[bool] = None, + require_pretrained: bool = False, +): + has_hf_hub_prefix = model_name.startswith(HF_HUB_PREFIX) + if has_hf_hub_prefix: + model_id = model_name[len(HF_HUB_PREFIX):] + checkpoint_path = download_pretrained_from_hf(model_id, cache_dir=cache_dir) + config_path = download_pretrained_from_hf(model_id, filename='open_clip_config.json', cache_dir=cache_dir) + + with open(config_path, 'r', encoding='utf-8') as f: + config = json.load(f) + pretrained_cfg = config['preprocess_cfg'] + model_cfg = config['model_cfg'] + else: + model_name = model_name.replace('/', '-') # for callers using old naming with / in ViT names + checkpoint_path = None + pretrained_cfg = {} + model_cfg = None + + if isinstance(device, str): + device = torch.device(device) + + if pretrained and pretrained.lower() == 'openai': + logging.info(f'Loading pretrained {model_name} from OpenAI.') + model = load_openai_model( + model_name, + precision=precision, + device=device, + cache_dir=cache_dir, + ) + else: + model_cfg = model_cfg or get_model_config(model_name) + if model_cfg is not None: + logging.info(f'Loaded {model_name} model config.') + else: + logging.error(f'Model config for {model_name} not found; available models {list_models()}.') + raise RuntimeError(f'Model config for {model_name} not found.') + + if force_quick_gelu: + # override for use of QuickGELU on non-OpenAI transformer models + model_cfg["quick_gelu"] = True + + if force_patch_dropout is not None: + # override the default patch dropout value + model_cfg["vision_cfg"]["patch_dropout"] = force_patch_dropout + + if force_image_size is not None: + # override model config's image size + model_cfg["vision_cfg"]["image_size"] = force_image_size + + is_timm_model = 'timm_model_name' in model_cfg.get('vision_cfg', {}) + if pretrained_image: + if is_timm_model: + # pretrained weight loading for timm models set via vision_cfg + model_cfg['vision_cfg']['timm_model_pretrained'] = True + else: + assert False, 'pretrained image towers currently only supported for timm models' + + # cast_dtype set for fp16 and bf16 (manual mixed-precision), not set for 'amp' or 'pure' modes + cast_dtype = get_cast_dtype(precision) + is_hf_model = 'hf_model_name' in model_cfg.get('text_cfg', {}) + custom_text = model_cfg.pop('custom_text', False) or force_custom_text or is_hf_model + + if custom_text: + if is_hf_model: + model_cfg['text_cfg']['hf_model_pretrained'] = pretrained_hf + if "coca" in model_name: + raise ValueError('Coca is not implemented') + model = CoCa(**model_cfg, cast_dtype=cast_dtype) + else: + raise ValueError('CustomTextCLIP is not implemented') + model = CustomTextCLIP(**model_cfg, cast_dtype=cast_dtype) + else: + model = CLIP(**model_cfg, cast_dtype=cast_dtype) + + if precision in ("fp16", "bf16"): + dtype = torch.float16 if 'fp16' in precision else torch.bfloat16 + # manual mixed precision that matches original OpenAI behaviour + if is_timm_model: + # FIXME this is a bit janky, create timm based model in low-precision and + # then cast only LayerNormFp32 instances back to float32 so they don't break. + # Why? The convert_weights_to_lp fn only works with native models. + model.to(device=device, dtype=dtype) + from transformer import LayerNormFp32 + def _convert_ln(m): + if isinstance(m, LayerNormFp32): + m.weight.data = m.weight.data.to(torch.float32) + m.bias.data = m.bias.data.to(torch.float32) + model.apply(_convert_ln) + else: + model.to(device=device) + convert_weights_to_lp(model, dtype=dtype) + elif precision in ("pure_fp16", "pure_bf16"): + dtype = torch.float16 if 'fp16' in precision else torch.bfloat16 + model.to(device=device, dtype=dtype) + else: + model.to(device=device) + + pretrained_loaded = False + if pretrained: + checkpoint_path = '' + pretrained_cfg = get_pretrained_cfg(model_name, pretrained) + if pretrained_cfg: + checkpoint_path = download_pretrained(pretrained_cfg, cache_dir=cache_dir) + elif os.path.exists(pretrained): + checkpoint_path = pretrained + + if checkpoint_path: + logging.info(f'Loading pretrained {model_name} weights ({pretrained}).') + load_checkpoint(model, checkpoint_path) + else: + error_str = ( + f'Pretrained weights ({pretrained}) not found for model {model_name}.' + f'Available pretrained tags ({list_pretrained_tags_by_model(model_name)}.') + logging.warning(error_str) + raise RuntimeError(error_str) + pretrained_loaded = True + elif has_hf_hub_prefix: + logging.info(f'Loading pretrained {model_name} weights ({pretrained}).') + load_checkpoint(model, checkpoint_path) + pretrained_loaded = True + + if require_pretrained and not pretrained_loaded: + # callers of create_model_from_pretrained always expect pretrained weights + raise RuntimeError( + f'Pretrained weights were required for (model: {model_name}, pretrained: {pretrained}) but not loaded.') + + # set image / mean metadata from pretrained_cfg if available, or use default + model.visual.image_mean = pretrained_cfg.get('mean', None) or OPENAI_DATASET_MEAN + model.visual.image_std = pretrained_cfg.get('std', None) or OPENAI_DATASET_STD + + if output_dict and hasattr(model, "output_dict"): + model.output_dict = True + + if jit: + model = torch.jit.script(model) + + return model + + +def create_loss(args): + if args.distill: + return DistillClipLoss( + local_loss=args.local_loss, + gather_with_grad=args.gather_with_grad, + cache_labels=True, + rank=args.rank, + world_size=args.world_size, + use_horovod=args.horovod, + ) + elif "coca" in args.model.lower(): + return CoCaLoss( + caption_loss_weight=args.coca_caption_loss_weight, + clip_loss_weight=args.coca_contrastive_loss_weight, + local_loss=args.local_loss, + gather_with_grad=args.gather_with_grad, + cache_labels=True, + rank=args.rank, + world_size=args.world_size, + use_horovod=args.horovod, + ) + return ClipLoss( + local_loss=args.local_loss, + gather_with_grad=args.gather_with_grad, + cache_labels=True, + rank=args.rank, + world_size=args.world_size, + use_horovod=args.horovod, + ) + + +def create_model_and_transforms( + model_name: str, + pretrained: Optional[str] = None, + precision: str = 'fp32', + device: Union[str, torch.device] = 'cpu', + jit: bool = False, + force_quick_gelu: bool = False, + force_custom_text: bool = False, + force_patch_dropout: Optional[float] = None, + force_image_size: Optional[Union[int, Tuple[int, int]]] = None, + pretrained_image: bool = False, + pretrained_hf: bool = True, + image_mean: Optional[Tuple[float, ...]] = None, + image_std: Optional[Tuple[float, ...]] = None, + aug_cfg: Optional[Union[Dict[str, Any], AugmentationCfg]] = None, + cache_dir: Optional[str] = None, + output_dict: Optional[bool] = None, +): + model = create_model( + model_name, + pretrained, + precision=precision, + device=device, + jit=jit, + force_quick_gelu=force_quick_gelu, + force_custom_text=force_custom_text, + force_patch_dropout=force_patch_dropout, + force_image_size=force_image_size, + pretrained_image=pretrained_image, + pretrained_hf=pretrained_hf, + cache_dir=cache_dir, + output_dict=output_dict, + ) + + image_mean = image_mean or getattr(model.visual, 'image_mean', None) + image_std = image_std or getattr(model.visual, 'image_std', None) + preprocess_train = image_transform( + model.visual.image_size, + is_train=True, + mean=image_mean, + std=image_std, + aug_cfg=aug_cfg, + ) + preprocess_val = image_transform( + model.visual.image_size, + is_train=False, + mean=image_mean, + std=image_std, + ) + + return model, preprocess_train, preprocess_val + + +def create_model_from_pretrained( + model_name: str, + pretrained: Optional[str] = None, + precision: str = 'fp32', + device: Union[str, torch.device] = 'cpu', + jit: bool = False, + force_quick_gelu: bool = False, + force_custom_text: bool = False, + force_image_size: Optional[Union[int, Tuple[int, int]]] = None, + return_transform: bool = True, + image_mean: Optional[Tuple[float, ...]] = None, + image_std: Optional[Tuple[float, ...]] = None, + cache_dir: Optional[str] = None, +): + model = create_model( + model_name, + pretrained, + precision=precision, + device=device, + jit=jit, + force_quick_gelu=force_quick_gelu, + force_custom_text=force_custom_text, + force_image_size=force_image_size, + cache_dir=cache_dir, + require_pretrained=True, + ) + + if not return_transform: + return model + + image_mean = image_mean or getattr(model.visual, 'image_mean', None) + image_std = image_std or getattr(model.visual, 'image_std', None) + preprocess = image_transform( + model.visual.image_size, + is_train=False, + mean=image_mean, + std=image_std, + ) + + return model, preprocess \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/hook.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/hook.py new file mode 100644 index 0000000000000000000000000000000000000000..7901d2a1a7c58a41f3ef97ac4983e41084cf4841 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/hook.py @@ -0,0 +1,87 @@ +from typing import Dict, Text, Callable, List +from collections import defaultdict + + +class HookManager(object): + def __init__(self, hook_dict: Dict[Text, List[Callable]] = None): + self.hook_dict = hook_dict or defaultdict(list) + self.called = defaultdict(int) + self.forks = dict() + + def register(self, name: Text, func: Callable): + assert name + found_successor = False + for header, d in self.forks.items(): + if name.startswith(header.split('.')[0]+'.'): + next_ = name[len(header.split('.')[0]+'.'):].split('.')[0] + prev_ = header.split('.')[0] + if next_.isnumeric() and prev_ + '.' + next_ == header: + d.register(name[len(header)+1:], func) + elif next_ == '*': + d.register(name[len(prev_ + '.*')+1:], func) + else: + d.register(name[len(header)+1:], func) + found_successor = True + if not found_successor: + self.hook_dict[name].append(func) + + def unregister(self, name: Text, func: Callable): + assert name + found_successor = False + for header, d in self.forks.items(): + if name.startswith(header.split('.')[0]+'.'): + next_ = name[len(header.split('.')[0]+'.'):].split('.')[0] + prev_ = header.split('.')[0] + if next_.isnumeric() and prev_ + '.' + next_ == header: + d.register(name[len(header)+1:], func) + elif next_ == '*': + d.register(name[len(prev_ + '.*')+1:], func) + else: + d.register(name[len(header)+1:], func) + found_successor = True + if not found_successor and func in self.hook_dict[name]: + self.hook_dict[name].remove(func) + + def __call__(self, name: Text, **kwargs): + if name in self.hook_dict: + self.called[name] += 1 + for function in self.hook_dict[name]: + ret = function(**kwargs) + if len(self.hook_dict[name]) > 1: + last = self.hook_dict[name][-1] + # print(f'The last returned value comes from func {last}') + return ret + else: + return kwargs['ret'] + + def fork(self, name): + if name in self.forks: + raise ValueError(f'Forking with the same name is not allowed. Already forked with {name}.') + filtered_hooks = [(k[len(name)+1:], v) for k, v in self.hook_dict.items() if k.startswith(name+'.')] + filtered_hooks_d = defaultdict(list) + for i, j in filtered_hooks: + if isinstance(j, list): + filtered_hooks_d[i].extend(j) + else: + filtered_hooks_d[i].append(j) + new_hook = HookManager(filtered_hooks_d) + self.forks[name] = new_hook + return new_hook + + def fork_iterative(self, name, iteration): + filtered_hooks = [(k[len(name+'.'+str(iteration))+1:], v) for k, v in self.hook_dict.items() if k.startswith(name+'.'+str(iteration)+'.')] + filtered_hooks += [(k[len(name+'.*')+1:], v) for k, v in self.hook_dict.items() if k.startswith(name+'.*.')] + filtered_hooks_d = defaultdict(list) + for i, j in filtered_hooks: + if isinstance(j, list): + filtered_hooks_d[i].extend(j) + else: + filtered_hooks_d[i].append(j) + new_hook = HookManager(filtered_hooks_d) + self.forks[name+'.'+str(iteration)] = new_hook + return new_hook + + def finalize(self): + for name in self.hook_dict.keys(): + if self.called[name] == 0: + raise ValueError(f'Hook {name} was registered but never used!') \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_classes.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_classes.py new file mode 100644 index 0000000000000000000000000000000000000000..1d34f838cd365ba63e55396e878d470f49b0478d --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_classes.py @@ -0,0 +1 @@ +imagenet_classes = ["tench", "goldfish", "great white shark", "tiger shark", "hammerhead shark", "electric ray", "stingray", "rooster", "hen", "ostrich", "brambling", "goldfinch", "house finch", "junco", "indigo bunting", "American robin", "bulbul", "jay", "magpie", "chickadee", "American dipper", "kite (bird of prey)", "bald eagle", "vulture", "great grey owl", "fire salamander", "smooth newt", "newt", "spotted salamander", "axolotl", "American bullfrog", "tree frog", "tailed frog", "loggerhead sea turtle", "leatherback sea turtle", "mud turtle", "terrapin", "box turtle", "banded gecko", "green iguana", "Carolina anole", "desert grassland whiptail lizard", "agama", "frilled-necked lizard", "alligator lizard", "Gila monster", "European green lizard", "chameleon", "Komodo dragon", "Nile crocodile", "American alligator", "triceratops", "worm snake", "ring-necked snake", "eastern hog-nosed snake", "smooth green snake", "kingsnake", "garter snake", "water snake", "vine snake", "night snake", "boa constrictor", "African rock python", "Indian cobra", "green mamba", "sea snake", "Saharan horned viper", "eastern diamondback rattlesnake", "sidewinder rattlesnake", "trilobite", "harvestman", "scorpion", "yellow garden spider", "barn spider", "European garden spider", "southern black widow", "tarantula", "wolf spider", "tick", "centipede", "black grouse", "ptarmigan", "ruffed grouse", "prairie grouse", "peafowl", "quail", "partridge", "african grey parrot", "macaw", "sulphur-crested cockatoo", "lorikeet", "coucal", "bee eater", "hornbill", "hummingbird", "jacamar", "toucan", "duck", "red-breasted merganser", "goose", "black swan", "tusker", "echidna", "platypus", "wallaby", "koala", "wombat", "jellyfish", "sea anemone", "brain coral", "flatworm", "nematode", "conch", "snail", "slug", "sea slug", "chiton", "chambered nautilus", "Dungeness crab", "rock crab", "fiddler crab", "red king crab", "American lobster", "spiny lobster", "crayfish", "hermit crab", "isopod", "white stork", "black stork", "spoonbill", "flamingo", "little blue heron", "great egret", "bittern bird", "crane bird", "limpkin", "common gallinule", "American coot", "bustard", "ruddy turnstone", "dunlin", "common redshank", "dowitcher", "oystercatcher", "pelican", "king penguin", "albatross", "grey whale", "killer whale", "dugong", "sea lion", "Chihuahua", "Japanese Chin", "Maltese", "Pekingese", "Shih Tzu", "King Charles Spaniel", "Papillon", "toy terrier", "Rhodesian Ridgeback", "Afghan Hound", "Basset Hound", "Beagle", "Bloodhound", "Bluetick Coonhound", "Black and Tan Coonhound", "Treeing Walker Coonhound", "English foxhound", "Redbone Coonhound", "borzoi", "Irish Wolfhound", "Italian Greyhound", "Whippet", "Ibizan Hound", "Norwegian Elkhound", "Otterhound", "Saluki", "Scottish Deerhound", "Weimaraner", "Staffordshire Bull Terrier", "American Staffordshire Terrier", "Bedlington Terrier", "Border Terrier", "Kerry Blue Terrier", "Irish Terrier", "Norfolk Terrier", "Norwich Terrier", "Yorkshire Terrier", "Wire Fox Terrier", "Lakeland Terrier", "Sealyham Terrier", "Airedale Terrier", "Cairn Terrier", "Australian Terrier", "Dandie Dinmont Terrier", "Boston Terrier", "Miniature Schnauzer", "Giant Schnauzer", "Standard Schnauzer", "Scottish Terrier", "Tibetan Terrier", "Australian Silky Terrier", "Soft-coated Wheaten Terrier", "West Highland White Terrier", "Lhasa Apso", "Flat-Coated Retriever", "Curly-coated Retriever", "Golden Retriever", "Labrador Retriever", "Chesapeake Bay Retriever", "German Shorthaired Pointer", "Vizsla", "English Setter", "Irish Setter", "Gordon Setter", "Brittany dog", "Clumber Spaniel", "English Springer Spaniel", "Welsh Springer Spaniel", "Cocker Spaniel", "Sussex Spaniel", "Irish Water Spaniel", "Kuvasz", "Schipperke", "Groenendael dog", "Malinois", "Briard", "Australian Kelpie", "Komondor", "Old English Sheepdog", "Shetland Sheepdog", "collie", "Border Collie", "Bouvier des Flandres dog", "Rottweiler", "German Shepherd Dog", "Dobermann", "Miniature Pinscher", "Greater Swiss Mountain Dog", "Bernese Mountain Dog", "Appenzeller Sennenhund", "Entlebucher Sennenhund", "Boxer", "Bullmastiff", "Tibetan Mastiff", "French Bulldog", "Great Dane", "St. Bernard", "husky", "Alaskan Malamute", "Siberian Husky", "Dalmatian", "Affenpinscher", "Basenji", "pug", "Leonberger", "Newfoundland dog", "Great Pyrenees dog", "Samoyed", "Pomeranian", "Chow Chow", "Keeshond", "brussels griffon", "Pembroke Welsh Corgi", "Cardigan Welsh Corgi", "Toy Poodle", "Miniature Poodle", "Standard Poodle", "Mexican hairless dog (xoloitzcuintli)", "grey wolf", "Alaskan tundra wolf", "red wolf or maned wolf", "coyote", "dingo", "dhole", "African wild dog", "hyena", "red fox", "kit fox", "Arctic fox", "grey fox", "tabby cat", "tiger cat", "Persian cat", "Siamese cat", "Egyptian Mau", "cougar", "lynx", "leopard", "snow leopard", "jaguar", "lion", "tiger", "cheetah", "brown bear", "American black bear", "polar bear", "sloth bear", "mongoose", "meerkat", "tiger beetle", "ladybug", "ground beetle", "longhorn beetle", "leaf beetle", "dung beetle", "rhinoceros beetle", "weevil", "fly", "bee", "ant", "grasshopper", "cricket insect", "stick insect", "cockroach", "praying mantis", "cicada", "leafhopper", "lacewing", "dragonfly", "damselfly", "red admiral butterfly", "ringlet butterfly", "monarch butterfly", "small white butterfly", "sulphur butterfly", "gossamer-winged butterfly", "starfish", "sea urchin", "sea cucumber", "cottontail rabbit", "hare", "Angora rabbit", "hamster", "porcupine", "fox squirrel", "marmot", "beaver", "guinea pig", "common sorrel horse", "zebra", "pig", "wild boar", "warthog", "hippopotamus", "ox", "water buffalo", "bison", "ram (adult male sheep)", "bighorn sheep", "Alpine ibex", "hartebeest", "impala (antelope)", "gazelle", "arabian camel", "llama", "weasel", "mink", "European polecat", "black-footed ferret", "otter", "skunk", "badger", "armadillo", "three-toed sloth", "orangutan", "gorilla", "chimpanzee", "gibbon", "siamang", "guenon", "patas monkey", "baboon", "macaque", "langur", "black-and-white colobus", "proboscis monkey", "marmoset", "white-headed capuchin", "howler monkey", "titi monkey", "Geoffroy's spider monkey", "common squirrel monkey", "ring-tailed lemur", "indri", "Asian elephant", "African bush elephant", "red panda", "giant panda", "snoek fish", "eel", "silver salmon", "rock beauty fish", "clownfish", "sturgeon", "gar fish", "lionfish", "pufferfish", "abacus", "abaya", "academic gown", "accordion", "acoustic guitar", "aircraft carrier", "airliner", "airship", "altar", "ambulance", "amphibious vehicle", "analog clock", "apiary", "apron", "trash can", "assault rifle", "backpack", "bakery", "balance beam", "balloon", "ballpoint pen", "Band-Aid", "banjo", "baluster / handrail", "barbell", "barber chair", "barbershop", "barn", "barometer", "barrel", "wheelbarrow", "baseball", "basketball", "bassinet", "bassoon", "swimming cap", "bath towel", "bathtub", "station wagon", "lighthouse", "beaker", "military hat (bearskin or shako)", "beer bottle", "beer glass", "bell tower", "baby bib", "tandem bicycle", "bikini", "ring binder", "binoculars", "birdhouse", "boathouse", "bobsleigh", "bolo tie", "poke bonnet", "bookcase", "bookstore", "bottle cap", "hunting bow", "bow tie", "brass memorial plaque", "bra", "breakwater", "breastplate", "broom", "bucket", "buckle", "bulletproof vest", "high-speed train", "butcher shop", "taxicab", "cauldron", "candle", "cannon", "canoe", "can opener", "cardigan", "car mirror", "carousel", "tool kit", "cardboard box / carton", "car wheel", "automated teller machine", "cassette", "cassette player", "castle", "catamaran", "CD player", "cello", "mobile phone", "chain", "chain-link fence", "chain mail", "chainsaw", "storage chest", "chiffonier", "bell or wind chime", "china cabinet", "Christmas stocking", "church", "movie theater", "cleaver", "cliff dwelling", "cloak", "clogs", "cocktail shaker", "coffee mug", "coffeemaker", "spiral or coil", "combination lock", "computer keyboard", "candy store", "container ship", "convertible", "corkscrew", "cornet", "cowboy boot", "cowboy hat", "cradle", "construction crane", "crash helmet", "crate", "infant bed", "Crock Pot", "croquet ball", "crutch", "cuirass", "dam", "desk", "desktop computer", "rotary dial telephone", "diaper", "digital clock", "digital watch", "dining table", "dishcloth", "dishwasher", "disc brake", "dock", "dog sled", "dome", "doormat", "drilling rig", "drum", "drumstick", "dumbbell", "Dutch oven", "electric fan", "electric guitar", "electric locomotive", "entertainment center", "envelope", "espresso machine", "face powder", "feather boa", "filing cabinet", "fireboat", "fire truck", "fire screen", "flagpole", "flute", "folding chair", "football helmet", "forklift", "fountain", "fountain pen", "four-poster bed", "freight car", "French horn", "frying pan", "fur coat", "garbage truck", "gas mask or respirator", "gas pump", "goblet", "go-kart", "golf ball", "golf cart", "gondola", "gong", "gown", "grand piano", "greenhouse", "radiator grille", "grocery store", "guillotine", "hair clip", "hair spray", "half-track", "hammer", "hamper", "hair dryer", "hand-held computer", "handkerchief", "hard disk drive", "harmonica", "harp", "combine harvester", "hatchet", "holster", "home theater", "honeycomb", "hook", "hoop skirt", "gymnastic horizontal bar", "horse-drawn vehicle", "hourglass", "iPod", "clothes iron", "carved pumpkin", "jeans", "jeep", "T-shirt", "jigsaw puzzle", "rickshaw", "joystick", "kimono", "knee pad", "knot", "lab coat", "ladle", "lampshade", "laptop computer", "lawn mower", "lens cap", "letter opener", "library", "lifeboat", "lighter", "limousine", "ocean liner", "lipstick", "slip-on shoe", "lotion", "music speaker", "loupe magnifying glass", "sawmill", "magnetic compass", "messenger bag", "mailbox", "tights", "one-piece bathing suit", "manhole cover", "maraca", "marimba", "mask", "matchstick", "maypole", "maze", "measuring cup", "medicine cabinet", "megalith", "microphone", "microwave oven", "military uniform", "milk can", "minibus", "miniskirt", "minivan", "missile", "mitten", "mixing bowl", "mobile home", "ford model t", "modem", "monastery", "monitor", "moped", "mortar and pestle", "graduation cap", "mosque", "mosquito net", "vespa", "mountain bike", "tent", "computer mouse", "mousetrap", "moving van", "muzzle", "metal nail", "neck brace", "necklace", "baby pacifier", "notebook computer", "obelisk", "oboe", "ocarina", "odometer", "oil filter", "pipe organ", "oscilloscope", "overskirt", "bullock cart", "oxygen mask", "product packet / packaging", "paddle", "paddle wheel", "padlock", "paintbrush", "pajamas", "palace", "pan flute", "paper towel", "parachute", "parallel bars", "park bench", "parking meter", "railroad car", "patio", "payphone", "pedestal", "pencil case", "pencil sharpener", "perfume", "Petri dish", "photocopier", "plectrum", "Pickelhaube", "picket fence", "pickup truck", "pier", "piggy bank", "pill bottle", "pillow", "ping-pong ball", "pinwheel", "pirate ship", "drink pitcher", "block plane", "planetarium", "plastic bag", "plate rack", "farm plow", "plunger", "Polaroid camera", "pole", "police van", "poncho", "pool table", "soda bottle", "plant pot", "potter's wheel", "power drill", "prayer rug", "printer", "prison", "missile", "projector", "hockey puck", "punching bag", "purse", "quill", "quilt", "race car", "racket", "radiator", "radio", "radio telescope", "rain barrel", "recreational vehicle", "fishing casting reel", "reflex camera", "refrigerator", "remote control", "restaurant", "revolver", "rifle", "rocking chair", "rotisserie", "eraser", "rugby ball", "ruler measuring stick", "sneaker", "safe", "safety pin", "salt shaker", "sandal", "sarong", "saxophone", "scabbard", "weighing scale", "school bus", "schooner", "scoreboard", "CRT monitor", "screw", "screwdriver", "seat belt", "sewing machine", "shield", "shoe store", "shoji screen / room divider", "shopping basket", "shopping cart", "shovel", "shower cap", "shower curtain", "ski", "balaclava ski mask", "sleeping bag", "slide rule", "sliding door", "slot machine", "snorkel", "snowmobile", "snowplow", "soap dispenser", "soccer ball", "sock", "solar thermal collector", "sombrero", "soup bowl", "keyboard space bar", "space heater", "space shuttle", "spatula", "motorboat", "spider web", "spindle", "sports car", "spotlight", "stage", "steam locomotive", "through arch bridge", "steel drum", "stethoscope", "scarf", "stone wall", "stopwatch", "stove", "strainer", "tram", "stretcher", "couch", "stupa", "submarine", "suit", "sundial", "sunglasses", "sunglasses", "sunscreen", "suspension bridge", "mop", "sweatshirt", "swim trunks / shorts", "swing", "electrical switch", "syringe", "table lamp", "tank", "tape player", "teapot", "teddy bear", "television", "tennis ball", "thatched roof", "front curtain", "thimble", "threshing machine", "throne", "tile roof", "toaster", "tobacco shop", "toilet seat", "torch", "totem pole", "tow truck", "toy store", "tractor", "semi-trailer truck", "tray", "trench coat", "tricycle", "trimaran", "tripod", "triumphal arch", "trolleybus", "trombone", "hot tub", "turnstile", "typewriter keyboard", "umbrella", "unicycle", "upright piano", "vacuum cleaner", "vase", "vaulted or arched ceiling", "velvet fabric", "vending machine", "vestment", "viaduct", "violin", "volleyball", "waffle iron", "wall clock", "wallet", "wardrobe", "military aircraft", "sink", "washing machine", "water bottle", "water jug", "water tower", "whiskey jug", "whistle", "hair wig", "window screen", "window shade", "Windsor tie", "wine bottle", "airplane wing", "wok", "wooden spoon", "wool", "split-rail fence", "shipwreck", "sailboat", "yurt", "website", "comic book", "crossword", "traffic or street sign", "traffic light", "dust jacket", "menu", "plate", "guacamole", "consomme", "hot pot", "trifle", "ice cream", "popsicle", "baguette", "bagel", "pretzel", "cheeseburger", "hot dog", "mashed potatoes", "cabbage", "broccoli", "cauliflower", "zucchini", "spaghetti squash", "acorn squash", "butternut squash", "cucumber", "artichoke", "bell pepper", "cardoon", "mushroom", "Granny Smith apple", "strawberry", "orange", "lemon", "fig", "pineapple", "banana", "jackfruit", "cherimoya (custard apple)", "pomegranate", "hay", "carbonara", "chocolate syrup", "dough", "meatloaf", "pizza", "pot pie", "burrito", "red wine", "espresso", "tea cup", "eggnog", "mountain", "bubble", "cliff", "coral reef", "geyser", "lakeshore", "promontory", "sandbar", "beach", "valley", "volcano", "baseball player", "bridegroom", "scuba diver", "rapeseed", "daisy", "yellow lady's slipper", "corn", "acorn", "rose hip", "horse chestnut seed", "coral fungus", "agaric", "gyromitra", "stinkhorn mushroom", "earth star fungus", "hen of the woods mushroom", "bolete", "corn cob", "toilet paper"] \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_segmentation.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_segmentation.py new file mode 100644 index 0000000000000000000000000000000000000000..50501fa8da3f5a6c531640b21f2ab747c8de9f6c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/imagenet_segmentation.py @@ -0,0 +1,50 @@ +import os +import torch +import torch.utils.data as data +import numpy as np + +from torchvision.datasets import ImageNet + +from PIL import Image, ImageFilter +import h5py +from glob import glob + + +class ImagenetSegmentation(data.Dataset): + CLASSES = 2 + + def __init__(self, + path, + transform=None, + target_transform=None): + self.path = path + self.transform = transform + self.target_transform = target_transform + self.h5py = None + tmp = h5py.File(path, 'r') + self.data_length = len(tmp['/value/img']) + tmp.close() + del tmp + + def __getitem__(self, index): + + if self.h5py is None: + self.h5py = h5py.File(self.path, 'r') + + img = np.array(self.h5py[self.h5py['/value/img'][index, 0]]).transpose((2, 1, 0)) + target = np.array(self.h5py[self.h5py[self.h5py['/value/gt'][index, 0]][0, 0]]).transpose((1, 0)) + + img = Image.fromarray(img).convert('RGB') + target = Image.fromarray(target) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = np.array(self.target_transform(target)).astype('int32') + target = torch.from_numpy(target).long() + + return img, target + + def __len__(self): + return self.data_length diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/misc.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..515e352282201079e7545f1993d05a2bf401b1ac --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/misc.py @@ -0,0 +1,114 @@ +from itertools import repeat +import collections.abc + +import torch +from torch import nn as nn +from torchvision.ops.misc import FrozenBatchNorm2d + + +def freeze_batch_norm_2d(module, module_match={}, name=''): + """ + Converts all `BatchNorm2d` and `SyncBatchNorm` layers of provided module into `FrozenBatchNorm2d`. If `module` is + itself an instance of either `BatchNorm2d` or `SyncBatchNorm`, it is converted into `FrozenBatchNorm2d` and + returned. Otherwise, the module is walked recursively and submodules are converted in place. + + Args: + module (torch.nn.Module): Any PyTorch module. + module_match (dict): Dictionary of full module names to freeze (all if empty) + name (str): Full module name (prefix) + + Returns: + torch.nn.Module: Resulting module + + Inspired by https://github.com/pytorch/pytorch/blob/a5895f85be0f10212791145bfedc0261d364f103/torch/nn/modules/batchnorm.py#L762 + """ + res = module + is_match = True + if module_match: + is_match = name in module_match + if is_match and isinstance(module, (nn.modules.batchnorm.BatchNorm2d, nn.modules.batchnorm.SyncBatchNorm)): + res = FrozenBatchNorm2d(module.num_features) + res.num_features = module.num_features + res.affine = module.affine + if module.affine: + res.weight.data = module.weight.data.clone().detach() + res.bias.data = module.bias.data.clone().detach() + res.running_mean.data = module.running_mean.data + res.running_var.data = module.running_var.data + res.eps = module.eps + else: + for child_name, child in module.named_children(): + full_child_name = '.'.join([name, child_name]) if name else child_name + new_child = freeze_batch_norm_2d(child, module_match, full_child_name) + if new_child is not child: + res.add_module(child_name, new_child) + return res + + +# From PyTorch internals +def _ntuple(n): + def parse(x): + if isinstance(x, collections.abc.Iterable): + return x + return tuple(repeat(x, n)) + return parse + + +to_1tuple = _ntuple(1) +to_2tuple = _ntuple(2) +to_3tuple = _ntuple(3) +to_4tuple = _ntuple(4) +to_ntuple = lambda n, x: _ntuple(n)(x) + +# Replaces all linear layers with linear_replacement +# TODO: add int8 support for other linear layers including attn and convnets +def replace_linear(model, linear_replacement, include_modules=['c_fc', 'c_proj'], copy_weights=True): + for name, module in model.named_children(): + if len(list(module.children())) > 0: + replace_linear(module, linear_replacement, include_modules, copy_weights) + + if isinstance(module, torch.nn.Linear) and name in include_modules: + old_module = model._modules[name] + model._modules[name] = linear_replacement( + module.in_features, + module.out_features, + module.bias is not None, + ) + if copy_weights: + model._modules[name].weight.data.copy_(old_module.weight.data) + if model._modules[name].bias is not None: + model._modules[name].bias.data.copy_(old_module.bias) + + return model + +def convert_int8_model_to_inference_mode(model): + for m in model.modules(): + if hasattr(m, 'prepare_for_eval'): + int8_original_dtype = m.weight.dtype + m.prepare_for_eval() + m.int8_original_dtype = int8_original_dtype + + +def accuracy(output, target, topk=(1,)): + """ + Compute top-k accuracy + + output: torch.Tensor + shape (N, C) where N is the number of examples, C the number of classes. + these are the logits. + + target: torch.Tensor + shape (N,) where N is the number of examples. Groundtruth class id of each example. + + topk: tuple + which topk to compute, e.g., topk=(1,5) will compute top-1 and top-5 accuracies + + Returns + ------- + + list of top-k accuracies in the same order as `topk` + """ + pred = output.topk(max(topk), 1, True, True)[1].t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + n = len(target) + return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) / n for k in topk] diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model.py new file mode 100644 index 0000000000000000000000000000000000000000..75142e2ef8c9cadc9cf1c3d6aa516cf74dd9034d --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model.py @@ -0,0 +1,407 @@ +""" CLIP Model + +Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" +from dataclasses import dataclass +import logging +import math +from typing import Optional, Tuple, Union, Text + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn +from torch.utils.checkpoint import checkpoint + + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.modified_resnet import ModifiedResNet +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.timm_model import TimmModel +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.transformer import LayerNorm, QuickGELU, VisionTransformer, TextTransformer, Attention +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import to_2tuple +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.hook import HookManager + + +@dataclass +class CLIPVisionCfg: + layers: Union[Tuple[int, int, int, int], int] = 12 + width: int = 768 + head_width: int = 64 + mlp_ratio: float = 4.0 + patch_size: int = 16 + image_size: Union[Tuple[int, int], int] = 224 + + ls_init_value: Optional[float] = None # layer scale initial value + patch_dropout: float = 0. # what fraction of patches to dropout during training (0 would mean disabled and no patches dropped) - 0.5 to 0.75 recommended in the paper for optimal results + input_patchnorm: bool = False # whether to use dual patchnorm - would only apply the input layernorm on each patch, as post-layernorm already exist in original clip vit design + global_average_pool: bool = False # whether to global average pool the last embedding layer, instead of using CLS token (https://arxiv.org/abs/2205.01580) + attentional_pool: bool = False # whether to use attentional pooler in the last embedding layer + n_queries: int = 256 # n_queries for attentional pooler + attn_pooler_heads: int = 8 # n heads for attentional_pooling + output_tokens: bool = False + + timm_model_name: str = None # a valid model name overrides layers, width, patch_size + timm_model_pretrained: bool = False # use (imagenet) pretrained weights for named model + timm_pool: str = 'avg' # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '') + timm_proj: str = 'linear' # linear projection for timm model output ('linear', 'mlp', '') + timm_proj_bias: bool = False # enable bias final projection + timm_drop: float = 0. # head dropout + timm_drop_path: Optional[float] = None # backbone stochastic depth + + + + +def convert_weights_to_lp(model: nn.Module, dtype=torch.float16): + """Convert applicable model parameters to low-precision (bf16 or fp16)""" + + def _convert_weights(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.to(dtype) + if l.bias is not None: + l.bias.data = l.bias.data.to(dtype) + + if isinstance(l, (nn.MultiheadAttention, Attention)): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.to(dtype) + + if isinstance(l, (CLIP, TextTransformer)): + # convert text nn.Parameter projections + attr = getattr(l, "text_projection", None) + if attr is not None: + attr.data = attr.data.to(dtype) + + if isinstance(l, VisionTransformer): + # convert vision nn.Parameter projections + attr = getattr(l, "proj", None) + if attr is not None: + attr.data = attr.data.to(dtype) + + model.apply(_convert_weights) + +convert_weights_to_fp16 = convert_weights_to_lp # backwards compat + + +@dataclass +class CLIPTextCfg: + context_length: int = 77 + vocab_size: int = 49408 + width: int = 512 + heads: int = 8 + layers: int = 12 + ls_init_value: Optional[float] = None # layer scale initial value + hf_model_name: str = None + hf_tokenizer_name: str = None + hf_model_pretrained: bool = True + proj: str = 'mlp' + pooler_type: str = 'mean_pooler' + embed_cls: bool = False + pad_id: int = 0 + output_tokens: bool = False + + +def get_cast_dtype(precision: str): + cast_dtype = None + if precision == 'bf16': + cast_dtype = torch.bfloat16 + elif precision == 'fp16': + cast_dtype = torch.float16 + return cast_dtype + + +def get_input_dtype(precision: str): + input_dtype = None + if precision in ('bf16', 'pure_bf16'): + input_dtype = torch.bfloat16 + elif precision in ('fp16', 'pure_fp16'): + input_dtype = torch.float16 + return input_dtype + + +def _build_vision_tower( + embed_dim: int, + vision_cfg: CLIPVisionCfg, + quick_gelu: bool = False, + cast_dtype: Optional[torch.dtype] = None, + hook: Optional[HookManager]= None, +): + if isinstance(vision_cfg, dict): + vision_cfg = CLIPVisionCfg(**vision_cfg) + + # OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more + # memory efficient in recent PyTorch releases (>= 1.10). + # NOTE: timm models always use native GELU regardless of quick_gelu flag. + act_layer = QuickGELU if quick_gelu else nn.GELU + + if vision_cfg.timm_model_name: + visual = TimmModel( + vision_cfg.timm_model_name, + pretrained=vision_cfg.timm_model_pretrained, + pool=vision_cfg.timm_pool, + proj=vision_cfg.timm_proj, + proj_bias=vision_cfg.timm_proj_bias, + drop=vision_cfg.timm_drop, + drop_path=vision_cfg.timm_drop_path, + patch_drop=vision_cfg.patch_dropout if vision_cfg.patch_dropout > 0 else None, + embed_dim=embed_dim, + image_size=vision_cfg.image_size, + hook=hook, + ) + elif isinstance(vision_cfg.layers, (tuple, list)): + vision_heads = vision_cfg.width * 32 // vision_cfg.head_width + visual = ModifiedResNet( + layers=vision_cfg.layers, + output_dim=embed_dim, + heads=vision_heads, + image_size=vision_cfg.image_size, + width=vision_cfg.width, + hook=hook, + ) + else: + vision_heads = vision_cfg.width // vision_cfg.head_width + norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm + visual = VisionTransformer( + image_size=vision_cfg.image_size, + patch_size=vision_cfg.patch_size, + width=vision_cfg.width, + layers=vision_cfg.layers, + heads=vision_heads, + mlp_ratio=vision_cfg.mlp_ratio, + ls_init_value=vision_cfg.ls_init_value, + patch_dropout=vision_cfg.patch_dropout, + input_patchnorm=vision_cfg.input_patchnorm, + global_average_pool=vision_cfg.global_average_pool, + attentional_pool=vision_cfg.attentional_pool, + n_queries=vision_cfg.n_queries, + attn_pooler_heads=vision_cfg.attn_pooler_heads, + output_tokens=vision_cfg.output_tokens, + output_dim=embed_dim, + act_layer=act_layer, + norm_layer=norm_layer, + hook=hook, + ) + + return visual + + +def _build_text_tower( + embed_dim: int, + text_cfg: CLIPTextCfg, + quick_gelu: bool = False, + cast_dtype: Optional[torch.dtype] = None, + hook: Optional[HookManager] = None, +): + if isinstance(text_cfg, dict): + text_cfg = CLIPTextCfg(**text_cfg) + + if text_cfg.hf_model_name: + from hf_model import HFTextEncoder + text = HFTextEncoder( + text_cfg.hf_model_name, + output_dim=embed_dim, + proj=text_cfg.proj, + pooler_type=text_cfg.pooler_type, + pretrained=text_cfg.hf_model_pretrained, + output_tokens=text_cfg.output_tokens, + ) + else: + act_layer = QuickGELU if quick_gelu else nn.GELU + norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm + + text = TextTransformer( + context_length=text_cfg.context_length, + vocab_size=text_cfg.vocab_size, + width=text_cfg.width, + heads=text_cfg.heads, + layers=text_cfg.layers, + ls_init_value=text_cfg.ls_init_value, + output_dim=embed_dim, + embed_cls=text_cfg.embed_cls, + output_tokens=text_cfg.output_tokens, + pad_id=text_cfg.pad_id, + act_layer=act_layer, + norm_layer=norm_layer, + ) + return text + + +class CLIP(nn.Module): + output_dict: torch.jit.Final[bool] + + def __init__( + self, + embed_dim: int, + vision_cfg: CLIPVisionCfg, + text_cfg: CLIPTextCfg, + quick_gelu: bool = False, + cast_dtype: Optional[torch.dtype] = None, + output_dict: bool = False, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook_manager = hook or HookManager() + self.output_dict = output_dict + self.visual = _build_vision_tower(embed_dim, vision_cfg, quick_gelu, cast_dtype, self.hook_manager.fork('visual')) + + text = _build_text_tower(embed_dim, text_cfg, quick_gelu, cast_dtype, self.hook_manager.fork('textual')) + self.transformer = text.transformer + self.context_length = text.context_length + self.vocab_size = text.vocab_size + self.token_embedding = text.token_embedding + self.positional_embedding = text.positional_embedding + self.ln_final = text.ln_final + self.text_projection = text.text_projection + self.register_buffer('attn_mask', text.attn_mask, persistent=False) + + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.visual.set_grad_checkpointing(enable) + self.transformer.grad_checkpointing = enable + + def encode_image(self, image, normalize: bool = False, attn_method: Text = 'direct'): + features = self.visual(image, attn_method=attn_method) + return F.normalize(features, dim=-1) if normalize else features + + def encode_text(self, text, normalize: bool = False): + cast_dtype = self.transformer.get_cast_dtype() + + x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.to(cast_dtype) + # x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x, attn_mask=self.attn_mask) + # x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x) # [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + return F.normalize(x, dim=-1) if normalize else x + + def forward( + self, + image: Optional[torch.Tensor] = None, + text: Optional[torch.Tensor] = None, + ): + image_features = self.encode_image(image, normalize=True) if image is not None else None + text_features = self.encode_text(text, normalize=True) if text is not None else None + if self.output_dict: + return { + "image_features": image_features, + "text_features": text_features, + "logit_scale": self.logit_scale.exp() + } + return image_features, text_features, self.logit_scale.exp() + + +# used to maintain checkpoint compatibility +def convert_to_custom_text_state_dict(state_dict: dict): + if 'text_projection' in state_dict: + # old format state_dict, move text tower -> .text + new_state_dict = {} + for k, v in state_dict.items(): + if any(k.startswith(p) for p in ( + 'text_projection', + 'positional_embedding', + 'token_embedding', + 'transformer', + 'ln_final', + )): + k = 'text.' + k + new_state_dict[k] = v + return new_state_dict + return state_dict + + +def build_model_from_openai_state_dict( + state_dict: dict, + quick_gelu=True, + cast_dtype=torch.float16, +): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len( + [k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_size = vision_patch_size * grid_size + else: + counts: list = [ + len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_size = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks"))) + + vision_cfg = CLIPVisionCfg( + layers=vision_layers, + width=vision_width, + patch_size=vision_patch_size, + image_size=image_size, + ) + text_cfg = CLIPTextCfg( + context_length=context_length, + vocab_size=vocab_size, + width=transformer_width, + heads=transformer_heads, + layers=transformer_layers, + ) + model = CLIP( + embed_dim, + vision_cfg=vision_cfg, + text_cfg=text_cfg, + quick_gelu=quick_gelu, # OpenAI models were trained with QuickGELU + cast_dtype=cast_dtype, + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + state_dict.pop(key, None) + + convert_weights_to_fp16(model) # OpenAI state dicts are partially converted to float16 + model.load_state_dict(state_dict) + return model.eval() + + +def resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', antialias: bool = True): + # Rescale the grid of position embeddings when loading from state_dict + old_pos_embed = state_dict.get('visual.positional_embedding', None) + if old_pos_embed is None or not hasattr(model.visual, 'grid_size'): + return + grid_size = to_2tuple(model.visual.grid_size) + extra_tokens = 1 # FIXME detect different token configs (ie no class token, or more) + new_seq_len = grid_size[0] * grid_size[1] + extra_tokens + if new_seq_len == old_pos_embed.shape[0]: + return + + if extra_tokens: + pos_emb_tok, pos_emb_img = old_pos_embed[:extra_tokens], old_pos_embed[extra_tokens:] + else: + pos_emb_tok, pos_emb_img = None, old_pos_embed + old_grid_size = to_2tuple(int(math.sqrt(len(pos_emb_img)))) + + logging.info('Resizing position embedding grid-size from %s to %s', old_grid_size, grid_size) + pos_emb_img = pos_emb_img.reshape(1, old_grid_size[0], old_grid_size[1], -1).permute(0, 3, 1, 2) + pos_emb_img = F.interpolate( + pos_emb_img, + size=grid_size, + mode=interpolation, + antialias=antialias, + align_corners=False, + ) + pos_emb_img = pos_emb_img.permute(0, 2, 3, 1).reshape(1, grid_size[0] * grid_size[1], -1)[0] + if pos_emb_tok is not None: + new_pos_embed = torch.cat([pos_emb_tok, pos_emb_img], dim=0) + else: + new_pos_embed = pos_emb_img + state_dict['visual.positional_embedding'] = new_pos_embed \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14-plus.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..73f46a71e664fce987218b8eb48903e7bd895f41 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14-plus.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva_giant_patch14_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14.json new file mode 100644 index 0000000000000000000000000000000000000000..9d0e80f290d9491b7c46fafd576201b1258165aa --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA01-g-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva_giant_patch14_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-B-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-B-16.json new file mode 100644 index 0000000000000000000000000000000000000000..3f92357287e1f6600da1e7f391cb6370d7f66de4 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-B-16.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva02_base_patch16_clip_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14-plus.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..e250c2a404c86ff168c54cfcf71bc2492be1b74c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14-plus.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva02_enormous_patch14_clip_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14.json new file mode 100644 index 0000000000000000000000000000000000000000..4b6648e25092b151a9095e0a66956c7ebf835b16 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-E-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva02_enormous_patch14_clip_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14-336.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14-336.json new file mode 100644 index 0000000000000000000000000000000000000000..2bb07f3c082fd88c4e86131b272163aaacfaef9e --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14-336.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 336, + "timm_model_name": "eva02_large_patch14_clip_336", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14.json new file mode 100644 index 0000000000000000000000000000000000000000..b4c7f377bc543aa92a145358f2630a58ae9be989 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/EVA02-L-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "timm_model_name": "eva02_large_patch14_clip_224", + "timm_model_pretrained": false, + "timm_pool": "token", + "timm_proj": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus-240.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus-240.json new file mode 100644 index 0000000000000000000000000000000000000000..5bbd12bcd01f64d6d0a0aa8316b129327a0d169a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus-240.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 240, + "layers": 12, + "width": 896, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..5dc1e09baccef2b15055c1bffeb9903e760101c6 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16-plus.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 896, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16.json new file mode 100644 index 0000000000000000000000000000000000000000..395eea77ec3907c0611531aba63459b193e67b9c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-plus-256.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-plus-256.json new file mode 100644 index 0000000000000000000000000000000000000000..2f09c857de9a4c01ae51297a7e2451984879f9de --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-plus-256.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 256, + "layers": 12, + "width": 896, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-quickgelu.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-quickgelu.json new file mode 100644 index 0000000000000000000000000000000000000000..ce6bd923593293ed50dfcfb28b73ca7403bcf3c5 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32-quickgelu.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..07c8e28eb06fa1813ba932fe4eec668262d1c47f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-B-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-14.json new file mode 100644 index 0000000000000000000000000000000000000000..3e3a7e934e7f02e41f4829996c4950e05f015a74 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-14.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-16.json new file mode 100644 index 0000000000000000000000000000000000000000..588485455fdf8193ec16474450b94e31c91ea93c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-H-16.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-280.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-280.json new file mode 100644 index 0000000000000000000000000000000000000000..2262deaefa82792d35d73c0d7c8e620525092581 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-280.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 280, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-336.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-336.json new file mode 100644 index 0000000000000000000000000000000000000000..8d1f74c2639c3a3705df9865b9c08215675ddc97 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14-336.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 336, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14.json new file mode 100644 index 0000000000000000000000000000000000000000..d4a4bbb1dd4ed4edb317d3ace4f3ad13b211c241 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-14.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16-320.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16-320.json new file mode 100644 index 0000000000000000000000000000000000000000..fc2d13ca9ec7f0b56a886ddaf66c4a7ba7a442ba --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16-320.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 320, + "layers": 24, + "width": 1024, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16.json new file mode 100644 index 0000000000000000000000000000000000000000..82a1cedfa290adacbbdc02bc5d589734c22d41d3 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-L-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16-alt.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16-alt.json new file mode 100644 index 0000000000000000000000000000000000000000..1a317aad8e02d9c26d2decc7cc49a18dfdf9e0d8 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16-alt.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 384, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 512, + "patch_size": 16, + "ls_init_value": 1e-4 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 384, + "heads": 6, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16.json new file mode 100644 index 0000000000000000000000000000000000000000..f2f3225a46e09237730a151d161f70c86b985172 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 512, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32-alt.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32-alt.json new file mode 100644 index 0000000000000000000000000000000000000000..fd222aeac0f582ef6a1a33f1b3fec70a5b386ac0 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32-alt.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 384, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 512, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 384, + "heads": 6, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32.json new file mode 100644 index 0000000000000000000000000000000000000000..4f718642821035d9776d1e006817d65ede074366 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-M-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 512, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16-alt.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16-alt.json new file mode 100644 index 0000000000000000000000000000000000000000..a8c056555e4da3ba0d1475a61fc316362ecce76f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16-alt.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 256, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 384, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 256, + "heads": 4, + "layers": 10 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16.json new file mode 100644 index 0000000000000000000000000000000000000000..1d8504e59658803f3093e5b05de45f30a09b8185 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-16.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 384, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 384, + "patch_size": 16 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 384, + "heads": 6, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32-alt.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32-alt.json new file mode 100644 index 0000000000000000000000000000000000000000..e1dfdec9824df09a2010e991ccfa1d9ee2f45807 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32-alt.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 256, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 384, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 256, + "heads": 4, + "layers": 10 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32.json new file mode 100644 index 0000000000000000000000000000000000000000..9b8b4191b268de267268cfcb90fc01c6b9df07d8 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-S-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 384, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 384, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 384, + "heads": 6, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-bigG-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-bigG-14.json new file mode 100644 index 0000000000000000000000000000000000000000..2cfba479a2e8f3737e71ce240732bf3bc743d8b7 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-bigG-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1280, + "vision_cfg": { + "image_size": 224, + "layers": 48, + "width": 1664, + "head_width": 104, + "mlp_ratio": 4.9231, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-e-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-e-14.json new file mode 100644 index 0000000000000000000000000000000000000000..91a0fe14d25a107fb8ec48dd7faae313fd26ed7b --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-e-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1280, + "vision_cfg": { + "image_size": 224, + "layers": 56, + "width": 1792, + "head_width": 112, + "mlp_ratio": 8.5715, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 36 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-g-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-g-14.json new file mode 100644 index 0000000000000000000000000000000000000000..8c4b7325cc75b6112be7107d36ae2cb5762d9091 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/ViT-g-14.json @@ -0,0 +1,18 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 40, + "width": 1408, + "head_width": 88, + "mlp_ratio": 4.3637, + "patch_size": 14 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..7e7eb520a6a0096e5602d509ecd6186e278f4725 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-B-32.json @@ -0,0 +1,30 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32, + "attentional_pool": true, + "attn_pooler_heads": 8, + "output_tokens": true + }, + "text_cfg": { + "context_length": 76, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12, + "embed_cls": true, + "output_tokens": true + }, + "multimodal_cfg": { + "context_length": 76, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12, + "attn_pooler_heads": 8 + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-L-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-L-14.json new file mode 100644 index 0000000000000000000000000000000000000000..3d5ca4ca2338540f06852df5ff35ea6277e64555 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_ViT-L-14.json @@ -0,0 +1,30 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "patch_size": 14, + "attentional_pool": true, + "attn_pooler_heads": 8, + "output_tokens": true + }, + "text_cfg": { + "context_length": 76, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12, + "embed_cls": true, + "output_tokens": true + }, + "multimodal_cfg": { + "context_length": 76, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12, + "attn_pooler_heads": 12 + }, + "custom_text": true +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_base.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_base.json new file mode 100644 index 0000000000000000000000000000000000000000..cf8c6cecb78a49d7e7140145a0307cbd561077c2 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_base.json @@ -0,0 +1,31 @@ +{ + "embed_dim": 512, + "multimodal_cfg": { + "width": 768, + "context_length": 76, + "vocab_size": 64000, + "mlp_ratio": 4, + "layers": 12, + "dim_head": 64, + "heads": 12, + "n_queries": 256, + "attn_pooler_heads": 8 + }, + "vision_cfg": { + "image_size": 288, + "layers": 12, + "width": 768, + "patch_size": 18, + "output_tokens": true + }, + "text_cfg": { + "context_length": 76, + "vocab_size": 64000, + "layers": 12, + "heads": 12, + "width": 768, + "embed_cls": true, + "output_tokens": true + }, + "custom_text": true +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_roberta-ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_roberta-ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..fb46354b95a17a46d7fcfd9d504e917ee6c1608c --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/coca_roberta-ViT-B-32.json @@ -0,0 +1,24 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32, + "output_tokens": true + }, + "text_cfg": { + "hf_model_name": "roberta-base", + "hf_tokenizer_name": "roberta-base", + "proj": "linear", + "width": 768, + "output_tokens": true + }, + "multimodal_cfg": { + "context_length": 76, + "width": 768, + "heads": 8, + "layers": 12 + }, + "custom_text": true +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-base-ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-base-ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..58cad89cf0f446bbe15e4e25b1ac43424a828017 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-base-ViT-B-32.json @@ -0,0 +1,15 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "hf_model_name": "google/mt5-base", + "hf_tokenizer_name": "google/mt5-base", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-xl-ViT-H-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-xl-ViT-H-14.json new file mode 100644 index 0000000000000000000000000000000000000000..b432810777ba7269dbb0e89edfe65cdd27e7d255 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/mt5-xl-ViT-H-14.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 14 + }, + "text_cfg": { + "hf_model_name": "google/mt5-xl", + "hf_tokenizer_name": "google/mt5-xl", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/roberta-ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/roberta-ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..ed687d472a73bb2ac96025f355f80437ab14c260 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/roberta-ViT-B-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 512, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "hf_model_name": "roberta-base", + "hf_tokenizer_name": "roberta-base", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/swin_base_patch4_window7_224.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/swin_base_patch4_window7_224.json new file mode 100644 index 0000000000000000000000000000000000000000..bd6820f0cf2aa655e0a2723287f4b78895a58e6a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/swin_base_patch4_window7_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "timm_model_name": "swin_base_patch4_window7_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_medium_patch16_gap_256.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_medium_patch16_gap_256.json new file mode 100644 index 0000000000000000000000000000000000000000..8843eaf08cad16c3e7b5f496fd650715c9573f65 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_medium_patch16_gap_256.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "vit_medium_patch16_gap_256", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 256 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_relpos_medium_patch16_cls_224.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_relpos_medium_patch16_cls_224.json new file mode 100644 index 0000000000000000000000000000000000000000..ed217b202d5e6071c5307f4547c97ff4cfe2abd1 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/vit_relpos_medium_patch16_cls_224.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "timm_model_name": "vit_relpos_medium_patch16_cls_224", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "linear", + "image_size": 224 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-base-ViT-B-32.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-base-ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..751bccc2c6fc41bc4ff20182de88d86739d518d9 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-base-ViT-B-32.json @@ -0,0 +1,15 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "hf_model_name": "xlm-roberta-base", + "hf_tokenizer_name": "xlm-roberta-base", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-large-ViT-H-14.json b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-large-ViT-H-14.json new file mode 100644 index 0000000000000000000000000000000000000000..31f271faa9bbb7a9da53900b483a4c00a16f3c4a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/model_configs/xlm-roberta-large-ViT-H-14.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 1280, + "head_width": 80, + "patch_size": 14 + }, + "text_cfg": { + "hf_model_name": "xlm-roberta-large", + "hf_tokenizer_name": "xlm-roberta-large", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/modified_resnet.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/modified_resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..51e1b059a892fc5b2faff07ace267435cd68b5d8 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/modified_resnet.py @@ -0,0 +1,181 @@ +from collections import OrderedDict + +import torch +from torch import nn +from torch.nn import functional as F + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import freeze_batch_norm_2d + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.act1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.act2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.act3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.act1(self.bn1(self.conv1(x))) + out = self.act2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.act3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x, key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0., + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + + return x[0] + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, image_size=224, width=64): + super().__init__() + self.output_dim = output_dim + self.image_size = image_size + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.act1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.act2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.act3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(image_size // 32, embed_dim, heads, output_dim) + + self.init_parameters() + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def init_parameters(self): + if self.attnpool is not None: + std = self.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.layer1, self.layer2, self.layer3, self.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + assert unlocked_groups == 0, 'partial locking not currently supported for this model' + for param in self.parameters(): + param.requires_grad = False + if freeze_bn_stats: + freeze_batch_norm_2d(self) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + # FIXME support for non-transformer + pass + + def stem(self, x): + x = self.act1(self.bn1(self.conv1(x))) + x = self.act2(self.bn2(self.conv2(x))) + x = self.act3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + def forward(self, x): + x = self.stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_models.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_models.py new file mode 100644 index 0000000000000000000000000000000000000000..ea0720d3c48b9b0e391c697e593547e011b43569 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_models.py @@ -0,0 +1,90 @@ +""" OpenAI pretrained model functions + +Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" + +import os +import warnings +from typing import List, Optional, Union + +import torch + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.model import build_model_from_openai_state_dict, get_cast_dtype +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.pretrained import * + +__all__ = ["list_openai_models", "load_openai_model"] + + +def list_openai_models() -> List[str]: + """Returns the names of available CLIP models""" + return list_pretrained_models_by_tag('openai') + + +def load_openai_model( + name: str, + precision: Optional[str] = None, + device: Optional[Union[str, torch.device]] = None, + cache_dir: Optional[str] = None, +): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + precision: str + Model precision, if None defaults to 'fp32' if device == 'cpu' else 'fp16'. + device : Union[str, torch.device] + The device to put the loaded model + cache_dir : Optional[str] + The directory to cache the downloaded model weights + + Returns + ------- + model : torch.nn.Module + The CLIP model + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if device is None: + device = "cuda" if torch.cuda.is_available() else "cpu" + if precision is None: + precision = 'fp32' if device == 'cpu' else 'fp16' + + if get_pretrained_url(name, 'openai'): + model_path = download_pretrained_from_url(get_pretrained_url(name, 'openai'), cache_dir=cache_dir) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {list_openai_models()}") + + try: + # loading JIT archive + model = torch.jit.load(model_path, map_location="cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + state_dict = torch.load(model_path, map_location="cpu") + + # Build a non-jit model from the OpenAI jitted model state dict + cast_dtype = get_cast_dtype(precision) + try: + model = build_model_from_openai_state_dict(state_dict or model.state_dict(), cast_dtype=cast_dtype) + except KeyError: + sd = {k[7:]: v for k, v in state_dict["state_dict"].items()} + model = build_model_from_openai_state_dict(sd, cast_dtype=cast_dtype) + + # model from OpenAI state dict is in manually cast fp16 mode, must be converted for AMP/fp32/bf16 use + model = model.to(device) + # FIXME support pure fp16/bf16 precision modes + if precision != 'fp16': + model.float() + if precision == 'bf16': + # for bf16, convert back to low-precision + convert_weights_to_lp(model, dtype=torch.bfloat16) + + # add mean / std attributes for consistency with OpenCLIP models + model.visual.image_mean = OPENAI_DATASET_MEAN + model.visual.image_std = OPENAI_DATASET_STD + return model \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_templates.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_templates.py new file mode 100644 index 0000000000000000000000000000000000000000..66d9faa9bd814967266c7edf41ccc258a182b1c7 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/openai_templates.py @@ -0,0 +1,84 @@ + +OPENAI_IMAGENET_TEMPLATES = ( + lambda c: f'a bad photo of a {c}.', + lambda c: f'a photo of many {c}.', + lambda c: f'a sculpture of a {c}.', + lambda c: f'a photo of the hard to see {c}.', + lambda c: f'a low resolution photo of the {c}.', + lambda c: f'a rendering of a {c}.', + lambda c: f'graffiti of a {c}.', + lambda c: f'a bad photo of the {c}.', + lambda c: f'a cropped photo of the {c}.', + lambda c: f'a tattoo of a {c}.', + lambda c: f'the embroidered {c}.', + lambda c: f'a photo of a hard to see {c}.', + lambda c: f'a bright photo of a {c}.', + lambda c: f'a photo of a clean {c}.', + lambda c: f'a photo of a dirty {c}.', + lambda c: f'a dark photo of the {c}.', + lambda c: f'a drawing of a {c}.', + lambda c: f'a photo of my {c}.', + lambda c: f'the plastic {c}.', + lambda c: f'a photo of the cool {c}.', + lambda c: f'a close-up photo of a {c}.', + lambda c: f'a black and white photo of the {c}.', + lambda c: f'a painting of the {c}.', + lambda c: f'a painting of a {c}.', + lambda c: f'a pixelated photo of the {c}.', + lambda c: f'a sculpture of the {c}.', + lambda c: f'a bright photo of the {c}.', + lambda c: f'a cropped photo of a {c}.', + lambda c: f'a plastic {c}.', + lambda c: f'a photo of the dirty {c}.', + lambda c: f'a jpeg corrupted photo of a {c}.', + lambda c: f'a blurry photo of the {c}.', + lambda c: f'a photo of the {c}.', + lambda c: f'a good photo of the {c}.', + lambda c: f'a rendering of the {c}.', + lambda c: f'a {c} in a video game.', + lambda c: f'a photo of one {c}.', + lambda c: f'a doodle of a {c}.', + lambda c: f'a close-up photo of the {c}.', + lambda c: f'a photo of a {c}.', + lambda c: f'the origami {c}.', + lambda c: f'the {c} in a video game.', + lambda c: f'a sketch of a {c}.', + lambda c: f'a doodle of the {c}.', + lambda c: f'a origami {c}.', + lambda c: f'a low resolution photo of a {c}.', + lambda c: f'the toy {c}.', + lambda c: f'a rendition of the {c}.', + lambda c: f'a photo of the clean {c}.', + lambda c: f'a photo of a large {c}.', + lambda c: f'a rendition of a {c}.', + lambda c: f'a photo of a nice {c}.', + lambda c: f'a photo of a weird {c}.', + lambda c: f'a blurry photo of a {c}.', + lambda c: f'a cartoon {c}.', + lambda c: f'art of a {c}.', + lambda c: f'a sketch of the {c}.', + lambda c: f'a embroidered {c}.', + lambda c: f'a pixelated photo of a {c}.', + lambda c: f'itap of the {c}.', + lambda c: f'a jpeg corrupted photo of the {c}.', + lambda c: f'a good photo of a {c}.', + lambda c: f'a plushie {c}.', + lambda c: f'a photo of the nice {c}.', + lambda c: f'a photo of the small {c}.', + lambda c: f'a photo of the weird {c}.', + lambda c: f'the cartoon {c}.', + lambda c: f'art of the {c}.', + lambda c: f'a drawing of the {c}.', + lambda c: f'a photo of the large {c}.', + lambda c: f'a black and white photo of a {c}.', + lambda c: f'the plushie {c}.', + lambda c: f'a dark photo of a {c}.', + lambda c: f'itap of a {c}.', + lambda c: f'graffiti of the {c}.', + lambda c: f'a toy {c}.', + lambda c: f'itap of my {c}.', + lambda c: f'a photo of a cool {c}.', + lambda c: f'a photo of a small {c}.', + lambda c: f'a tattoo of the {c}.', +) + diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/pretrained.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/pretrained.py new file mode 100644 index 0000000000000000000000000000000000000000..48567fd1a46147c5c0c091a8731bd430042bd3cc --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/pretrained.py @@ -0,0 +1,426 @@ +import hashlib +import os +import urllib +import warnings +from functools import partial +from typing import Dict, Union + +from tqdm import tqdm + + +try: + from huggingface_hub import hf_hub_download + hf_hub_download = partial(hf_hub_download, library_name="open_clip", library_version='2.20.0') + _has_hf_hub = True +except ImportError: + hf_hub_download = None + _has_hf_hub = False + + +def _pcfg(url='', hf_hub='', mean=None, std=None): + return dict( + url=url, + hf_hub=hf_hub, + mean=mean, + std=std, + ) + + +_RN50 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-yfcc15m-455df137.pt"), + cc12m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-cc12m-f000538c.pt"), +) + +_RN50_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-yfcc15m-455df137.pt"), + cc12m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn50-quickgelu-cc12m-f000538c.pt"), +) + +_RN101 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn101-quickgelu-yfcc15m-3e04b30e.pt"), +) + +_RN101_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt"), + yfcc15m=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/rn101-quickgelu-yfcc15m-3e04b30e.pt"), +) + +_RN50x4 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt"), +) + +_RN50x16 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt"), +) + +_RN50x64 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt"), +) + +_VITB32 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e31-d867053b.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e32-46683a32.pt"), + laion2b_e16=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-laion2b_e16-af8dbd0c.pth"), + laion2b_s34b_b79k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-laion2B-s34B-b79K/'), + # DataComp-M models + datacomp_m_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-DataComp.M-s128M-b4K/'), + commonpool_m_clip_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M.clip-s128M-b4K/'), + commonpool_m_laion_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M.laion-s128M-b4K/'), + commonpool_m_image_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M.image-s128M-b4K/'), + commonpool_m_text_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M.text-s128M-b4K/'), + commonpool_m_basic_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M.basic-s128M-b4K/'), + commonpool_m_s128m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.M-s128M-b4K/'), + # DataComp-S models + datacomp_s_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-DataComp.S-s13M-b4K/'), + commonpool_s_clip_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S.clip-s13M-b4K/'), + commonpool_s_laion_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S.laion-s13M-b4K/'), + commonpool_s_image_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S.image-s13M-b4K/'), + commonpool_s_text_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S.text-s13M-b4K/'), + commonpool_s_basic_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S.basic-s13M-b4K/'), + commonpool_s_s13m_b4k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-CommonPool.S-s13M-b4K/'), +) + +_VITB32_quickgelu = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e31-d867053b.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_32-quickgelu-laion400m_e32-46683a32.pt"), +) + +_VITB16 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16-laion400m_e31-00efa78f.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16-laion400m_e32-55e67d44.pt"), + laion2b_s34b_b88k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-laion2B-s34B-b88K/'), + # DataComp-L models + datacomp_l_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-DataComp.L-s1B-b8K/'), + commonpool_l_clip_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L.clip-s1B-b8K/'), + commonpool_l_laion_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L.laion-s1B-b8K/'), + commonpool_l_image_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L.image-s1B-b8K/'), + commonpool_l_text_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L.text-s1B-b8K/'), + commonpool_l_basic_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L.basic-s1B-b8K/'), + commonpool_l_s1b_b8k=_pcfg(hf_hub='laion/CLIP-ViT-B-16-CommonPool.L-s1B-b8K/'), +) + +_VITB16_PLUS_240 = dict( + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16_plus_240-laion400m_e31-8fb26589.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_b_16_plus_240-laion400m_e32-699c4b84.pt"), +) + +_VITL14 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt"), + laion400m_e31=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_l_14-laion400m_e31-69988bb6.pt"), + laion400m_e32=_pcfg( + "https://github.com/mlfoundations/open_clip/releases/download/v0.2-weights/vit_l_14-laion400m_e32-3d133497.pt"), + laion2b_s32b_b82k=_pcfg( + hf_hub='laion/CLIP-ViT-L-14-laion2B-s32B-b82K/', + mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), + # DataComp-XL models + datacomp_xl_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-L-14-DataComp.XL-s13B-b90K/'), + commonpool_xl_clip_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-L-14-CommonPool.XL.clip-s13B-b90K/'), + commonpool_xl_laion_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-L-14-CommonPool.XL.laion-s13B-b90K/'), + commonpool_xl_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-L-14-CommonPool.XL-s13B-b90K/'), +) + +_VITL14_336 = dict( + openai=_pcfg( + "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt"), +) + +_VITH14 = dict( + laion2b_s32b_b79k=_pcfg(hf_hub='laion/CLIP-ViT-H-14-laion2B-s32B-b79K/'), +) + +_VITg14 = dict( + laion2b_s12b_b42k=_pcfg(hf_hub='laion/CLIP-ViT-g-14-laion2B-s12B-b42K/'), + laion2b_s34b_b88k=_pcfg(hf_hub='laion/CLIP-ViT-g-14-laion2B-s34B-b88K/'), +) + +_VITbigG14 = dict( + laion2b_s39b_b160k=_pcfg(hf_hub='laion/CLIP-ViT-bigG-14-laion2B-39B-b160k/'), +) + +_robertaViTB32 = dict( + laion2b_s12b_b32k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-roberta-base-laion2B-s12B-b32k/'), +) + +_xlmRobertaBaseViTB32 = dict( + laion5b_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-B-32-xlm-roberta-base-laion5B-s13B-b90k/'), +) + +_xlmRobertaLargeFrozenViTH14 = dict( + frozen_laion5b_s13b_b90k=_pcfg(hf_hub='laion/CLIP-ViT-H-14-frozen-xlm-roberta-large-laion5B-s13B-b90k/'), +) + +_convnext_base = dict( + laion400m_s13b_b51k=_pcfg(hf_hub='laion/CLIP-convnext_base-laion400M-s13B-b51K/'), +) + +_convnext_base_w = dict( + laion2b_s13b_b82k=_pcfg(hf_hub='laion/CLIP-convnext_base_w-laion2B-s13B-b82K/'), + laion2b_s13b_b82k_augreg=_pcfg(hf_hub='laion/CLIP-convnext_base_w-laion2B-s13B-b82K-augreg/'), + laion_aesthetic_s13b_b82k=_pcfg(hf_hub='laion/CLIP-convnext_base_w-laion_aesthetic-s13B-b82K/'), +) + +_convnext_base_w_320 = dict( + laion_aesthetic_s13b_b82k=_pcfg(hf_hub='laion/CLIP-convnext_base_w_320-laion_aesthetic-s13B-b82K/'), + laion_aesthetic_s13b_b82k_augreg=_pcfg(hf_hub='laion/CLIP-convnext_base_w_320-laion_aesthetic-s13B-b82K-augreg/'), +) + +_convnext_large_d = dict( + laion2b_s26b_b102k_augreg=_pcfg(hf_hub='laion/CLIP-convnext_large_d.laion2B-s26B-b102K-augreg/'), +) + +_convnext_large_d_320 = dict( + laion2b_s29b_b131k_ft=_pcfg(hf_hub='laion/CLIP-convnext_large_d_320.laion2B-s29B-b131K-ft/'), + laion2b_s29b_b131k_ft_soup=_pcfg(hf_hub='laion/CLIP-convnext_large_d_320.laion2B-s29B-b131K-ft-soup/'), +) + +_convnext_xxlarge = dict( + laion2b_s34b_b82k_augreg=_pcfg(hf_hub='laion/CLIP-convnext_xxlarge-laion2B-s34B-b82K-augreg/'), + laion2b_s34b_b82k_augreg_rewind=_pcfg(hf_hub='laion/CLIP-convnext_xxlarge-laion2B-s34B-b82K-augreg-rewind/'), + laion2b_s34b_b82k_augreg_soup=_pcfg(hf_hub='laion/CLIP-convnext_xxlarge-laion2B-s34B-b82K-augreg-soup/'), +) + +_coca_VITB32 = dict( + laion2b_s13b_b90k=_pcfg(hf_hub='laion/CoCa-ViT-B-32-laion2B-s13B-b90k/'), + mscoco_finetuned_laion2b_s13b_b90k=_pcfg(hf_hub='laion/mscoco_finetuned_CoCa-ViT-B-32-laion2B-s13B-b90k/') +) + +_coca_VITL14 = dict( + laion2b_s13b_b90k=_pcfg(hf_hub='laion/CoCa-ViT-L-14-laion2B-s13B-b90k/'), + mscoco_finetuned_laion2b_s13b_b90k=_pcfg(hf_hub='laion/mscoco_finetuned_CoCa-ViT-L-14-laion2B-s13B-b90k/') +) + + +_PRETRAINED = { + "RN50": _RN50, + "RN50-quickgelu": _RN50_quickgelu, + "RN101": _RN101, + "RN101-quickgelu": _RN101_quickgelu, + "RN50x4": _RN50x4, + "RN50x16": _RN50x16, + "RN50x64": _RN50x64, + "ViT-B-32": _VITB32, + "ViT-B-32-quickgelu": _VITB32_quickgelu, + "ViT-B-16": _VITB16, + "ViT-B-16-plus-240": _VITB16_PLUS_240, + "ViT-L-14": _VITL14, + "ViT-L-14-336": _VITL14_336, + "ViT-H-14": _VITH14, + "ViT-g-14": _VITg14, + "ViT-bigG-14": _VITbigG14, + "roberta-ViT-B-32": _robertaViTB32, + "xlm-roberta-base-ViT-B-32": _xlmRobertaBaseViTB32, + "xlm-roberta-large-ViT-H-14": _xlmRobertaLargeFrozenViTH14, + "convnext_base": _convnext_base, + "convnext_base_w": _convnext_base_w, + "convnext_base_w_320": _convnext_base_w_320, + "convnext_large_d": _convnext_large_d, + "convnext_large_d_320": _convnext_large_d_320, + "convnext_xxlarge": _convnext_xxlarge, + "coca_ViT-B-32": _coca_VITB32, + "coca_ViT-L-14": _coca_VITL14, + "EVA01-g-14": dict( + # from QuanSun/EVA-CLIP/EVA01_CLIP_g_14_psz14_s11B.pt + laion400m_s11b_b41k=_pcfg(hf_hub='timm/eva_giant_patch14_clip_224.laion400m_s11b_b41k/'), + ), + "EVA01-g-14-plus": dict( + # from QuanSun/EVA-CLIP/EVA01_CLIP_g_14_plus_psz14_s11B.pt + merged2b_s11b_b114k=_pcfg(hf_hub='timm/eva_giant_patch14_plus_clip_224.merged2b_s11b_b114k/'), + ), + "EVA02-B-16": dict( + # from QuanSun/EVA-CLIP/EVA02_CLIP_B_psz16_s8B.pt + merged2b_s8b_b131k=_pcfg(hf_hub='timm/eva02_base_patch16_clip_224.merged2b_s8b_b131k/'), + ), + "EVA02-L-14": dict( + # from QuanSun/EVA-CLIP/EVA02_CLIP_L_psz14_s4B.pt + merged2b_s4b_b131k=_pcfg(hf_hub='timm/eva02_large_patch14_clip_224.merged2b_s4b_b131k/'), + ), + "EVA02-L-14-336": dict( + # from QuanSun/EVA-CLIP/EVA02_CLIP_L_336_psz14_s6B.pt + merged2b_s6b_b61k=_pcfg(hf_hub='timm/eva02_large_patch14_clip_336.merged2b_s6b_b61k/'), + ), + "EVA02-E-14": dict( + # from QuanSun/EVA-CLIP/EVA02_CLIP_E_psz14_s4B.pt + laion2b_s4b_b115k=_pcfg(hf_hub='timm/eva02_enormous_patch14_clip_224.laion2b_s4b_b115k/'), + ), + "EVA02-E-14-plus": dict( + # from QuanSun/EVA-CLIP/EVA02_CLIP_E_psz14_plus_s9B.pt + laion2b_s9b_b144k=_pcfg(hf_hub='timm/eva02_enormous_patch14_plus_clip_224.laion2b_s9b_b144k/'), + ) +} + + +def _clean_tag(tag: str): + # normalize pretrained tags + return tag.lower().replace('-', '_') + + +def list_pretrained(as_str: bool = False): + """ returns list of pretrained models + Returns a tuple (model_name, pretrain_tag) by default or 'name:tag' if as_str == True + """ + return [':'.join([k, t]) if as_str else (k, t) for k in _PRETRAINED.keys() for t in _PRETRAINED[k].keys()] + + +def list_pretrained_models_by_tag(tag: str): + """ return all models having the specified pretrain tag """ + models = [] + tag = _clean_tag(tag) + for k in _PRETRAINED.keys(): + if tag in _PRETRAINED[k]: + models.append(k) + return models + + +def list_pretrained_tags_by_model(model: str): + """ return all pretrain tags for the specified model architecture """ + tags = [] + if model in _PRETRAINED: + tags.extend(_PRETRAINED[model].keys()) + return tags + + +def is_pretrained_cfg(model: str, tag: str): + if model not in _PRETRAINED: + return False + return _clean_tag(tag) in _PRETRAINED[model] + + +def get_pretrained_cfg(model: str, tag: str): + if model not in _PRETRAINED: + return {} + model_pretrained = _PRETRAINED[model] + return model_pretrained.get(_clean_tag(tag), {}) + + +def get_pretrained_url(model: str, tag: str): + cfg = get_pretrained_cfg(model, _clean_tag(tag)) + return cfg.get('url', '') + + +def download_pretrained_from_url( + url: str, + cache_dir: Union[str, None] = None, +): + if not cache_dir: + cache_dir = os.path.expanduser("~/.cache/clip") + os.makedirs(cache_dir, exist_ok=True) + filename = os.path.basename(url) + + if 'openaipublic' in url: + expected_sha256 = url.split("/")[-2] + elif 'mlfoundations' in url: + expected_sha256 = os.path.splitext(filename)[0].split("-")[-1] + else: + expected_sha256 = '' + + download_target = os.path.join(cache_dir, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if expected_sha256: + if hashlib.sha256(open(download_target, "rb").read()).hexdigest().startswith(expected_sha256): + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + else: + return download_target + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.headers.get("Content-Length")), ncols=80, unit='iB', unit_scale=True) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if expected_sha256 and not hashlib.sha256(open(download_target, "rb").read()).hexdigest().startswith(expected_sha256): + raise RuntimeError(f"Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def has_hf_hub(necessary=False): + if not _has_hf_hub and necessary: + # if no HF Hub module installed, and it is necessary to continue, raise error + raise RuntimeError( + 'Hugging Face hub model specified but package not installed. Run `pip install huggingface_hub`.') + return _has_hf_hub + + +def download_pretrained_from_hf( + model_id: str, + filename: str = 'open_clip_pytorch_model.bin', + revision=None, + cache_dir: Union[str, None] = None, +): + has_hf_hub(True) + cached_file = hf_hub_download(model_id, filename, revision=revision, cache_dir=cache_dir) + return cached_file + + +def download_pretrained( + cfg: Dict, + force_hf_hub: bool = False, + cache_dir: Union[str, None] = None, +): + target = '' + if not cfg: + return target + + download_url = cfg.get('url', '') + download_hf_hub = cfg.get('hf_hub', '') + if download_hf_hub and force_hf_hub: + # use HF hub even if url exists + download_url = '' + + if download_url: + target = download_pretrained_from_url(download_url, cache_dir=cache_dir) + elif download_hf_hub: + has_hf_hub(True) + # we assume the hf_hub entries in pretrained config combine model_id + filename in + # 'org/model_name/filename.pt' form. To specify just the model id w/o filename and + # use 'open_clip_pytorch_model.bin' default, there must be a trailing slash 'org/model_name/'. + model_id, filename = os.path.split(download_hf_hub) + if filename: + target = download_pretrained_from_hf(model_id, filename=filename, cache_dir=cache_dir) + else: + target = download_pretrained_from_hf(model_id, cache_dir=cache_dir) + + return target \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/segmentation_utils.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/segmentation_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e286e0a4d3255952ef2d501b6ac8571cd72cb7f6 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/segmentation_utils.py @@ -0,0 +1,682 @@ +import torch +import matplotlib.cm +import skimage.io +import skimage.feature +import skimage.filters +import numpy as np +import os +from collections import OrderedDict +import glob +from sklearn.metrics import f1_score, average_precision_score +from sklearn.metrics import precision_recall_curve, roc_curve + +SMOOTH = 1e-6 + + +def get_iou(outputs: torch.Tensor, labels: torch.Tensor): + # You can comment out this line if you are passing tensors of equal shape + # But if you are passing output from UNet or something it will most probably + # be with the BATCH x 1 x H x W shape + outputs = outputs.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + labels = labels.squeeze(1) # BATCH x 1 x H x W => BATCH x H x W + + intersection = (outputs & labels).float().sum((1, 2)) # Will be zero if Truth=0 or Prediction=0 + union = (outputs | labels).float().sum((1, 2)) # Will be zzero if both are 0 + + iou = (intersection + SMOOTH) / (union + SMOOTH) # We smooth our devision to avoid 0/0 + + return iou.cpu().numpy() + + +def get_f1_scores(predict, target, ignore_index=-1): + # Tensor process + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target.data.cpu().numpy().reshape(-1) + pb = predict[target != ignore_index].reshape(batch_size, -1) + tb = target[target != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(np.nan_to_num(f1_score(t, p))) + + return total + + +def get_roc(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(roc_curve(t, p)) + + return total + + +def get_pr(predict, target, ignore_index=-1): + target_expand = target.unsqueeze(1).expand_as(predict) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = target.unsqueeze(1).clamp(min=0) + target_1hot = x.scatter_(1, t, 1) + batch_size = predict.shape[0] + predict = predict.data.cpu().numpy().reshape(-1) + target = target_1hot.data.cpu().numpy().reshape(-1) + pb = predict[target_expand_numpy != ignore_index].reshape(batch_size, -1) + tb = target[target_expand_numpy != ignore_index].reshape(batch_size, -1) + + total = [] + for p, t in zip(pb, tb): + total.append(precision_recall_curve(t, p)) + + return total + + +def get_ap_scores(predict, target, ignore_index=-1): + total = [] + for pred, tgt in zip(predict, target): + target_expand = tgt.unsqueeze(0).expand_as(pred) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + + # Tensor process + x = torch.zeros_like(target_expand) + t = tgt.unsqueeze(0).clamp(min=0).long() + target_1hot = x.scatter_(0, t, 1) + predict_flat = pred.data.cpu().numpy().reshape(-1) + target_flat = target_1hot.data.cpu().numpy().reshape(-1) + + p = predict_flat[target_expand_numpy != ignore_index] + t = target_flat[target_expand_numpy != ignore_index] + + total.append(np.nan_to_num(average_precision_score(t, p))) + + return total + + +def get_ap_multiclass(predict, target): + total = [] + for pred, tgt in zip(predict, target): + predict_flat = pred.data.cpu().numpy().reshape(-1) + target_flat = tgt.data.cpu().numpy().reshape(-1) + + total.append(np.nan_to_num(average_precision_score(target_flat, predict_flat))) + + return total + + +def batch_precision_recall(predict, target, thr=0.5): + """Batch Precision Recall + Args: + predict: input 4D tensor + target: label 4D tensor + """ + # _, predict = torch.max(predict, 1) + + predict = predict > thr + predict = predict.data.cpu().numpy() + 1 + target = target.data.cpu().numpy() + 1 + + tp = np.sum(((predict == 2) * (target == 2)) * (target > 0)) + fp = np.sum(((predict == 2) * (target == 1)) * (target > 0)) + fn = np.sum(((predict == 1) * (target == 2)) * (target > 0)) + + precision = float(np.nan_to_num(tp / (tp + fp))) + recall = float(np.nan_to_num(tp / (tp + fn))) + + return precision, recall + + +def batch_pix_accuracy(predict, target): + """Batch Pixel Accuracy + Args: + predict: input 3D tensor + target: label 3D tensor + """ + + # for thr in np.linspace(0, 1, slices): + + _, predict = torch.max(predict, 0) + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + pixel_labeled = np.sum(target > 0) + pixel_correct = np.sum((predict == target) * (target > 0)) + assert pixel_correct <= pixel_labeled, \ + "Correct area should be smaller than Labeled" + return pixel_correct, pixel_labeled + + +def batch_intersection_union(predict, target, nclass): + """Batch Intersection of Union + Args: + predict: input 3D tensor + target: label 3D tensor + nclass: number of categories (int) + """ + _, predict = torch.max(predict, 0) + mini = 1 + maxi = nclass + nbins = nclass + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + + predict = predict * (target > 0).astype(predict.dtype) + intersection = predict * (predict == target) + # areas of intersection and union + area_inter, _ = np.histogram(intersection, bins=nbins, range=(mini, maxi)) + area_pred, _ = np.histogram(predict, bins=nbins, range=(mini, maxi)) + area_lab, _ = np.histogram(target, bins=nbins, range=(mini, maxi)) + area_union = area_pred + area_lab - area_inter + assert (area_inter <= area_union).all(), \ + "Intersection area should be smaller than Union area" + return area_inter, area_union + + +def pixel_accuracy(im_pred, im_lab): + # ref https://github.com/CSAILVision/sceneparsing/blob/master/evaluationCode/utils_eval.py + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + + # Remove classes from unlabeled pixels in gt image. + # We should not penalize detections in unlabeled portions of the image. + pixel_labeled = np.sum(im_lab > 0) + pixel_correct = np.sum((im_pred == im_lab) * (im_lab > 0)) + # pixel_accuracy = 1.0 * pixel_correct / pixel_labeled + return pixel_correct, pixel_labeled + + +def intersection_and_union(im_pred, im_lab, num_class): + im_pred = np.asarray(im_pred) + im_lab = np.asarray(im_lab) + # Remove classes from unlabeled pixels in gt image. + im_pred = im_pred * (im_lab > 0) + # Compute area intersection: + intersection = im_pred * (im_pred == im_lab) + area_inter, _ = np.histogram(intersection, bins=num_class - 1, + range=(1, num_class - 1)) + # Compute area union: + area_pred, _ = np.histogram(im_pred, bins=num_class - 1, + range=(1, num_class - 1)) + area_lab, _ = np.histogram(im_lab, bins=num_class - 1, + range=(1, num_class - 1)) + area_union = area_pred + area_lab - area_inter + return area_inter, area_union + + +class Saver(object): + def __init__(self, args): + self.args = args + self.directory = os.path.join('run', args.train_dataset, args.model) + self.runs = sorted(glob.glob(os.path.join(self.directory, 'experiment_*'))) + run_id = int(self.runs[-1].split('_')[-1]) + 1 if self.runs else 0 + + self.experiment_dir = os.path.join(self.directory, 'experiment_{}'.format(str(run_id))) + if not os.path.exists(self.experiment_dir): + os.makedirs(self.experiment_dir) + + def save_checkpoint(self, state, filename='checkpoint.pth.tar'): + """Saves checkpoint to disk""" + filename = os.path.join(self.experiment_dir, filename) + torch.save(state, filename) + + def save_experiment_config(self): + logfile = os.path.join(self.experiment_dir, 'parameters.txt') + log_file = open(logfile, 'w') + p = OrderedDict() + p['train_dataset'] = self.args.train_dataset + p['lr'] = self.args.lr + p['epoch'] = self.args.epochs + + for key, val in p.items(): + log_file.write(key + ':' + str(val) + '\n') + log_file.close() + + +class Metric(object): + """Base class for all metrics. + From: https://github.com/pytorch/tnt/blob/master/torchnet/meter/meter.py + """ + def reset(self): + pass + + def add(self): + pass + + def value(self): + pass + + +class ConfusionMatrix(Metric): + """Constructs a confusion matrix for a multi-class classification problems. + Does not support multi-label, multi-class problems. + Keyword arguments: + - num_classes (int): number of classes in the classification problem. + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + Modified from: https://github.com/pytorch/tnt/blob/master/torchnet/meter/confusionmeter.py + """ + + def __init__(self, num_classes, normalized=False): + super().__init__() + + self.conf = np.ndarray((num_classes, num_classes), dtype=np.int32) + self.normalized = normalized + self.num_classes = num_classes + self.reset() + + def reset(self): + self.conf.fill(0) + + def add(self, predicted, target): + """Computes the confusion matrix + The shape of the confusion matrix is K x K, where K is the number + of classes. + Keyword arguments: + - predicted (Tensor or numpy.ndarray): Can be an N x K tensor/array of + predicted scores obtained from the model for N examples and K classes, + or an N-tensor/array of integer values between 0 and K-1. + - target (Tensor or numpy.ndarray): Can be an N x K tensor/array of + ground-truth classes for N examples and K classes, or an N-tensor/array + of integer values between 0 and K-1. + """ + # If target and/or predicted are tensors, convert them to numpy arrays + if torch.is_tensor(predicted): + predicted = predicted.cpu().numpy() + if torch.is_tensor(target): + target = target.cpu().numpy() + + assert predicted.shape[0] == target.shape[0], \ + 'number of targets and predicted outputs do not match' + + if np.ndim(predicted) != 1: + assert predicted.shape[1] == self.num_classes, \ + 'number of predictions does not match size of confusion matrix' + predicted = np.argmax(predicted, 1) + else: + assert (predicted.max() < self.num_classes) and (predicted.min() >= 0), \ + 'predicted values are not between 0 and k-1' + + if np.ndim(target) != 1: + assert target.shape[1] == self.num_classes, \ + 'Onehot target does not match size of confusion matrix' + assert (target >= 0).all() and (target <= 1).all(), \ + 'in one-hot encoding, target values should be 0 or 1' + assert (target.sum(1) == 1).all(), \ + 'multi-label setting is not supported' + target = np.argmax(target, 1) + else: + assert (target.max() < self.num_classes) and (target.min() >= 0), \ + 'target values are not between 0 and k-1' + + # hack for bincounting 2 arrays together + x = predicted + self.num_classes * target + bincount_2d = np.bincount( + x.astype(np.int32), minlength=self.num_classes**2) + assert bincount_2d.size == self.num_classes**2 + conf = bincount_2d.reshape((self.num_classes, self.num_classes)) + + self.conf += conf + + def value(self): + """ + Returns: + Confustion matrix of K rows and K columns, where rows corresponds + to ground-truth targets and columns corresponds to predicted + targets. + """ + if self.normalized: + conf = self.conf.astype(np.float32) + return conf / conf.sum(1).clip(min=1e-12)[:, None] + else: + return self.conf + + +def vec2im(V, shape=()): + ''' + Transform an array V into a specified shape - or if no shape is given assume a square output format. + + Parameters + ---------- + + V : numpy.ndarray + an array either representing a matrix or vector to be reshaped into an two-dimensional image + + shape : tuple or list + optional. containing the shape information for the output array if not given, the output is assumed to be square + + Returns + ------- + + W : numpy.ndarray + with W.shape = shape or W.shape = [np.sqrt(V.size)]*2 + + ''' + + if len(shape) < 2: + shape = [np.sqrt(V.size)] * 2 + shape = map(int, shape) + return np.reshape(V, shape) + + +def enlarge_image(img, scaling=3): + ''' + Enlarges a given input matrix by replicating each pixel value scaling times in horizontal and vertical direction. + + Parameters + ---------- + + img : numpy.ndarray + array of shape [H x W] OR [H x W x D] + + scaling : int + positive integer value > 0 + + Returns + ------- + + out : numpy.ndarray + two-dimensional array of shape [scaling*H x scaling*W] + OR + three-dimensional array of shape [scaling*H x scaling*W x D] + depending on the dimensionality of the input + ''' + + if scaling < 1 or not isinstance(scaling, int): + print('scaling factor needs to be an int >= 1') + + if len(img.shape) == 2: + H, W = img.shape + + out = np.zeros((scaling * H, scaling * W)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh:fh + scaling, fw:fw + scaling] = img[h, w] + + elif len(img.shape) == 3: + H, W, D = img.shape + + out = np.zeros((scaling * H, scaling * W, D)) + for h in range(H): + fh = scaling * h + for w in range(W): + fw = scaling * w + out[fh:fh + scaling, fw:fw + scaling, :] = img[h, w, :] + + return out + + +def repaint_corner_pixels(rgbimg, scaling=3): + ''' + DEPRECATED/OBSOLETE. + + Recolors the top left and bottom right pixel (groups) with the average rgb value of its three neighboring pixel (groups). + The recoloring visually masks the opposing pixel values which are a product of stabilizing the scaling. + Assumes those image ares will pretty much never show evidence. + + Parameters + ---------- + + rgbimg : numpy.ndarray + array of shape [H x W x 3] + + scaling : int + positive integer value > 0 + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] + ''' + + # top left corner. + rgbimg[0:scaling, 0:scaling, :] = (rgbimg[0, scaling, :] + rgbimg[scaling, 0, :] + rgbimg[scaling, scaling, + :]) / 3.0 + # bottom right corner + rgbimg[-scaling:, -scaling:, :] = (rgbimg[-1, -1 - scaling, :] + rgbimg[-1 - scaling, -1, :] + rgbimg[-1 - scaling, + -1 - scaling, + :]) / 3.0 + return rgbimg + + +def digit_to_rgb(X, scaling=3, shape=(), cmap='binary'): + ''' + Takes as input an intensity array and produces a rgb image due to some color map + + Parameters + ---------- + + X : numpy.ndarray + intensity matrix as array of shape [M x N] + + scaling : int + optional. positive integer value > 0 + + shape: tuple or list of its , length = 2 + optional. if not given, X is reshaped to be square. + + cmap : str + name of color map of choice. default is 'binary' + + Returns + ------- + + image : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + ''' + + # create color map object from name string + cmap = eval('matplotlib.cm.{}'.format(cmap)) + + image = enlarge_image(vec2im(X, shape), scaling) # enlarge + image = cmap(image.flatten())[..., 0:3].reshape([image.shape[0], image.shape[1], 3]) # colorize, reshape + + return image + + +def hm_to_rgb(R, X=None, scaling=3, shape=(), sigma=2, cmap='bwr', normalize=True): + ''' + Takes as input an intensity array and produces a rgb image for the represented heatmap. + optionally draws the outline of another input on top of it. + + Parameters + ---------- + + R : numpy.ndarray + the heatmap to be visualized, shaped [M x N] + + X : numpy.ndarray + optional. some input, usually the data point for which the heatmap R is for, which shall serve + as a template for a black outline to be drawn on top of the image + shaped [M x N] + + scaling: int + factor, on how to enlarge the heatmap (to control resolution and as a inverse way to control outline thickness) + after reshaping it using shape. + + shape: tuple or list, length = 2 + optional. if not given, X is reshaped to be square. + + sigma : double + optional. sigma-parameter for the canny algorithm used for edge detection. the found edges are drawn as outlines. + + cmap : str + optional. color map of choice + + normalize : bool + optional. whether to normalize the heatmap to [-1 1] prior to colorization or not. + + Returns + ------- + + rgbimg : numpy.ndarray + three-dimensional array of shape [scaling*H x scaling*W x 3] , where H*W == M*N + ''' + + # create color map object from name string + cmap = eval('matplotlib.cm.{}'.format(cmap)) + + if normalize: + R = R / np.max(np.abs(R)) # normalize to [-1,1] wrt to max relevance magnitude + R = (R + 1.) / 2. # shift/normalize to [0,1] for color mapping + + R = enlarge_image(R, scaling) + rgb = cmap(R.flatten())[..., 0:3].reshape([R.shape[0], R.shape[1], 3]) + # rgb = repaint_corner_pixels(rgb, scaling) #obsolete due to directly calling the color map with [0,1]-normalized inputs + + if not X is None: # compute the outline of the input + # X = enlarge_image(vec2im(X,shape), scaling) + xdims = X.shape + Rdims = R.shape + + return rgb + + +def save_image(rgb_images, path, gap=2): + ''' + Takes as input a list of rgb images, places them next to each other with a gap and writes out the result. + + Parameters + ---------- + + rgb_images : list , tuple, collection. such stuff + each item in the collection is expected to be an rgb image of dimensions [H x _ x 3] + where the width is variable + + path : str + the output path of the assembled image + + gap : int + optional. sets the width of a black area of pixels realized as an image shaped [H x gap x 3] in between the input images + + Returns + ------- + + image : numpy.ndarray + the assembled image as written out to path + ''' + + sz = [] + image = [] + for i in range(len(rgb_images)): + if not sz: + sz = rgb_images[i].shape + image = rgb_images[i] + gap = np.zeros((sz[0], gap, sz[2])) + continue + if not sz[0] == rgb_images[i].shape[0] and sz[1] == rgb_images[i].shape[2]: + print('image', i, 'differs in size. unable to perform horizontal alignment') + print('expected: Hx_xD = {0}x_x{1}'.format(sz[0], sz[1])) + print('got : Hx_xD = {0}x_x{1}'.format(rgb_images[i].shape[0], rgb_images[i].shape[1])) + print('skipping image\n') + else: + image = np.hstack((image, gap, rgb_images[i])) + + image *= 255 + image = image.astype(np.uint8) + + print('saving image to ', path) + skimage.io.imsave(path, image) + return image + + +class IoU(Metric): + """Computes the intersection over union (IoU) per class and corresponding + mean (mIoU). + + Intersection over union (IoU) is a common evaluation metric for semantic + segmentation. The predictions are first accumulated in a confusion matrix + and the IoU is computed from it as follows: + + IoU = true_positive / (true_positive + false_positive + false_negative). + + Keyword arguments: + - num_classes (int): number of classes in the classification problem + - normalized (boolean, optional): Determines whether or not the confusion + matrix is normalized or not. Default: False. + - ignore_index (int or iterable, optional): Index of the classes to ignore + when computing the IoU. Can be an int, or any iterable of ints. + """ + + def __init__(self, num_classes, normalized=False, ignore_index=None): + super().__init__() + self.conf_metric = ConfusionMatrix(num_classes, normalized) + + if ignore_index is None: + self.ignore_index = None + elif isinstance(ignore_index, int): + self.ignore_index = (ignore_index,) + else: + try: + self.ignore_index = tuple(ignore_index) + except TypeError: + raise ValueError("'ignore_index' must be an int or iterable") + + def reset(self): + self.conf_metric.reset() + + def add(self, predicted, target): + """Adds the predicted and target pair to the IoU metric. + + Keyword arguments: + - predicted (Tensor): Can be a (N, K, H, W) tensor of + predicted scores obtained from the model for N examples and K classes, + or (N, H, W) tensor of integer values between 0 and K-1. + - target (Tensor): Can be a (N, K, H, W) tensor of + target scores for N examples and K classes, or (N, H, W) tensor of + integer values between 0 and K-1. + + """ + # Dimensions check + assert predicted.size(0) == target.size(0), \ + 'number of targets and predicted outputs do not match' + assert predicted.dim() == 3 or predicted.dim() == 4, \ + "predictions must be of dimension (N, H, W) or (N, K, H, W)" + assert target.dim() == 3 or target.dim() == 4, \ + "targets must be of dimension (N, H, W) or (N, K, H, W)" + + # If the tensor is in categorical format convert it to integer format + if predicted.dim() == 4: + _, predicted = predicted.max(1) + if target.dim() == 4: + _, target = target.max(1) + + self.conf_metric.add(predicted.view(-1), target.view(-1)) + + def value(self): + """Computes the IoU and mean IoU. + + The mean computation ignores NaN elements of the IoU array. + + Returns: + Tuple: (IoU, mIoU). The first output is the per class IoU, + for K classes it's numpy.ndarray with K elements. The second output, + is the mean IoU. + """ + conf_matrix = self.conf_metric.value() + if self.ignore_index is not None: + for index in self.ignore_index: + conf_matrix[:, self.ignore_index] = 0 + conf_matrix[self.ignore_index, :] = 0 + true_positive = np.diag(conf_matrix) + false_positive = np.sum(conf_matrix, 0) - true_positive + false_negative = np.sum(conf_matrix, 1) - true_positive + + # Just in case we get a division by 0, ignore/hide the error + with np.errstate(divide='ignore', invalid='ignore'): + iou = true_positive / (true_positive + false_positive + false_negative) + + return iou, np.nanmean(iou) + \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/timm_model.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/timm_model.py new file mode 100644 index 0000000000000000000000000000000000000000..97a8c52bf6a1e4f7cd92ddcbf9d1ad76897ffdd0 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/timm_model.py @@ -0,0 +1,149 @@ +""" timm model adapter + +Wraps timm (https://github.com/rwightman/pytorch-image-models) models for use as a vision tower in CLIP model. +""" +import logging +from collections import OrderedDict + +import torch +import torch.nn as nn + +try: + import timm + from timm.models.layers import Mlp, to_2tuple + try: + # old timm imports < 0.8.1 + from timm.models.layers.attention_pool2d import RotAttentionPool2d + from timm.models.layers.attention_pool2d import AttentionPool2d as AbsAttentionPool2d + except ImportError: + # new timm imports >= 0.8.1 + from timm.layers import RotAttentionPool2d + from timm.layers import AttentionPool2d as AbsAttentionPool2d +except ImportError: + timm = None + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import freeze_batch_norm_2d + + +class TimmModel(nn.Module): + """ timm model adapter + """ + + def __init__( + self, + model_name, + embed_dim, + image_size=224, + pool='avg', + proj='linear', + proj_bias=False, + drop=0., + drop_path=None, + patch_drop=None, + pretrained=False, + ): + super().__init__() + if timm is None: + raise RuntimeError("Please `pip install timm` to use timm models.") + self.image_size = to_2tuple(image_size) + + # setup kwargs that may not be common across all models + timm_kwargs = {} + if drop_path is not None: + timm_kwargs['drop_path_rate'] = drop_path + if patch_drop is not None: + timm_kwargs['patch_drop_rate'] = patch_drop + + custom_pool = pool in ('abs_attn', 'rot_attn') + if not proj and not custom_pool: + # use network classifier head as projection if no proj specified and no custom pooling used + self.trunk = timm.create_model( + model_name, + num_classes=embed_dim, + global_pool=pool, + pretrained=pretrained, + **timm_kwargs, + ) + prev_chs = embed_dim + else: + self.trunk = timm.create_model( + model_name, + pretrained=pretrained, + **timm_kwargs, + ) + feat_size = self.trunk.default_cfg.get('pool_size', None) + feature_ndim = 1 if not feat_size else 2 + if custom_pool: + assert feature_ndim == 2 + # if attn pooling used, remove both classifier and default pool + self.trunk.reset_classifier(0, global_pool='') + else: + # reset global pool if pool config set, otherwise leave as network default + reset_kwargs = dict(global_pool=pool) if pool else {} + self.trunk.reset_classifier(0, **reset_kwargs) + prev_chs = self.trunk.num_features + + head_layers = OrderedDict() + + # Add custom pooling to head + if pool == 'abs_attn': + head_layers['pool'] = AbsAttentionPool2d(prev_chs, feat_size=feat_size, out_features=embed_dim) + prev_chs = embed_dim + elif pool == 'rot_attn': + head_layers['pool'] = RotAttentionPool2d(prev_chs, out_features=embed_dim) + prev_chs = embed_dim + + # NOTE attention pool ends with a projection layer, so proj should usually be set to '' if such pooling is used + if proj == 'linear': + head_layers['drop'] = nn.Dropout(drop) + head_layers['proj'] = nn.Linear(prev_chs, embed_dim, bias=proj_bias) + elif proj == 'mlp': + head_layers['mlp'] = Mlp(prev_chs, 2 * embed_dim, embed_dim, drop=(drop, 0), bias=(True, proj_bias)) + else: + assert not proj, f'Unknown projection type {proj}.' + + self.head = nn.Sequential(head_layers) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + """ lock modules + Args: + unlocked_groups (int): leave last n layer groups unlocked (default: 0) + """ + if not unlocked_groups: + # lock full model + for param in self.trunk.parameters(): + param.requires_grad = False + if freeze_bn_stats: + freeze_batch_norm_2d(self.trunk) + else: + # NOTE: partial freeze requires latest timm (master) branch and is subject to change + try: + # FIXME import here until API stable and in an official release + from timm.models.helpers import group_parameters, group_modules + except ImportError: + raise RuntimeError( + 'Please install latest timm `pip install git+https://github.com/rwightman/pytorch-image-models`') + matcher = self.trunk.group_matcher() + gparams = group_parameters(self.trunk, matcher) + max_layer_id = max(gparams.keys()) + max_layer_id = max_layer_id - unlocked_groups + for group_idx in range(max_layer_id + 1): + group = gparams[group_idx] + for param in group: + self.trunk.get_parameter(param).requires_grad = False + if freeze_bn_stats: + gmodules = group_modules(self.trunk, matcher, reverse=True) + gmodules = {k for k, v in gmodules.items() if v <= max_layer_id} + freeze_batch_norm_2d(self.trunk, gmodules) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + try: + self.trunk.set_grad_checkpointing(enable) + except Exception as e: + logging.warning('grad checkpointing not supported for this timm image tower, continuing without...') + + def forward(self, x): + x = self.trunk(x) + x = self.head(x) + return x \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/tokenizer.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..33ecf184db66784ad6c2639bfb9e382cb2071187 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/tokenizer.py @@ -0,0 +1,214 @@ +""" CLIP tokenizer + +Copied from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI. +""" +import gzip +import html +import os +from functools import lru_cache +from typing import Union, List + +import ftfy +import regex as re +import torch + +# https://stackoverflow.com/q/62691279 +import os +os.environ["TOKENIZERS_PARALLELISM"] = "false" + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "vocab/bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a significant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe(), special_tokens=None): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + if not special_tokens: + special_tokens = ['', ''] + else: + special_tokens = ['', ''] + special_tokens + vocab.extend(special_tokens) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {t:t for t in special_tokens} + special = "|".join(special_tokens) + self.pat = re.compile(special + r"""|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + self.vocab_size = len(self.encoder) + self.all_special_ids = [self.encoder[t] for t in special_tokens] + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text + + +_tokenizer = SimpleTokenizer() + +def decode(output_ids: torch.Tensor): + output_ids = output_ids.cpu().numpy() + return _tokenizer.decode(output_ids) + +def tokenize(texts: Union[str, List[str]], context_length: int = 77) -> torch.LongTensor: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + context_length : int + The context length to use; all CLIP models use 77 as the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length] + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder[""] + eot_token = _tokenizer.encoder[""] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + tokens = tokens[:context_length] # Truncate + tokens[-1] = eot_token + result[i, :len(tokens)] = torch.tensor(tokens) + + return result + + +class HFTokenizer: + """HuggingFace tokenizer wrapper""" + + def __init__(self, tokenizer_name: str): + from transformers import AutoTokenizer + self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name) + + def save_pretrained(self, dest): + self.tokenizer.save_pretrained(dest) + + def __call__(self, texts: Union[str, List[str]], context_length: int = 77) -> torch.Tensor: + # same cleaning as for default tokenizer, except lowercasing + # adding lower (for case-sensitive tokenizers) will make it more robust but less sensitive to nuance + if isinstance(texts, str): + texts = [texts] + texts = [whitespace_clean(basic_clean(text)) for text in texts] + input_ids = self.tokenizer( + texts, + return_tensors='pt', + max_length=context_length, + padding='max_length', + truncation=True, + ).input_ids + return input_ids \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transform.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transform.py new file mode 100644 index 0000000000000000000000000000000000000000..b215bbfa5643645c885de54373767a777704ca96 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transform.py @@ -0,0 +1,133 @@ +import warnings +from dataclasses import dataclass, asdict +from typing import Any, Dict, Optional, Sequence, Tuple, Union + +import torch +import torch.nn as nn +import torchvision.transforms.functional as F + +from torchvision.transforms import Normalize, Compose, RandomResizedCrop, InterpolationMode, ToTensor, Resize, \ + CenterCrop + +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.constants import OPENAI_DATASET_MEAN, OPENAI_DATASET_STD + + +@dataclass +class AugmentationCfg: + scale: Tuple[float, float] = (0.9, 1.0) + ratio: Optional[Tuple[float, float]] = None + color_jitter: Optional[Union[float, Tuple[float, float, float]]] = None + interpolation: Optional[str] = None + re_prob: Optional[float] = None + re_count: Optional[int] = None + use_timm: bool = False + + +class ResizeMaxSize(nn.Module): + + def __init__(self, max_size, interpolation=InterpolationMode.BICUBIC, fn='max', fill=0): + super().__init__() + if not isinstance(max_size, int): + raise TypeError(f"Size should be int. Got {type(max_size)}") + self.max_size = max_size + self.interpolation = interpolation + self.fn = min if fn == 'min' else min + self.fill = fill + + def forward(self, img): + if isinstance(img, torch.Tensor): + height, width = img.shape[:2] + else: + width, height = img.size + scale = self.max_size / float(max(height, width)) + if scale != 1.0: + new_size = tuple(round(dim * scale) for dim in (height, width)) + img = F.resize(img, new_size, self.interpolation) + pad_h = self.max_size - new_size[0] + pad_w = self.max_size - new_size[1] + img = F.pad(img, padding=[pad_w//2, pad_h//2, pad_w - pad_w//2, pad_h - pad_h//2], fill=self.fill) + return img + + +def _convert_to_rgb(image): + return image.convert('RGB') + + +def image_transform( + image_size: int, + is_train: bool, + mean: Optional[Tuple[float, ...]] = None, + std: Optional[Tuple[float, ...]] = None, + resize_longest_max: bool = False, + fill_color: int = 0, + aug_cfg: Optional[Union[Dict[str, Any], AugmentationCfg]] = None, +): + mean = mean or OPENAI_DATASET_MEAN + if not isinstance(mean, (list, tuple)): + mean = (mean,) * 3 + + std = std or OPENAI_DATASET_STD + if not isinstance(std, (list, tuple)): + std = (std,) * 3 + + if isinstance(image_size, (list, tuple)) and image_size[0] == image_size[1]: + # for square size, pass size as int so that Resize() uses aspect preserving shortest edge + image_size = image_size[0] + + if isinstance(aug_cfg, dict): + aug_cfg = AugmentationCfg(**aug_cfg) + else: + aug_cfg = aug_cfg or AugmentationCfg() + normalize = Normalize(mean=mean, std=std) + if is_train: + aug_cfg_dict = {k: v for k, v in asdict(aug_cfg).items() if v is not None} + use_timm = aug_cfg_dict.pop('use_timm', False) + if use_timm: + from timm.data import create_transform # timm can still be optional + if isinstance(image_size, (tuple, list)): + assert len(image_size) >= 2 + input_size = (3,) + image_size[-2:] + else: + input_size = (3, image_size, image_size) + # by default, timm aug randomly alternates bicubic & bilinear for better robustness at inference time + aug_cfg_dict.setdefault('interpolation', 'random') + aug_cfg_dict.setdefault('color_jitter', None) # disable by default + train_transform = create_transform( + input_size=input_size, + is_training=True, + hflip=0., + mean=mean, + std=std, + re_mode='pixel', + **aug_cfg_dict, + ) + else: + train_transform = Compose([ + RandomResizedCrop( + image_size, + scale=aug_cfg_dict.pop('scale'), + interpolation=InterpolationMode.BICUBIC, + ), + _convert_to_rgb, + ToTensor(), + normalize, + ]) + if aug_cfg_dict: + warnings.warn(f'Unused augmentation cfg items, specify `use_timm` to use ({list(aug_cfg_dict.keys())}).') + return train_transform + else: + if resize_longest_max: + transforms = [ + ResizeMaxSize(image_size, fill=fill_color) + ] + else: + transforms = [ + Resize(image_size, interpolation=InterpolationMode.BICUBIC), + CenterCrop(image_size), + ] + transforms.extend([ + _convert_to_rgb, + ToTensor(), + normalize, + ]) + return Compose(transforms) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transformer.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..1d2d9bdc3afe59fff96314d62402f04459359b41 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/transformer.py @@ -0,0 +1,1006 @@ +from collections import OrderedDict +import math +from typing import Callable, Optional, Sequence, Tuple, Text + +import torch +from torch import nn +from torch.nn import functional as F +from torch.utils.checkpoint import checkpoint +import numbers +import einops +import numpy as np +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.misc import to_2tuple +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.hook import HookManager + + +class LayerNorm(nn.Module): + """Subclass torch's LayerNorm (with cast back to input dtype).""" + + def __init__( + self, + normalized_shape, + eps: float = 1e-5, + elementwise_affine: bool = True, + device=None, + dtype=None, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + if isinstance(normalized_shape, numbers.Integral): + # mypy error: incompatible types in assignment + normalized_shape = (normalized_shape,) # type: ignore[assignment] + self.normalized_shape = tuple(normalized_shape) # type: ignore[arg-type] + self.eps = eps + self.elementwise_affine = elementwise_affine + if self.elementwise_affine: + self.weight = torch.nn.Parameter( + torch.empty( + self.normalized_shape, + ) + ) + self.bias = torch.nn.Parameter( + torch.empty( + self.normalized_shape, + ) + ) + else: + self.register_parameter("weight", None) + self.register_parameter("bias", None) + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + assert self.normalized_shape == x.shape[-len(self.normalized_shape) :] + dims = [-(i + 1) for i in range(len(self.normalized_shape))] + mean = self.hook("mean", ret=x.mean(dim=dims, keepdim=True)) + mean_x2 = (x**2).mean(dim=dims, keepdim=True) + var = mean_x2 - mean**2 + x_norm = self.hook("mean_reduced", ret=(x - mean)) / self.hook( + "sqrt_var", ret=torch.sqrt(var + self.eps) + ) + if self.elementwise_affine: + x_norm = self.hook("renorm.post", ret=self.weight * x_norm + self.bias) + self.hook.finalize() + return x_norm.to(orig_type) + + +class QuickGELU(nn.Module): + # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class LayerScale(nn.Module): + def __init__(self, dim, init_values=1e-5, inplace=False): + super().__init__() + self.inplace = inplace + self.gamma = nn.Parameter(init_values * torch.ones(dim)) + + def forward(self, x): + raise ValueError("Not implemented") + return x.mul_(self.gamma) if self.inplace else x * self.gamma + + +class PatchDropout(nn.Module): + """ + https://arxiv.org/abs/2212.00794 + """ + + def __init__(self, prob, exclude_first_token=True): + super().__init__() + assert 0 <= prob < 1.0 + self.prob = prob + self.exclude_first_token = exclude_first_token # exclude CLS token + + def forward(self, x): + if not self.training or self.prob == 0.0: + return x + + if self.exclude_first_token: + cls_tokens, x = x[:, :1], x[:, 1:] + else: + cls_tokens = torch.jit.annotate(torch.Tensor, x[:, :1]) + + batch = x.size()[0] + num_tokens = x.size()[1] + + batch_indices = torch.arange(batch) + batch_indices = batch_indices[..., None] + + keep_prob = 1 - self.prob + num_patches_keep = max(1, int(num_tokens * keep_prob)) + + rand = torch.randn(batch, num_tokens) + patch_indices_keep = rand.topk(num_patches_keep, dim=-1).indices + + x = x[batch_indices, patch_indices_keep] + + if self.exclude_first_token: + x = torch.cat((cls_tokens, x), dim=1) + + return x + + +class Attention(nn.Module): + def __init__( + self, + dim, + num_heads=8, + qkv_bias=True, + scaled_cosine=False, + scale_heads=False, + logit_scale_max=math.log(1.0 / 0.01), + attn_drop=0.0, + proj_drop=0.0, + ): + super().__init__() + self.scaled_cosine = scaled_cosine + self.scale_heads = scale_heads + assert dim % num_heads == 0, "dim should be divisible by num_heads" + self.num_heads = num_heads + self.head_dim = dim // num_heads + self.scale = self.head_dim**-0.5 + self.logit_scale_max = logit_scale_max + + # keeping in_proj in this form (instead of nn.Linear) to match weight scheme of original + self.in_proj_weight = nn.Parameter(torch.randn((dim * 3, dim)) * self.scale) + if qkv_bias: + self.in_proj_bias = nn.Parameter(torch.zeros(dim * 3)) + else: + self.in_proj_bias = None + + if self.scaled_cosine: + self.logit_scale = nn.Parameter( + torch.log(10 * torch.ones((num_heads, 1, 1))) + ) + else: + self.logit_scale = None + self.attn_drop = nn.Dropout(attn_drop) + if self.scale_heads: + self.head_scale = nn.Parameter(torch.ones((num_heads, 1, 1))) + else: + self.head_scale = None + self.out_proj = nn.Linear(dim, dim) + self.out_drop = nn.Dropout(proj_drop) + + def forward(self, x, attn_mask: Optional[torch.Tensor] = None): + L, N, C = x.shape + q, k, v = F.linear(x, self.in_proj_weight, self.in_proj_bias).chunk(3, dim=-1) + q = q.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + k = k.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + v = v.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1) + + if self.logit_scale is not None: + attn = torch.bmm( + F.normalize(q, dim=-1), F.normalize(k, dim=-1).transpose(-1, -2) + ) + logit_scale = torch.clamp(self.logit_scale, max=self.logit_scale_max).exp() + attn = attn.view(N, self.num_heads, L, L) * logit_scale + attn = attn.view(-1, L, L) + else: + q = q * self.scale + attn = torch.bmm(q, k.transpose(-1, -2)) + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + new_attn_mask = torch.zeros_like(attn_mask, dtype=q.dtype) + new_attn_mask.masked_fill_(attn_mask, float("-inf")) + attn_mask = new_attn_mask + attn += attn_mask + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = torch.bmm(attn, v) + if self.head_scale is not None: + x = x.view(N, self.num_heads, L, C) * self.head_scale + x = x.view(-1, L, C) + x = x.transpose(0, 1).reshape(L, N, C) + x = self.out_proj(x) + x = self.out_drop(x) + return x + + +class AttentionalPooler(nn.Module): + def __init__( + self, + d_model: int, + context_dim: int, + n_head: int = 8, + n_queries: int = 256, + norm_layer: Callable = LayerNorm, + ): + super().__init__() + self.query = nn.Parameter(torch.randn(n_queries, d_model)) + self.attn = nn.MultiheadAttention( + d_model, n_head, kdim=context_dim, vdim=context_dim + ) + self.ln_q = norm_layer(d_model) + self.ln_k = norm_layer(context_dim) + + def forward(self, x: torch.Tensor): + x = self.ln_k(x).permute(1, 0, 2) # NLD -> LND + N = x.shape[1] + q = self.ln_q(self.query) + out = self.attn(self._repeat(q, N), x, x, need_weights=False)[0] + return out.permute(1, 0, 2) # LND -> NLD + + def _repeat(self, query, N: int): + return query.unsqueeze(1).repeat(1, N, 1) + + +class MLP(nn.Module): + def __init__( + self, + d_model: int, + mlp_width: int, + act_layer: Callable = nn.GELU, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.c_fc = nn.Linear(d_model, mlp_width) + self.gelu = act_layer() + self.c_proj = nn.Linear(mlp_width, d_model) + + def forward(self, x): + x = self.hook("c_fc.post", ret=self.c_fc(x)) + x = self.hook("gelu.post", ret=self.gelu(x)) + x = self.hook("c_proj.post", ret=self.c_proj(x)) + self.hook.finalize() + return x + + +class MultiheadAttention(nn.Module): + """ + There are variety of ways to look at multihead attention. Because of that I implemented a few so it will be easy to compare. + """ + + def __init__( + self, + embed_dim, + num_heads, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + kdim=None, + vdim=None, + batch_first=False, + device=None, + dtype=None, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self._qkv_same_embed_dim = self.kdim == embed_dim and self.vdim == embed_dim + + self.num_heads = num_heads + self.dropout = dropout + self.batch_first = batch_first + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.in_proj_weight = nn.Parameter(torch.empty((3 * embed_dim, embed_dim))) + + if bias: + self.in_proj_bias = nn.Parameter(torch.empty(3 * embed_dim)) + else: + self.register_parameter("in_proj_bias", None) + self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias) + + if add_bias_kv: + self.bias_k = nn.Parameter(torch.empty((1, 1, embed_dim))) + self.bias_v = nn.Parameter(torch.empty((1, 1, embed_dim))) + else: + self.bias_k = self.bias_v = None + + self.add_zero_attn = add_zero_attn + + def forward_direct(self, x, attn_mask=None): + B, N, C = x.shape + qkv = self.hook( + "in_proj_bias.post", + ret=self.hook("in_proj.post", ret=x @ self.in_proj_weight.T) + + self.in_proj_bias, + ) + qkv = qkv.reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4) + q, k, v = qkv.unbind(0) + k = self.hook("k", ret=k) + q = self.hook("q", ret=q) + v = self.hook("v", ret=v) + dk = q.size()[-1] + q = q / math.sqrt(dk) + q = self.hook("q_norm", ret=q) + attn = q @ k.transpose(-2, -1) # [B, H, N, N] + attn = self.hook("pre_mask", ret=attn) + if attn_mask is not None: + attn += attn_mask + attn = self.hook("post_mask", ret=attn) + attn = attn.softmax(dim=-1) + attn = self.hook("post_softmax", ret=attn) + x = attn @ v + + x = x.transpose(1, 2).reshape(B, N, C) + x = self.hook("attn_v", ret=x) + x = self.hook( + "out_proj_bias.post", + ret=self.hook("out_proj.post", ret=x @ self.out_proj.weight.T) + + self.out_proj.bias, + ) + return x + + def _split_qkv_weight(self): + q_weight, k_weight, v_weight = ( + self.in_proj_weight[: self.embed_dim].reshape( + self.num_heads, self.head_dim, -1 + ), + self.in_proj_weight[self.embed_dim : self.embed_dim * 2].reshape( + self.num_heads, self.head_dim, -1 + ), + self.in_proj_weight[self.embed_dim * 2 :].reshape( + self.num_heads, self.head_dim, -1 + ), + ) + return q_weight, k_weight, v_weight + + def _split_qkv_bias(self): + q_bias, k_bias, v_bias = ( + self.in_proj_bias[: self.embed_dim].reshape( + 1, self.num_heads, 1, self.head_dim + ), + self.in_proj_bias[self.embed_dim : self.embed_dim * 2].reshape( + 1, self.num_heads, 1, self.head_dim + ), + self.in_proj_bias[self.embed_dim * 2 :].reshape( + 1, self.num_heads, 1, self.head_dim + ), + ) + return q_bias, k_bias, v_bias + + def forward_qkv(self, x, attn_mask=None): + B, N, C = x.shape + q_weight, k_weight, v_weight = ( + self.in_proj_weight[: self.embed_dim], + self.in_proj_weight[self.embed_dim : self.embed_dim * 2], + self.in_proj_weight[self.embed_dim * 2 :], + ) + q_bias, k_bias, v_bias = ( + self.in_proj_bias[: self.embed_dim], + self.in_proj_bias[self.embed_dim : self.embed_dim * 2], + self.in_proj_bias[self.embed_dim * 2 :], + ) + q = ( + self.hook( + "in_q_bias.post", + ret=self.hook("in_q.post", ret=x @ q_weight.T) + q_bias, + ) + .reshape(B, N, self.num_heads, self.head_dim) + .permute(0, 2, 1, 3) + ) + k = ( + self.hook( + "in_k_bias.post", + ret=self.hook("in_k.post", ret=x @ k_weight.T) + k_bias, + ) + .reshape(B, N, self.num_heads, self.head_dim) + .permute(0, 2, 1, 3) + ) + v = ( + self.hook( + "in_v_bias.post", + ret=self.hook("in_v.post", ret=x @ v_weight.T) + v_bias, + ) + .reshape(B, N, self.num_heads, self.head_dim) + .permute(0, 2, 1, 3) + ) + dk = q.size()[-1] + q = q / math.sqrt(dk) + q = self.hook("q_norm", ret=q) + attn = q @ k.transpose(-2, -1) + attn = self.hook("attention.pre_mask", ret=attn) + if attn_mask is not None: + attn += attn_mask + attn = self.hook("attention.post_mask", ret=attn) + attn = attn.softmax(dim=-1) + attn = self.hook("attention.post_softmax", ret=attn) # [B, H, N, N] + x = torch.einsum("bhnm,bhmc->bhnmc", attn, v) + x = self.hook("extended_attn_v", ret=x) + x = x.sum(axis=3).transpose(1, 2).reshape(B, N, C) + x = self.hook("attn_v", ret=x) + x = self.hook( + "out.post_bias", + ret=self.hook("out.post", ret=x @ self.out_proj.weight.T) + + self.out_proj.bias, + ) + return x + + def forward_per_head_no_spatial(self, x, attn_mask=None): + B, N, C = x.shape + q_weight, k_weight, v_weight = self._split_qkv_weight() + q_bias, k_bias, v_bias = self._split_qkv_bias() + q = self.hook( + "in_q_bias.post", + ret=self.hook("in_q.post", ret=torch.einsum("bnc,hdc->bhnd", x, q_weight)) + + q_bias, + ) + k = self.hook( + "in_k_bias.post", + ret=self.hook("in_k.post", ret=torch.einsum("bnc,hdc->bhnd", x, k_weight)) + + k_bias, + ) + v = self.hook( + "in_v_bias.post", + ret=self.hook("in_v.post", ret=torch.einsum("bnc,hdc->bhnd", x, v_weight)) + + v_bias, + ) # (B, self.num_heads, N, self.head_dim) + dk = q.size()[-1] + q = q / math.sqrt(dk) + q = self.hook("q_norm", ret=q) + attn = q @ k.transpose(-2, -1) + attn = self.hook("attention.pre_mask", ret=attn) + if attn_mask is not None: + attn += attn_mask + attn = self.hook("attention.post_mask", ret=attn) + attn = attn.softmax(dim=-1) + attn = self.hook("attention.post_softmax", ret=attn) # [B, H, N, N] + x = torch.einsum( + "bhnm,bhmc->bnhc", attn, v + ) # We also switch here back from head-first to n-first + x = self.hook("attn_v", ret=x) + x = self.hook( + "out.post", + ret=torch.einsum( + "bnhc,dhc->bnhd", + x, + self.out_proj.weight.reshape( + self.embed_dim, self.num_heads, self.head_dim + ), + ), + ) + x = self.hook("out.post_collapse", ret=x.sum(axis=2)) + x = self.hook("out.post_bias", ret=x + self.out_proj.bias) + return x + + + def forward_per_head(self, x, attn_mask=None): + B, N, C = x.shape + q_weight, k_weight, v_weight = self._split_qkv_weight() + q_bias, k_bias, v_bias = self._split_qkv_bias() + q = self.hook( + "in_q_bias.post", + ret=self.hook("in_q.post", ret=torch.einsum("bnc,hdc->bhnd", x, q_weight)) + + q_bias, + ) + k = self.hook( + "in_k_bias.post", + ret=self.hook("in_k.post", ret=torch.einsum("bnc,hdc->bhnd", x, k_weight)) + + k_bias, + ) + v = self.hook( + "in_v_bias.post", + ret=self.hook("in_v.post", ret=torch.einsum("bnc,hdc->bhnd", x, v_weight)) + + v_bias, + ) # (B, self.num_heads, N, self.head_dim) + dk = q.size()[-1] + q = q / math.sqrt(dk) + q = self.hook("q_norm", ret=q) + attn = q @ k.transpose(-2, -1) + attn = self.hook("attention.pre_mask", ret=attn) + if attn_mask is not None: + attn += attn_mask + attn = self.hook("attention.post_mask", ret=attn) + attn = attn.softmax(dim=-1) + attn = self.hook("attention.post_softmax", ret=attn) # [B, H, N, N] + x = torch.einsum( + "bhnm,bhmc->bnmhc", attn, v + ) # We also switch here back from head-first to n-first + x = self.hook("extended_attn_v", ret=x) + x = self.hook( + "out.post", + ret=torch.einsum( + "bnmhc,dhc->bnmhd", + x, + self.out_proj.weight.reshape( + self.embed_dim, self.num_heads, self.head_dim + ), + ), + ) + x = self.hook("out.post_collapse", ret=x.sum(axis=[2, 3])) + x = self.hook("out.post_bias", ret=x + self.out_proj.bias) + return x + + def _get_ov_circuit( + self, + ): + reshaped_o = self.out_proj.weight.reshape( + self.embed_dim, self.num_heads, self.head_dim + ) + _, _, v_weight = self._split_qkv_weight() # num_heads, head_dim, embed_dim + _, _, v_bias = self._split_qkv_bias() # 1, num_heads, 1, head_dim + ov_circuit = torch.einsum("onh,nhi->oni", reshaped_o, v_weight) + ov_bias_circuit = torch.einsum( + "onh,bnxh->bnxo", reshaped_o, v_bias + ) # [1, num_heads, 1, embed_dim] + return ov_circuit, ov_bias_circuit + + def forward_ov_circuit(self, x, attn_mask=None): + B, N, C = x.shape + q_weight, k_weight, _ = self._split_qkv_weight() + q_bias, k_bias, _ = self._split_qkv_bias() + q = self.hook( + "in_q_bias.post", + ret=self.hook("in_q.post", ret=torch.einsum("bnc,hdc->bhnd", x, q_weight)) + + q_bias, + ) + k = self.hook( + "in_k_bias.post", + ret=self.hook("in_k.post", ret=torch.einsum("bnc,hdc->bhnd", x, k_weight)) + + k_bias, + ) + ov, ov_bias = self._get_ov_circuit() + ov = self.hook("ov", ret=ov) + ov_bias = self.hook("ov_bias", ret=ov_bias) + v = self.hook( + "ov_bias.post", + ret=self.hook("ov.post", ret=torch.einsum("bnc,dhc->bhnd", x, ov)) + + ov_bias, + ) + + dk = q.size()[-1] + q = q / math.sqrt(dk) + q = self.hook("q_norm", ret=q) + attn = q @ k.transpose(-2, -1) + attn = self.hook("attention.pre_mask", ret=attn) + if attn_mask is not None: + attn += attn_mask + attn = self.hook("attention.post_mask", ret=attn) + attn = attn.softmax(dim=-1) + attn = self.hook("attention.post_softmax", ret=attn) # [B, H, N, N] + x = torch.einsum( + "bhnm,bhmc->bnmhc", attn, v + ) # We also switch here back from head-first to n-first + x = self.hook("extended_attn_ov", ret=x) + x = self.hook("out.post_collapse", ret=x.sum(axis=[2, 3])) + x = self.hook("out.post_bias", ret=x + self.out_proj.bias) + return x + + def forward(self, x, attn_mask=None, method: Text = "ov_circuit"): + if method == "direct": + x = self.forward_direct(x, attn_mask=attn_mask) + elif method == "qkv": + x = self.forward_qkv(x, attn_mask=attn_mask) + elif method == "head": + x = self.forward_per_head(x, attn_mask=attn_mask) + elif method == "head_no_spatial": + x = self.forward_per_head_no_spatial(x, attn_mask=attn_mask) + elif method == "ov_circuit": + x = self.forward_ov_circuit(x, attn_mask=attn_mask) + else: + raise NotImplementedError('Unknown attention method') + self.hook.finalize() + + return x + + +class ResidualAttentionBlock(nn.Module): + def __init__( + self, + d_model: int, + n_head: int, + mlp_ratio: float = 4.0, + ls_init_value: float = None, + act_layer: Callable = nn.GELU, + norm_layer: Callable = LayerNorm, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.ln_1 = norm_layer(d_model, hook=hook.fork("ln_1")) + self.attn = MultiheadAttention(d_model, n_head, hook=hook.fork("attn")) + + self.ls_1 = ( + LayerScale(d_model, ls_init_value) + if ls_init_value is not None + else nn.Identity() + ) + + self.ln_2 = norm_layer(d_model, hook=hook.fork("ln_2")) + mlp_width = int(d_model * mlp_ratio) + self.mlp = MLP(d_model, mlp_width, act_layer=act_layer, hook=hook.fork("mlp")) + self.ls_2 = ( + LayerScale(d_model, ls_init_value) + if ls_init_value is not None + else nn.Identity() + ) + + def attention( + self, + q_x: torch.Tensor, + attn_mask: Optional[torch.Tensor] = None, + method: Text = "direct", + ): + attn_mask = attn_mask.to(q_x.dtype) if attn_mask is not None else None + return self.attn(q_x, attn_mask=attn_mask, method=method) + + def forward( + self, + q_x: torch.Tensor, + attn_mask: Optional[torch.Tensor] = None, + attn_method: Text = "direct", + ): + q_x = self.hook("pre", ret=q_x) + after_ln1 = self.ln_1(q_x) + after_attn = self.attention( + q_x=after_ln1, attn_mask=attn_mask, method=attn_method + ) + after_attn = self.hook("after_attn", ret=after_attn) + x = q_x + self.ls_1(after_attn) + after_ln2 = self.ln_2(x) + after_mlp = self.mlp(after_ln2) + after_mlp = self.hook("after_mlp", ret=after_mlp) + x = x + self.ls_2(after_mlp) + x = self.hook("post", ret=x) + self.hook.finalize() + return x + + +class Transformer(nn.Module): + def __init__( + self, + width: int, + layers: int, + heads: int, + mlp_ratio: float = 4.0, + ls_init_value: float = None, + act_layer: Callable = nn.GELU, + norm_layer: Callable = LayerNorm, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.width = width + self.layers = layers + self.grad_checkpointing = False + + self.resblocks = nn.ModuleList( + [ + ResidualAttentionBlock( + width, + heads, + mlp_ratio, + ls_init_value=ls_init_value, + act_layer=act_layer, + norm_layer=norm_layer, + hook=hook.fork(f"resblocks.{i}"), + ) + for i in range(layers) + ] + ) + + def get_cast_dtype(self) -> torch.dtype: + if hasattr(self.resblocks[0].mlp.c_fc, "int8_original_dtype"): + return self.resblocks[0].mlp.c_fc.int8_original_dtype + return self.resblocks[0].mlp.c_fc.weight.dtype + + def forward( + self, + x: torch.Tensor, + attn_mask: Optional[torch.Tensor] = None, + attn_method: Text = "direct", + ): + for r in self.resblocks: + if self.grad_checkpointing and not torch.jit.is_scripting(): + raise ValueError("grad_checkpointing not implement") + # TODO: handle kwargs https://github.com/pytorch/pytorch/issues/79887#issuecomment-1161758372 + x = checkpoint(r, x, None, None, attn_mask) + else: + x = r(x, attn_mask=attn_mask, attn_method=attn_method) + self.hook.finalize() + return x + + +class VisionTransformer(nn.Module): + output_tokens: torch.jit.Final[bool] + + def __init__( + self, + image_size: int, + patch_size: int, + width: int, + layers: int, + heads: int, + mlp_ratio: float, + ls_init_value: float = None, + global_average_pool: bool = False, + attentional_pool: bool = False, + n_queries: int = 256, + attn_pooler_heads: int = 8, + output_dim: int = 512, + patch_dropout: float = 0.0, + input_patchnorm: bool = False, + act_layer: Callable = nn.GELU, + norm_layer: Callable = LayerNorm, + output_tokens: bool = False, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.output_tokens = output_tokens + image_height, image_width = self.image_size = to_2tuple(image_size) + patch_height, patch_width = self.patch_size = to_2tuple(patch_size) + self.grid_size = (image_height // patch_height, image_width // patch_width) + self.output_dim = output_dim + + # whether to layernorm each patch, as done in dual patchnorm paper - https://arxiv.org/abs/2302.01327v1 + self.input_patchnorm = input_patchnorm + + if input_patchnorm: + patch_input_dim = patch_height * patch_width * 3 + self.patchnorm_pre_ln = LayerNorm( + patch_input_dim, hook=hook.fork("patchnorm_pre_ln") + ) + self.conv1 = nn.Linear(patch_input_dim, width) + else: + self.patchnorm_pre_ln = nn.Identity() + self.conv1 = nn.Conv2d( + in_channels=3, + out_channels=width, + kernel_size=patch_size, + stride=patch_size, + bias=False, + ) + + # class embeddings and positional embeddings + scale = width**-0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter( + scale * torch.randn(self.grid_size[0] * self.grid_size[1] + 1, width) + ) + + # setting a patch_dropout of 0. would mean it is disabled and this function would be the identity fn + self.patch_dropout = ( + PatchDropout(patch_dropout) if patch_dropout > 0.0 else nn.Identity() + ) + + self.ln_pre = norm_layer(width, hook=hook.fork("ln_pre")) + self.transformer = Transformer( + width, + layers, + heads, + mlp_ratio, + ls_init_value=ls_init_value, + act_layer=act_layer, + norm_layer=norm_layer, + hook=hook.fork("transformer"), + ) + + self.global_average_pool = global_average_pool + if attentional_pool: + self.attn_pool = AttentionalPooler( + output_dim, width, n_head=attn_pooler_heads, n_queries=n_queries + ) + self.ln_post = norm_layer(output_dim, hook=hook.fork("ln_post")) + self.proj = nn.Parameter(scale * torch.randn(output_dim, output_dim)) + else: + self.attn_pool = None + self.ln_post = norm_layer(width, hook=hook.fork("ln_post")) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.transformer.grad_checkpointing = enable + + def _global_pool(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + if self.global_average_pool: + return x.mean(dim=1), x + else: + return x[:, 0], x[:, 1:] + + def forward(self, x: torch.Tensor, attn_method: Text = "direct"): + + # to patches - whether to use dual patchnorm - https://arxiv.org/abs/2302.01327v1 + if self.input_patchnorm: + # einops - rearrange(x, 'b c (h p1) (w p2) -> b (h w) (c p1 p2)') + x = x.reshape( + x.shape[0], + x.shape[1], + self.grid_size[0], + self.patch_size[0], + self.grid_size[1], + self.patch_size[1], + ) + x = x.permute(0, 2, 4, 1, 3, 5) + x = x.reshape(x.shape[0], self.grid_size[0] * self.grid_size[1], -1) + x = self.hook("patchnorm_pre_ln.post", ret=self.patchnorm_pre_ln(x)) + x = self.hook("conv1.post", ret=self.conv1(x)) + else: + x = self.hook( + "conv1.post", ret=self.conv1(x) + ) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + + # class embeddings and positional embeddings + x = torch.cat( + [ + self.class_embedding.to(x.dtype) + + torch.zeros( + x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device + ), + x, + ], + dim=1, + ) # shape = [*, grid ** 2 + 1, width] + x = self.hook( + "positional_embedding.post", ret=x + self.positional_embedding.to(x.dtype) + ) + + # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in + x = self.hook("patch_dropout.post", ret=self.patch_dropout(x)) + x = self.hook("ln_pre_post", ret=self.ln_pre(x)) + # x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x, attn_method=attn_method) + # x = x.permute(1, 0, 2) # LND -> NLD + if self.attn_pool is not None: + x = self.hook("attn_pool.post", ret=self.attn_pool(x)) + x = self.hook("ln_post_post", ret=self.ln_post(x)) + pooled, tokens = self.hook("global_pool.post", ret=self._global_pool(x)) + else: + pooled, tokens = self.hook("global_pool.post", ret=self._global_pool(x)) + pooled = self.hook("ln_post_post", ret=self.ln_post(pooled)) + + if self.proj is not None: + pooled = self.hook( + "proj.post", ret=self.hook("proj.pre", ret=pooled) @ self.proj + ) + + self.hook.finalize() + + if self.output_tokens: + return pooled, tokens + + return pooled + + +class TextTransformer(nn.Module): + output_tokens: torch.jit.Final[bool] + + def __init__( + self, + context_length: int = 77, + vocab_size: int = 49408, + width: int = 512, + heads: int = 8, + layers: int = 12, + ls_init_value: float = None, + output_dim: int = 512, + act_layer: Callable = nn.GELU, + norm_layer: Callable = LayerNorm, + embed_cls: bool = False, + pad_id: int = 0, + output_tokens: bool = False, + hook: Optional[HookManager] = None, + ): + super().__init__() + self.hook = hook or HookManager() + self.output_tokens = output_tokens + self.num_pos = self.context_length = context_length + self.vocab_size = vocab_size + self.width = width + self.output_dim = output_dim + self.heads = heads + self.pad_id = pad_id + + self.text_projection = nn.Parameter(torch.empty(width, output_dim)) + + if embed_cls: + self.cls_emb = nn.Parameter(torch.empty(width)) + self.num_pos += 1 + else: + self.cls_emb = None + + self.token_embedding = nn.Embedding(vocab_size, width) + self.positional_embedding = nn.Parameter(torch.empty(self.num_pos, width)) + self.transformer = Transformer( + width=width, + layers=layers, + heads=heads, + ls_init_value=ls_init_value, + act_layer=act_layer, + norm_layer=norm_layer, + hook=self.hook.fork("transformer"), + ) + self.ln_final = norm_layer(width) + + self.register_buffer("attn_mask", self.build_attention_mask(), persistent=False) + + self.init_parameters() + + def init_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + if self.cls_emb is not None: + nn.init.normal_(self.cls_emb, std=0.01) + + proj_std = (self.transformer.width**-0.5) * ( + (2 * self.transformer.layers) ** -0.5 + ) + attn_std = self.transformer.width**-0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width**-0.5) + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.transformer.grad_checkpointing = enable + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.num_pos, self.num_pos) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + def build_cls_mask(self, text, cast_dtype: torch.dtype): + cls_mask = (text != self.pad_id).unsqueeze(1) + cls_mask = F.pad(cls_mask, (1, 0, cls_mask.shape[2], 0), value=1.0) + additive_mask = torch.empty( + cls_mask.shape, dtype=cast_dtype, device=cls_mask.device + ) + additive_mask.fill_(0) + additive_mask.masked_fill_(~cls_mask, float("-inf")) + additive_mask = torch.repeat_interleave(additive_mask, self.heads, 0) + return additive_mask + + def _repeat(self, t, N: int): + return t.reshape(1, 1, -1).repeat(N, 1, 1) + + def forward(self, text, attn_method: Text = "direct"): + cast_dtype = self.transformer.get_cast_dtype() + seq_len = text.shape[1] + + x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model] + attn_mask = self.attn_mask + if self.cls_emb is not None: + seq_len += 1 + x = torch.cat([x, self._repeat(self.cls_emb, x.shape[0])], dim=1) + cls_mask = self.build_cls_mask(text, cast_dtype) + attn_mask = ( + attn_mask[None, :seq_len, :seq_len] + cls_mask[:, :seq_len, :seq_len] + ) + + x = x + self.positional_embedding[:seq_len].to(cast_dtype) + # x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x, attn_mask=attn_mask, attn_method=attn_method) + # x = x.permute(1, 0, 2) # LND -> NLD + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + if self.cls_emb is not None: + pooled, tokens = x[:, -1], x[:, :-1] + pooled = self.ln_final(pooled) + else: + x = self.ln_final(x) + pooled, tokens = x[torch.arange(x.shape[0]), text.argmax(dim=-1)], x + + if self.text_projection is not None: + pooled = pooled @ self.text_projection + + self.hook.finalize() + + if self.output_tokens: + return pooled, tokens + + return pooled diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span/utils/visualization.py b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/visualization.py new file mode 100644 index 0000000000000000000000000000000000000000..54cc0be5eb0ef0ad856cfa40264da5a19c534d1a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span/utils/visualization.py @@ -0,0 +1,30 @@ +from PIL import Image + +## Imports +from PIL import Image +from torchvision import transforms + + +def _convert_to_rgb(image): + return image.convert("RGB") + + +visualization_preprocess = transforms.Compose( + [ + transforms.Resize(size=224, interpolation=Image.BICUBIC), + transforms.CenterCrop(size=(224, 224)), + _convert_to_rgb, + ] +) + + +def image_grid(imgs, rows, cols): + assert len(imgs) == rows * cols + + w, h = imgs[0].size + grid = Image.new("RGB", size=(cols * w, rows * h)) + grid_w, grid_h = grid.size + + for i, img in enumerate(imgs): + grid.paste(img, box=(i % cols * w, i // cols * h)) + return grid diff --git a/concept_attention/binary_segmentation_baselines/clip_text_span_baseline.py b/concept_attention/binary_segmentation_baselines/clip_text_span_baseline.py new file mode 100644 index 0000000000000000000000000000000000000000..b4b3a2e8b07e344cb2fc863ad1e991d584405f1f --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/clip_text_span_baseline.py @@ -0,0 +1,92 @@ +import torch +import torch.nn.functional as F +import einops +from torchvision import transforms +from tqdm import tqdm +import PIL + +from concept_attention.binary_segmentation_baselines.clip_text_span.prs_hook import hook_prs_logger +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.factory import create_model_and_transforms, get_tokenizer +from concept_attention.binary_segmentation_baselines.clip_text_span.utils.openai_templates import OPENAI_IMAGENET_TEMPLATES +from concept_attention.segmentation import SegmentationAbstractClass + +class CLIPTextSpanSegmentationModel(SegmentationAbstractClass): + + def __init__( + self, + model_name='ViT-H-14', + pretrained='laion2b_s32b_b79k', + device='cuda:3' + ): + self.device = device + # Load up the clip model and the tokenizer + self.clip_model, _, preprocess = create_model_and_transforms( + model_name, pretrained=pretrained + ) + self.clip_model.to(device) + self.clip_model.eval() + + context_length = self.clip_model.context_length + vocab_size = self.clip_model.vocab_size + self.tokenizer = get_tokenizer(model_name) + self.image_transform = transforms.Compose([ + transforms.Resize((224, 224)), + transforms.ToTensor(), + ]) + + self.prs = hook_prs_logger(self.clip_model, device) + + def generate_clip_vectors_for_concepts(self, concepts: list[str]): + """ + Produces a set of clip vectors for each concept by averaging a set of + templates. + """ + autocast = torch.cuda.amp.autocast + with torch.no_grad(), autocast(): + zeroshot_weights = [] + for classname in tqdm(concepts): + texts = [template(classname) for template in OPENAI_IMAGENET_TEMPLATES] + texts = self.tokenizer(texts).to(self.device) # tokenize + class_embeddings = self.clip_model.encode_text(texts) + class_embedding = F.normalize(class_embeddings, dim=-1).mean(dim=0) + class_embedding /= class_embedding.norm() + zeroshot_weights.append(class_embedding) + zeroshot_weights = torch.stack(zeroshot_weights, dim=1).to(self.device) + + return zeroshot_weights + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + # Apply transform to image + if isinstance(image, PIL.Image.Image): + image = self.image_transform(image) + else: + image = transforms.ToPILImage()(image) + image = self.image_transform(image) + if len(image.shape) == 3: + image = image.unsqueeze(0) + image_size = image.shape[-1] + # Compute CLIP vectors for each text concept + concept_vectors = self.generate_clip_vectors_for_concepts(concepts) + concept_vectors = concept_vectors.detach().cpu() + # Create the encodings for the image + self.prs.reinit() + representation = self.clip_model.encode_image( + image.to(self.device), attn_method="head", normalize=False + ) + attentions, _ = self.prs.finalize(representation) + representation = representation.detach().cpu() + attentions = attentions.detach().cpu() # [b, l, n, h, d] + # chosen_class = (representation @ concept_vectors).argmax(axis=1) + attentions_collapse = attentions[:, :, 1:].sum(axis=(1, 3)) + concept_heatmaps = ( + attentions_collapse @ concept_vectors + ) # [b, n, classes] + # Now reshape the heatmaps + patches = image_size // self.clip_model.visual.patch_size[0] + concept_heatmaps = einops.rearrange( + concept_heatmaps, + "1 (h w) concepts -> concepts h w", + h=patches, w=patches + ) + # NOTE: none corresponds to reconstructed image which does not exist for this model + return concept_heatmaps, None diff --git a/concept_attention/binary_segmentation_baselines/daam_flux.py b/concept_attention/binary_segmentation_baselines/daam_flux.py new file mode 100644 index 0000000000000000000000000000000000000000..e669ae6e704c55d4298216a3e78b10c5facb28d7 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/daam_flux.py @@ -0,0 +1,95 @@ +""" + Here we reproduce DAAM, but for Flux DiT models. This is effectively a visualization of the cross attention + layers of a Flux model. +""" +from torch import nn +import torch +import einops + +from concept_attention.image_generator import FluxGenerator +from concept_attention.segmentation import SegmentationAbstractClass + +class DAAM(nn.Module): + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + ): + """ + Initialize the DAAM model. + """ + super(DAAM, self).__init__() + # Load up the flux generator + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + # Unpack the tokenizer + self.tokenizer = self.generator.t5.tokenizer + + def __call__( + self, + prompt, + seed=4, + num_steps=4, + timesteps=None, + layers=None + ): + """ + Generate cross attention heatmap visualizations. + + Args: + - prompt: str, the prompt to generate the visualizations for + - seed: int, the seed to use for the visualization + + Returns: + - attention_maps: torch.Tensor, the attention maps for the prompt + - tokens: list[str], the tokens in the prompt + - image: torch.Tensor, the image generated by the + """ + if timesteps is None: + timesteps = list(range(num_steps)) + if layers is None: + layers = list(range(19)) + # Run the tokenizer and get list of the tokens + token_strings = self.tokenizer.tokenize(prompt) + # Run the image generator + image = self.generator.generate_image( + width=1024, + height=1024, + num_steps=num_steps, + guidance=0.0, + seed=seed, + prompt=prompt, + concepts=token_strings + ) + # Pull out and average the attention maps + cross_attention_maps = [] + for double_block in self.generator.model.double_blocks: + cross_attention_map = torch.stack( + double_block.cross_attention_maps + ).squeeze(1) + # Clear out the layer (always same) + double_block.clear_cached_vectors() + # Append to the list + cross_attention_maps.append(cross_attention_map) + # Stack layers + cross_attention_maps = torch.stack(cross_attention_maps).to(torch.float32) + # Pull out the desired timesteps + cross_attention_maps = cross_attention_maps[:, timesteps] + # Pull out the desired layers + cross_attention_maps = cross_attention_maps[layers] + # Average over layers and time + attention_maps = einops.reduce( + cross_attention_maps, + "layers time concepts height width -> concepts height width", + reduction="mean" + ) + # Pull out only token length attention maps + attention_maps = attention_maps[:len(token_strings)] + + return attention_maps, token_strings, image + \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/daam_sd2.py b/concept_attention/binary_segmentation_baselines/daam_sd2.py new file mode 100644 index 0000000000000000000000000000000000000000..e61abb2a9acf0ac838f14940175b840387737d81 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/daam_sd2.py @@ -0,0 +1,158 @@ +import PIL +import torch +from daam import trace +from diffusers import DiffusionPipeline, StableDiffusionPipeline +from diffusers.utils.torch_utils import randn_tensor + +import matplotlib.pyplot as plt + +from concept_attention.segmentation import SegmentationAbstractClass + +def retrieve_latents(encoder_output, generator, sample_mode="sample"): + if hasattr(encoder_output, "latent_dist") and sample_mode == "sample": + return encoder_output.latent_dist.sample(generator) + elif hasattr(encoder_output, "latent_dist") and sample_mode == "argmax": + return encoder_output.latent_dist.mode() + elif hasattr(encoder_output, "latents"): + return encoder_output.latents + else: + raise AttributeError("Could not access latents of provided encoder_output") + +class DAAMStableDiffusion2SegmentationModel(SegmentationAbstractClass): + + def __init__(self, device='cuda:3'): + # Load the SDXL Pipeline + model_id = 'stabilityai/stable-diffusion-2-base' + self.pipeline = StableDiffusionPipeline.from_pretrained(model_id, use_auth_token=True) + self.pipeline = self.pipeline.to(device) + self.device = device + + def _encode_image(self, image: PIL.Image.Image, timestep, height=512, width=512): + # Preprocess the image + init_image = self.pipeline.image_processor.preprocess( + image, + height=height, + width=width, + ) + init_image = init_image.to(dtype=torch.float32) # Make sure float 32 cause otherwise vae encoder doesnt work + init_image = init_image.to(device=self.device) + init_latents = retrieve_latents(self.pipeline.vae.encode(init_image), generator=None) + init_latents = self.pipeline.vae.config.scaling_factor * init_latents + init_latents = torch.cat([init_latents], dim=0) + shape = init_latents.shape + # Add noise + noise = randn_tensor(shape, generator=None, device=self.device, dtype=self.pipeline.dtype) + init_latents = self.pipeline.scheduler.add_noise(init_latents, noise, timestep) + latents = init_latents + + return latents + + @torch.no_grad() + def _model_forward_pass( + self, + image, + prompt, + timestep=49, + guidance_scale=1.0, + num_inference_steps=50, + height=512, + width=512, + dtype=torch.float32, + batch_size=1, + generator=None, + ): + # Set up timesteps + self.pipeline.scheduler.set_timesteps(num_inference_steps) + timestep = self.pipeline.scheduler.timesteps[timestep] # .to(device=device, dtype=dtype) + # # Encode the image + # self.pipeline( + # image, + # device=self.device, + # num_images_per_prompt=1, + # output_hidden_states=None, + # ) + ########################## Prepare latents ########################## + image_latents = self._encode_image( + image, + timestep + ) + # Add noise at the appropriate timescale + # noise = randn_tensor(image_latents.shape, generator=generator, device=torch.device(self.device), dtype=dtype) + # noisy_latents = self.pipeline.scheduler.add_noise(image_latents, noise, timestep.unsqueeze(0)) + # noisy_latents = self.pipeline.scheduler.scale_model_input(noisy_latents, timestep) + # noisy_latents = noisy_latents.to(device=self.device, dtype=dtype) + # Encode the prompt + prompt_embeds, negative_prompt_embeds = self.pipeline.encode_prompt( + prompt, + self.device, + 1, + True, + None, + # prompt_embeds=prompt_embeds, + # negative_prompt_embeds=negative_prompt_embeds, + lora_scale=0.0, + # clip_skip=self.pipeline.clip_skip, + ) + ########################## Run forward pass ########################## + noise_pred = self.pipeline.unet( + image_latents, + timestep, + encoder_hidden_states=prompt_embeds, + timestep_cond=None, + cross_attention_kwargs=None, + added_cond_kwargs=None, + return_dict=False, + )[0] + ########################## Get and save predicted image ########################## + # image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False, generator=generator)[0] + # do_denormalize = [True] * image.shape[0] + # image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize) + # # Manually do the logic for the scheduler to get the original prediction + # s_churn = 0.0 + # s_tmin = 0.0 + # s_tmax = float("inf") + # s_noise = 1.0 + # # Upcast to avoid precision issues when computing prev_sample + # sample = noisy_latents.to(torch.float32) + # sigma = self.pipeline.scheduler.sigmas[self.pipeline.scheduler.index_for_timestep(timestep)] + # gamma = min(s_churn / (len(self.pipeline.scheduler.sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigma <= s_tmax else 0.0 + # noise = randn_tensor( + # noise_pred.shape, dtype=noise_pred.dtype, device=noise_pred.device, generator=generator + # ) + # eps = noise * s_noise + # sigma_hat = sigma * (gamma + 1) + # if gamma > 0: + # sample = sample + eps * (sigma_hat**2 - sigma**2) ** 0.5 + # pred_original_sample = sample - sigma_hat * noise_pred + # # For testing purposes get the predicted original latents and generate the image for it to verify that the image was encoded properly. + # image = self.pipeline.vae.decode(pred_original_sample / self.pipeline.vae.config.scaling_factor, return_dict=False, generator=generator)[0] + # image = self.pipeline.image_processor.postprocess(image, output_type="pil", do_denormalize=[True for _ in range(batch_size)]) + return None + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, **kwargs): + # Cocnat the concepts into the prompt + modified_caption = caption + ", ".join([f"a {concept}" for concept in concepts]) + # Run the forward pass with daam trace wrapper + concept_heatmaps = [] + with trace(self.pipeline) as tc: + _ = self._model_forward_pass( + image, + caption, + timestep=49, + guidance_scale=7.0, + num_inference_steps=50, + height=512, + width=512, + dtype=torch.float32, + batch_size=1, + ) + + heat_map = tc.compute_global_heat_map(prompt=modified_caption) + # For each concept make a heatmap + for concept in concepts: + concept_heat_map = heat_map.compute_word_heat_map(concept).heatmap + concept_heatmaps.append(concept_heat_map) + + concept_heatmaps = torch.stack(concept_heatmaps, dim=0) + + return concept_heatmaps, None diff --git a/concept_attention/binary_segmentation_baselines/daam_sdxl.py b/concept_attention/binary_segmentation_baselines/daam_sdxl.py new file mode 100644 index 0000000000000000000000000000000000000000..8edd0650e2d3ac99432fedfa73387a6e11b85c34 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/daam_sdxl.py @@ -0,0 +1,191 @@ +import PIL +import torch +from daam import trace +from diffusers import DiffusionPipeline +from diffusers.utils.torch_utils import randn_tensor + +from concept_attention.segmentation import SegmentationAbstractClass + + +class DAAMStableDiffusionXLSegmentationModel(SegmentationAbstractClass): + + def __init__(self, device='cuda:3'): + # Load the SDXL Pipeline + model_id = 'stabilityai/stable-diffusion-xl-base-1.0' + self.pipeline = DiffusionPipeline.from_pretrained( + model_id, + use_auth_token=True, + torch_dtype=torch.float32, + use_safetensors=True + ) + self.pipeline = self.pipeline.to(device) + self.device = device + + def _encode_prompt(self, prompt, guidance_scale=0.0, device="cuda:0"): + # Get the prompt embeddings + prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds = self.pipeline.encode_prompt( + prompt, + None, + device, + True, + negative_prompt=None, + # lora_scale=None, + # clip_skip=None, + ) + + return prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds + + def _encode_image(self, image: PIL.Image.Image, generator=None): + image_latents = self.pipeline.vae.encode(image) + image_latents = image_latents.latent_dist.sample(generator) + image_latents = self.pipeline.vae.config.scaling_factor * image_latents + + return image_latents + + def _process_added_kwargs( + self, + prompt_embeds, + pooled_prompt_embeds, + height=512, + width=512, + ): + add_text_embeds = pooled_prompt_embeds + if self.pipeline.text_encoder_2 is None: + text_encoder_projection_dim = int(pooled_prompt_embeds.shape[-1]) + else: + text_encoder_projection_dim = self.pipeline.text_encoder_2.config.projection_dim + add_time_ids = self.pipeline._get_add_time_ids( + (height, width), + (0, 0), + (height, width), + dtype=prompt_embeds.dtype, + text_encoder_projection_dim=text_encoder_projection_dim, + ) + # Proprocess the text embeddings + added_cond_kwargs = { + "time_ids": add_time_ids.to(device=self.device), + "text_embeds": pooled_prompt_embeds.to(device=self.device), + } + + return added_cond_kwargs + + @torch.no_grad() + def _model_forward_pass( + self, + image, + prompt, + timestep=49, + guidance_scale=1.0, + num_inference_steps=50, + height=512, + width=512, + dtype=torch.float32, + batch_size=1, + generator=None, + ): + # Set up timesteps + self.pipeline.scheduler.set_timesteps(num_inference_steps) + ########################## Prepare latents ########################## + init_image = self.pipeline.image_processor.preprocess( + image, + height=height, + width=width, + # crops_coords=None, + # resize_mode="default" + ) + init_image = init_image.to(dtype=torch.float32) # Make sure float 32 cause otherwise vae encoder doesnt work + init_image = init_image.to(device=self.device) + initial_image_latents = self._encode_image(init_image) + # Figure out the number fo steps to do + timestep = self.pipeline.scheduler.timesteps[timestep] + # Encode the prompt + prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds = self._encode_prompt( + prompt, + guidance_scale=guidance_scale, + device=self.device + ) + # Proprocess the text embeddings + added_cond_kwargs = self._process_added_kwargs( + prompt_embeds, + pooled_prompt_embeds, + width=width, + height=height + ) + # Add noise at the appropriate timescale + noise = randn_tensor(initial_image_latents.shape, device=torch.device(self.device), dtype=dtype) + noisy_latents = self.pipeline.scheduler.add_noise(initial_image_latents, noise, timestep.unsqueeze(0)) + noisy_latents = self.pipeline.scheduler.scale_model_input(noisy_latents, timestep) + noisy_latents = noisy_latents.to(device=self.device, dtype=dtype) + ########################## Run forward pass ########################## + noise_pred = self.pipeline.unet( + noisy_latents, + timestep, + encoder_hidden_states=prompt_embeds, + timestep_cond=None, + cross_attention_kwargs=None, + added_cond_kwargs=added_cond_kwargs, + return_dict=False, + )[0] + ########################## Get and save predicted image ########################## + # # Manually do the logic for the scheduler to get the original prediction + # s_churn = 0.0 + # s_tmin = 0.0 + # s_tmax = float("inf") + # s_noise = 1.0 + # # Upcast to avoid precision issues when computing prev_sample + # sample = noisy_latents.to(torch.float32) + # sigma = self.pipeline.scheduler.sigmas[self.pipeline.scheduler.index_for_timestep(timestep)] + # gamma = min(s_churn / (len(self.pipeline.scheduler.sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigma <= s_tmax else 0.0 + # noise = randn_tensor( + # noise_pred.shape, dtype=noise_pred.dtype, device=noise_pred.device, generator=generator + # ) + # eps = noise * s_noise + # sigma_hat = sigma * (gamma + 1) + # if gamma > 0: + # sample = sample + eps * (sigma_hat**2 - sigma**2) ** 0.5 + # pred_original_sample = sample - sigma_hat * noise_pred + # # For testing purposes get the predicted original latents and generate the image for it to verify that the image was encoded properly. + # image = self.pipeline.vae.decode(pred_original_sample / self.pipeline.vae.config.scaling_factor, return_dict=False, generator=generator)[0] + # image = self.pipeline.image_processor.postprocess(image, output_type="pil", do_denormalize=[True for _ in range(batch_size)]) + + return None + + def segment_individual_image(self, image: torch.Tensor, concepts: list[str], caption: str, num_samples=1, num_inference_steps=50, **kwargs): + # Cocnat the concepts into the prompt + modified_caption = caption+ "," + ", ".join([f"a {concept}" for concept in concepts]) + # Run the forward pass with daam trace wrapper + concept_heatmaps = [] + if num_samples > 1: + timesteps = [49 for _ in range(num_samples)] + # timesteps = list(range(num_samples)) + else: + timesteps = [49] + + all_heatmaps = [] + for timestep in timesteps: + with trace(self.pipeline) as tc: + _ = self._model_forward_pass( + image, + modified_caption, + timestep=timestep, + guidance_scale=7.0, + num_inference_steps=num_inference_steps, + height=512, + width=512, + dtype=torch.float32, + batch_size=1, + ) + print(f"Modified Caption: {modified_caption}") + heat_map = tc.compute_global_heat_map(prompt=modified_caption) + concept_heatmaps = [] + # For each concept make a heatmap + for concept in concepts: + concept_heat_map = heat_map.compute_word_heat_map(concept).heatmap + concept_heatmaps.append(concept_heat_map) + concept_heatmaps = torch.stack(concept_heatmaps, dim=0) + all_heatmaps.append(concept_heatmaps) + + all_heatmaps = torch.stack(all_heatmaps, dim=0) + all_heatmaps = all_heatmaps.mean(0) + + return all_heatmaps, None \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/dino.py b/concept_attention/binary_segmentation_baselines/dino.py new file mode 100644 index 0000000000000000000000000000000000000000..59fc3fe56b7ab1d204bee4a52afdf5f9282ecb24 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/dino.py @@ -0,0 +1,69 @@ +import torch +from torchvision import transforms +import torch.nn as nn +import numpy as np + +from concept_attention.segmentation import SegmentationAbstractClass +import concept_attention.binary_segmentation_baselines.dino_src.vision_transformer as vits + +class DINOSegmentationModel(SegmentationAbstractClass): + + def __init__(self, arch="vit_small", patch_size=8, image_size=480, image_path=None, device="cuda"): + self.device = device + # build model + self.image_size = image_size + self.patch_size = patch_size + self.model = vits.__dict__[arch](patch_size=patch_size, num_classes=0) + for p in self.model.parameters(): + p.requires_grad = False + self.model.eval() + self.model.to(device) + # Load up the model + if arch == "vit_small" and patch_size == 16: + url = "dino_deitsmall16_pretrain/dino_deitsmall16_pretrain.pth" + elif arch == "vit_small" and patch_size == 8: + url = "dino_deitsmall8_300ep_pretrain/dino_deitsmall8_300ep_pretrain.pth" # model used for visualizations in our paper + elif arch == "vit_base" and patch_size == 16: + url = "dino_vitbase16_pretrain/dino_vitbase16_pretrain.pth" + elif arch == "vit_base" and patch_size == 8: + url = "dino_vitbase8_pretrain/dino_vitbase8_pretrain.pth" + + if url is not None: + print("Since no pretrained weights have been provided, we load the reference pretrained DINO weights.") + state_dict = torch.hub.load_state_dict_from_url(url="https://dl.fbaipublicfiles.com/dino/" + url) + self.model.load_state_dict(state_dict, strict=True) + else: + print("There is no reference weights available for this model => We use random weights.") + + # Transforms + self.transform = transforms.Compose([ + transforms.Resize(image_size), + transforms.ToTensor(), + transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), + ]) + + def segment_individual_image(self, image, concepts, caption, **kwargs): + # NOTE: Do nothing with concepts or caption, as this is not a text conditioned approach. + if isinstance(image, torch.Tensor): + image = transforms.Resize(self.image_size)(image) + else: + image = self.transform(image) + # Predict the raw scores. + # make the image divisible by the patch size + w, h = image.shape[1] - image.shape[1] % self.patch_size, image.shape[2] - image.shape[2] % self.patch_size + image = image[:, :w, :h].unsqueeze(0) + + w_featmap = image.shape[-2] // self.patch_size + h_featmap = image.shape[-1] // self.patch_size + + attentions = self.model.get_last_selfattention(image.to(self.device)) + nh = attentions.shape[1] # number of head + + # we keep only the output patch attention + attentions = attentions[0, :, 0, 1:].reshape(nh, -1) + attentions = attentions.reshape(nh, w_featmap, h_featmap) + attentions = nn.functional.interpolate(attentions.unsqueeze(0), scale_factor=self.patch_size, mode="nearest")[0] + attentions = torch.mean(attentions, dim=0, keepdim=True) + attentions = attentions.repeat(len(concepts), 1, 1) + + return attentions, None \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/dino_src/__init__.py b/concept_attention/binary_segmentation_baselines/dino_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/__init__.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..564b941d72136dc8aa9657a21e6a42ff24a7c568 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/__init__.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/utils.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..022e72f5824980c7cdcdb36efb77f377985f3c33 Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/utils.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/vision_transformer.cpython-310.pyc b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/vision_transformer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3feb0482877db7d9b04a9ff1fa83e18dd2a5b17d Binary files /dev/null and b/concept_attention/binary_segmentation_baselines/dino_src/__pycache__/vision_transformer.cpython-310.pyc differ diff --git a/concept_attention/binary_segmentation_baselines/dino_src/utils.py b/concept_attention/binary_segmentation_baselines/dino_src/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e02d3d4a0c6f2f2829b6e5198109db384728e55a --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/dino_src/utils.py @@ -0,0 +1,829 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Misc functions. + +Mostly copy-paste from torchvision references or other public repos like DETR: +https://github.com/facebookresearch/detr/blob/master/util/misc.py +""" +import os +import sys +import time +import math +import random +import datetime +import subprocess +from collections import defaultdict, deque + +import numpy as np +import torch +from torch import nn +import torch.distributed as dist +from PIL import ImageFilter, ImageOps + + +class GaussianBlur(object): + """ + Apply Gaussian Blur to the PIL image. + """ + def __init__(self, p=0.5, radius_min=0.1, radius_max=2.): + self.prob = p + self.radius_min = radius_min + self.radius_max = radius_max + + def __call__(self, img): + do_it = random.random() <= self.prob + if not do_it: + return img + + return img.filter( + ImageFilter.GaussianBlur( + radius=random.uniform(self.radius_min, self.radius_max) + ) + ) + + +class Solarization(object): + """ + Apply Solarization to the PIL image. + """ + def __init__(self, p): + self.p = p + + def __call__(self, img): + if random.random() < self.p: + return ImageOps.solarize(img) + else: + return img + + +def load_pretrained_weights(model, pretrained_weights, checkpoint_key, model_name, patch_size): + if os.path.isfile(pretrained_weights): + state_dict = torch.load(pretrained_weights, map_location="cpu") + if checkpoint_key is not None and checkpoint_key in state_dict: + print(f"Take key {checkpoint_key} in provided checkpoint dict") + state_dict = state_dict[checkpoint_key] + # remove `module.` prefix + state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} + # remove `backbone.` prefix induced by multicrop wrapper + state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()} + msg = model.load_state_dict(state_dict, strict=False) + print('Pretrained weights found at {} and loaded with msg: {}'.format(pretrained_weights, msg)) + else: + print("Please use the `--pretrained_weights` argument to indicate the path of the checkpoint to evaluate.") + url = None + if model_name == "vit_small" and patch_size == 16: + url = "dino_deitsmall16_pretrain/dino_deitsmall16_pretrain.pth" + elif model_name == "vit_small" and patch_size == 8: + url = "dino_deitsmall8_pretrain/dino_deitsmall8_pretrain.pth" + elif model_name == "vit_base" and patch_size == 16: + url = "dino_vitbase16_pretrain/dino_vitbase16_pretrain.pth" + elif model_name == "vit_base" and patch_size == 8: + url = "dino_vitbase8_pretrain/dino_vitbase8_pretrain.pth" + elif model_name == "xcit_small_12_p16": + url = "dino_xcit_small_12_p16_pretrain/dino_xcit_small_12_p16_pretrain.pth" + elif model_name == "xcit_small_12_p8": + url = "dino_xcit_small_12_p8_pretrain/dino_xcit_small_12_p8_pretrain.pth" + elif model_name == "xcit_medium_24_p16": + url = "dino_xcit_medium_24_p16_pretrain/dino_xcit_medium_24_p16_pretrain.pth" + elif model_name == "xcit_medium_24_p8": + url = "dino_xcit_medium_24_p8_pretrain/dino_xcit_medium_24_p8_pretrain.pth" + elif model_name == "resnet50": + url = "dino_resnet50_pretrain/dino_resnet50_pretrain.pth" + if url is not None: + print("Since no pretrained weights have been provided, we load the reference pretrained DINO weights.") + state_dict = torch.hub.load_state_dict_from_url(url="https://dl.fbaipublicfiles.com/dino/" + url) + model.load_state_dict(state_dict, strict=True) + else: + print("There is no reference weights available for this model => We use random weights.") + + +def load_pretrained_linear_weights(linear_classifier, model_name, patch_size): + url = None + if model_name == "vit_small" and patch_size == 16: + url = "dino_deitsmall16_pretrain/dino_deitsmall16_linearweights.pth" + elif model_name == "vit_small" and patch_size == 8: + url = "dino_deitsmall8_pretrain/dino_deitsmall8_linearweights.pth" + elif model_name == "vit_base" and patch_size == 16: + url = "dino_vitbase16_pretrain/dino_vitbase16_linearweights.pth" + elif model_name == "vit_base" and patch_size == 8: + url = "dino_vitbase8_pretrain/dino_vitbase8_linearweights.pth" + elif model_name == "resnet50": + url = "dino_resnet50_pretrain/dino_resnet50_linearweights.pth" + if url is not None: + print("We load the reference pretrained linear weights.") + state_dict = torch.hub.load_state_dict_from_url(url="https://dl.fbaipublicfiles.com/dino/" + url)["state_dict"] + linear_classifier.load_state_dict(state_dict, strict=True) + else: + print("We use random linear weights.") + + +def clip_gradients(model, clip): + norms = [] + for name, p in model.named_parameters(): + if p.grad is not None: + param_norm = p.grad.data.norm(2) + norms.append(param_norm.item()) + clip_coef = clip / (param_norm + 1e-6) + if clip_coef < 1: + p.grad.data.mul_(clip_coef) + return norms + + +def cancel_gradients_last_layer(epoch, model, freeze_last_layer): + if epoch >= freeze_last_layer: + return + for n, p in model.named_parameters(): + if "last_layer" in n: + p.grad = None + + +def restart_from_checkpoint(ckp_path, run_variables=None, **kwargs): + """ + Re-start from checkpoint + """ + if not os.path.isfile(ckp_path): + return + print("Found checkpoint at {}".format(ckp_path)) + + # open checkpoint file + checkpoint = torch.load(ckp_path, map_location="cpu") + + # key is what to look for in the checkpoint file + # value is the object to load + # example: {'state_dict': model} + for key, value in kwargs.items(): + if key in checkpoint and value is not None: + try: + msg = value.load_state_dict(checkpoint[key], strict=False) + print("=> loaded '{}' from checkpoint '{}' with msg {}".format(key, ckp_path, msg)) + except TypeError: + try: + msg = value.load_state_dict(checkpoint[key]) + print("=> loaded '{}' from checkpoint: '{}'".format(key, ckp_path)) + except ValueError: + print("=> failed to load '{}' from checkpoint: '{}'".format(key, ckp_path)) + else: + print("=> key '{}' not found in checkpoint: '{}'".format(key, ckp_path)) + + # re load variable important for the run + if run_variables is not None: + for var_name in run_variables: + if var_name in checkpoint: + run_variables[var_name] = checkpoint[var_name] + + +def cosine_scheduler(base_value, final_value, epochs, niter_per_ep, warmup_epochs=0, start_warmup_value=0): + warmup_schedule = np.array([]) + warmup_iters = warmup_epochs * niter_per_ep + if warmup_epochs > 0: + warmup_schedule = np.linspace(start_warmup_value, base_value, warmup_iters) + + iters = np.arange(epochs * niter_per_ep - warmup_iters) + schedule = final_value + 0.5 * (base_value - final_value) * (1 + np.cos(np.pi * iters / len(iters))) + + schedule = np.concatenate((warmup_schedule, schedule)) + assert len(schedule) == epochs * niter_per_ep + return schedule + + +def bool_flag(s): + """ + Parse boolean arguments from the command line. + """ + FALSY_STRINGS = {"off", "false", "0"} + TRUTHY_STRINGS = {"on", "true", "1"} + if s.lower() in FALSY_STRINGS: + return False + elif s.lower() in TRUTHY_STRINGS: + return True + else: + raise argparse.ArgumentTypeError("invalid value for a boolean flag") + + +def fix_random_seeds(seed=31): + """ + Fix random seeds. + """ + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + + +class SmoothedValue(object): + """Track a series of values and provide access to smoothed values over a + window or the global series average. + """ + + def __init__(self, window_size=20, fmt=None): + if fmt is None: + fmt = "{median:.6f} ({global_avg:.6f})" + self.deque = deque(maxlen=window_size) + self.total = 0.0 + self.count = 0 + self.fmt = fmt + + def update(self, value, n=1): + self.deque.append(value) + self.count += n + self.total += value * n + + def synchronize_between_processes(self): + """ + Warning: does not synchronize the deque! + """ + if not is_dist_avail_and_initialized(): + return + t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda') + dist.barrier() + dist.all_reduce(t) + t = t.tolist() + self.count = int(t[0]) + self.total = t[1] + + @property + def median(self): + d = torch.tensor(list(self.deque)) + return d.median().item() + + @property + def avg(self): + d = torch.tensor(list(self.deque), dtype=torch.float32) + return d.mean().item() + + @property + def global_avg(self): + return self.total / self.count + + @property + def max(self): + return max(self.deque) + + @property + def value(self): + return self.deque[-1] + + def __str__(self): + return self.fmt.format( + median=self.median, + avg=self.avg, + global_avg=self.global_avg, + max=self.max, + value=self.value) + + +def reduce_dict(input_dict, average=True): + """ + Args: + input_dict (dict): all the values will be reduced + average (bool): whether to do average or sum + Reduce the values in the dictionary from all processes so that all processes + have the averaged results. Returns a dict with the same fields as + input_dict, after reduction. + """ + world_size = get_world_size() + if world_size < 2: + return input_dict + with torch.no_grad(): + names = [] + values = [] + # sort the keys so that they are consistent across processes + for k in sorted(input_dict.keys()): + names.append(k) + values.append(input_dict[k]) + values = torch.stack(values, dim=0) + dist.all_reduce(values) + if average: + values /= world_size + reduced_dict = {k: v for k, v in zip(names, values)} + return reduced_dict + + +class MetricLogger(object): + def __init__(self, delimiter="\t"): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + + def update(self, **kwargs): + for k, v in kwargs.items(): + if isinstance(v, torch.Tensor): + v = v.item() + assert isinstance(v, (float, int)) + self.meters[k].update(v) + + def __getattr__(self, attr): + if attr in self.meters: + return self.meters[attr] + if attr in self.__dict__: + return self.__dict__[attr] + raise AttributeError("'{}' object has no attribute '{}'".format( + type(self).__name__, attr)) + + def __str__(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append( + "{}: {}".format(name, str(meter)) + ) + return self.delimiter.join(loss_str) + + def synchronize_between_processes(self): + for meter in self.meters.values(): + meter.synchronize_between_processes() + + def add_meter(self, name, meter): + self.meters[name] = meter + + def log_every(self, iterable, print_freq, header=None): + i = 0 + if not header: + header = '' + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt='{avg:.6f}') + data_time = SmoothedValue(fmt='{avg:.6f}') + space_fmt = ':' + str(len(str(len(iterable)))) + 'd' + if torch.cuda.is_available(): + log_msg = self.delimiter.join([ + header, + '[{0' + space_fmt + '}/{1}]', + 'eta: {eta}', + '{meters}', + 'time: {time}', + 'data: {data}', + 'max mem: {memory:.0f}' + ]) + else: + log_msg = self.delimiter.join([ + header, + '[{0' + space_fmt + '}/{1}]', + 'eta: {eta}', + '{meters}', + 'time: {time}', + 'data: {data}' + ]) + MB = 1024.0 * 1024.0 + for obj in iterable: + data_time.update(time.time() - end) + yield obj + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == len(iterable) - 1: + eta_seconds = iter_time.global_avg * (len(iterable) - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + print(log_msg.format( + i, len(iterable), eta=eta_string, + meters=str(self), + time=str(iter_time), data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB)) + else: + print(log_msg.format( + i, len(iterable), eta=eta_string, + meters=str(self), + time=str(iter_time), data=str(data_time))) + i += 1 + end = time.time() + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + print('{} Total time: {} ({:.6f} s / it)'.format( + header, total_time_str, total_time / len(iterable))) + + +def get_sha(): + cwd = os.path.dirname(os.path.abspath(__file__)) + + def _run(command): + return subprocess.check_output(command, cwd=cwd).decode('ascii').strip() + sha = 'N/A' + diff = "clean" + branch = 'N/A' + try: + sha = _run(['git', 'rev-parse', 'HEAD']) + subprocess.check_output(['git', 'diff'], cwd=cwd) + diff = _run(['git', 'diff-index', 'HEAD']) + diff = "has uncommited changes" if diff else "clean" + branch = _run(['git', 'rev-parse', '--abbrev-ref', 'HEAD']) + except Exception: + pass + message = f"sha: {sha}, status: {diff}, branch: {branch}" + return message + + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + + +def get_world_size(): + if not is_dist_avail_and_initialized(): + return 1 + return dist.get_world_size() + + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + + +def is_main_process(): + return get_rank() == 0 + + +def save_on_master(*args, **kwargs): + if is_main_process(): + torch.save(*args, **kwargs) + + +def setup_for_distributed(is_master): + """ + This function disables printing when not in master process + """ + import builtins as __builtin__ + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop('force', False) + if is_master or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def init_distributed_mode(args): + # launched with torch.distributed.launch + if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: + args.rank = int(os.environ["RANK"]) + args.world_size = int(os.environ['WORLD_SIZE']) + args.gpu = int(os.environ['LOCAL_RANK']) + # launched with submitit on a slurm cluster + elif 'SLURM_PROCID' in os.environ: + args.rank = int(os.environ['SLURM_PROCID']) + args.gpu = args.rank % torch.cuda.device_count() + # launched naively with `python main_dino.py` + # we manually add MASTER_ADDR and MASTER_PORT to env variables + elif torch.cuda.is_available(): + print('Will run the code on one GPU.') + args.rank, args.gpu, args.world_size = 0, 0, 1 + os.environ['MASTER_ADDR'] = '127.0.0.1' + os.environ['MASTER_PORT'] = '29500' + else: + print('Does not support training without GPU.') + sys.exit(1) + + dist.init_process_group( + backend="nccl", + init_method=args.dist_url, + world_size=args.world_size, + rank=args.rank, + ) + + torch.cuda.set_device(args.gpu) + print('| distributed init (rank {}): {}'.format( + args.rank, args.dist_url), flush=True) + dist.barrier() + setup_for_distributed(args.rank == 0) + + +def accuracy(output, target, topk=(1,)): + """Computes the accuracy over the k top predictions for the specified values of k""" + maxk = max(topk) + batch_size = target.size(0) + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.reshape(1, -1).expand_as(pred)) + return [correct[:k].reshape(-1).float().sum(0) * 100. / batch_size for k in topk] + + +def _no_grad_trunc_normal_(tensor, mean, std, a, b): + # Cut & paste from PyTorch official master until it's in a few official releases - RW + # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf + def norm_cdf(x): + # Computes standard normal cumulative distribution function + return (1. + math.erf(x / math.sqrt(2.))) / 2. + + if (mean < a - 2 * std) or (mean > b + 2 * std): + warnings.warn("mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " + "The distribution of values may be incorrect.", + stacklevel=2) + + with torch.no_grad(): + # Values are generated by using a truncated uniform distribution and + # then using the inverse CDF for the normal distribution. + # Get upper and lower cdf values + l = norm_cdf((a - mean) / std) + u = norm_cdf((b - mean) / std) + + # Uniformly fill tensor with values from [l, u], then translate to + # [2l-1, 2u-1]. + tensor.uniform_(2 * l - 1, 2 * u - 1) + + # Use inverse cdf transform for normal distribution to get truncated + # standard normal + tensor.erfinv_() + + # Transform to proper mean, std + tensor.mul_(std * math.sqrt(2.)) + tensor.add_(mean) + + # Clamp to ensure it's in the proper range + tensor.clamp_(min=a, max=b) + return tensor + + +def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.): + # type: (Tensor, float, float, float, float) -> Tensor + return _no_grad_trunc_normal_(tensor, mean, std, a, b) + + +class LARS(torch.optim.Optimizer): + """ + Almost copy-paste from https://github.com/facebookresearch/barlowtwins/blob/main/main.py + """ + def __init__(self, params, lr=0, weight_decay=0, momentum=0.9, eta=0.001, + weight_decay_filter=None, lars_adaptation_filter=None): + defaults = dict(lr=lr, weight_decay=weight_decay, momentum=momentum, + eta=eta, weight_decay_filter=weight_decay_filter, + lars_adaptation_filter=lars_adaptation_filter) + super().__init__(params, defaults) + + @torch.no_grad() + def step(self): + for g in self.param_groups: + for p in g['params']: + dp = p.grad + + if dp is None: + continue + + if p.ndim != 1: + dp = dp.add(p, alpha=g['weight_decay']) + + if p.ndim != 1: + param_norm = torch.norm(p) + update_norm = torch.norm(dp) + one = torch.ones_like(param_norm) + q = torch.where(param_norm > 0., + torch.where(update_norm > 0, + (g['eta'] * param_norm / update_norm), one), one) + dp = dp.mul(q) + + param_state = self.state[p] + if 'mu' not in param_state: + param_state['mu'] = torch.zeros_like(p) + mu = param_state['mu'] + mu.mul_(g['momentum']).add_(dp) + + p.add_(mu, alpha=-g['lr']) + + +class MultiCropWrapper(nn.Module): + """ + Perform forward pass separately on each resolution input. + The inputs corresponding to a single resolution are clubbed and single + forward is run on the same resolution inputs. Hence we do several + forward passes = number of different resolutions used. We then + concatenate all the output features and run the head forward on these + concatenated features. + """ + def __init__(self, backbone, head): + super(MultiCropWrapper, self).__init__() + # disable layers dedicated to ImageNet labels classification + backbone.fc, backbone.head = nn.Identity(), nn.Identity() + self.backbone = backbone + self.head = head + + def forward(self, x): + # convert to list + if not isinstance(x, list): + x = [x] + idx_crops = torch.cumsum(torch.unique_consecutive( + torch.tensor([inp.shape[-1] for inp in x]), + return_counts=True, + )[1], 0) + start_idx, output = 0, torch.empty(0).to(x[0].device) + for end_idx in idx_crops: + _out = self.backbone(torch.cat(x[start_idx: end_idx])) + # The output is a tuple with XCiT model. See: + # https://github.com/facebookresearch/xcit/blob/master/xcit.py#L404-L405 + if isinstance(_out, tuple): + _out = _out[0] + # accumulate outputs + output = torch.cat((output, _out)) + start_idx = end_idx + # Run the head forward on the concatenated features. + return self.head(output) + + +def get_params_groups(model): + regularized = [] + not_regularized = [] + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + # we do not regularize biases nor Norm parameters + if name.endswith(".bias") or len(param.shape) == 1: + not_regularized.append(param) + else: + regularized.append(param) + return [{'params': regularized}, {'params': not_regularized, 'weight_decay': 0.}] + + +def has_batchnorms(model): + bn_types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.SyncBatchNorm) + for name, module in model.named_modules(): + if isinstance(module, bn_types): + return True + return False + + +class PCA(): + """ + Class to compute and apply PCA. + """ + def __init__(self, dim=256, whit=0.5): + self.dim = dim + self.whit = whit + self.mean = None + + def train_pca(self, cov): + """ + Takes a covariance matrix (np.ndarray) as input. + """ + d, v = np.linalg.eigh(cov) + eps = d.max() * 1e-5 + n_0 = (d < eps).sum() + if n_0 > 0: + d[d < eps] = eps + + # total energy + totenergy = d.sum() + + # sort eigenvectors with eigenvalues order + idx = np.argsort(d)[::-1][:self.dim] + d = d[idx] + v = v[:, idx] + + print("keeping %.2f %% of the energy" % (d.sum() / totenergy * 100.0)) + + # for the whitening + d = np.diag(1. / d**self.whit) + + # principal components + self.dvt = np.dot(d, v.T) + + def apply(self, x): + # input is from numpy + if isinstance(x, np.ndarray): + if self.mean is not None: + x -= self.mean + return np.dot(self.dvt, x.T).T + + # input is from torch and is on GPU + if x.is_cuda: + if self.mean is not None: + x -= torch.cuda.FloatTensor(self.mean) + return torch.mm(torch.cuda.FloatTensor(self.dvt), x.transpose(0, 1)).transpose(0, 1) + + # input if from torch, on CPU + if self.mean is not None: + x -= torch.FloatTensor(self.mean) + return torch.mm(torch.FloatTensor(self.dvt), x.transpose(0, 1)).transpose(0, 1) + + +def compute_ap(ranks, nres): + """ + Computes average precision for given ranked indexes. + Arguments + --------- + ranks : zerro-based ranks of positive images + nres : number of positive images + Returns + ------- + ap : average precision + """ + + # number of images ranked by the system + nimgranks = len(ranks) + + # accumulate trapezoids in PR-plot + ap = 0 + + recall_step = 1. / nres + + for j in np.arange(nimgranks): + rank = ranks[j] + + if rank == 0: + precision_0 = 1. + else: + precision_0 = float(j) / rank + + precision_1 = float(j + 1) / (rank + 1) + + ap += (precision_0 + precision_1) * recall_step / 2. + + return ap + + +def compute_map(ranks, gnd, kappas=[]): + """ + Computes the mAP for a given set of returned results. + Usage: + map = compute_map (ranks, gnd) + computes mean average precsion (map) only + map, aps, pr, prs = compute_map (ranks, gnd, kappas) + computes mean average precision (map), average precision (aps) for each query + computes mean precision at kappas (pr), precision at kappas (prs) for each query + Notes: + 1) ranks starts from 0, ranks.shape = db_size X #queries + 2) The junk results (e.g., the query itself) should be declared in the gnd stuct array + 3) If there are no positive images for some query, that query is excluded from the evaluation + """ + + map = 0. + nq = len(gnd) # number of queries + aps = np.zeros(nq) + pr = np.zeros(len(kappas)) + prs = np.zeros((nq, len(kappas))) + nempty = 0 + + for i in np.arange(nq): + qgnd = np.array(gnd[i]['ok']) + + # no positive images, skip from the average + if qgnd.shape[0] == 0: + aps[i] = float('nan') + prs[i, :] = float('nan') + nempty += 1 + continue + + try: + qgndj = np.array(gnd[i]['junk']) + except: + qgndj = np.empty(0) + + # sorted positions of positive and junk images (0 based) + pos = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgnd)] + junk = np.arange(ranks.shape[0])[np.in1d(ranks[:,i], qgndj)] + + k = 0; + ij = 0; + if len(junk): + # decrease positions of positives based on the number of + # junk images appearing before them + ip = 0 + while (ip < len(pos)): + while (ij < len(junk) and pos[ip] > junk[ij]): + k += 1 + ij += 1 + pos[ip] = pos[ip] - k + ip += 1 + + # compute ap + ap = compute_ap(pos, len(qgnd)) + map = map + ap + aps[i] = ap + + # compute precision @ k + pos += 1 # get it to 1-based + for j in np.arange(len(kappas)): + kq = min(max(pos), kappas[j]); + prs[i, j] = (pos <= kq).sum() / kq + pr = pr + prs[i, :] + + map = map / (nq - nempty) + pr = pr / (nq - nempty) + + return map, aps, pr, prs + + +def multi_scale(samples, model): + v = None + for s in [1, 1/2**(1/2), 1/2]: # we use 3 different scales + if s == 1: + inp = samples.clone() + else: + inp = nn.functional.interpolate(samples, scale_factor=s, mode='bilinear', align_corners=False) + feats = model(inp).clone() + if v is None: + v = feats + else: + v += feats + v /= 3 + v /= v.norm() + return v \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/dino_src/vision_transformer.py b/concept_attention/binary_segmentation_baselines/dino_src/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..19c4c9a50cab9353aa25057e56377087d74169bc --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/dino_src/vision_transformer.py @@ -0,0 +1,291 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Mostly copy-paste from timm library. +https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py +""" +import math +from functools import partial + +import torch +import torch.nn as nn + +from concept_attention.binary_segmentation_baselines.dino_src.utils import trunc_normal_ + + +def drop_path(x, drop_prob: float = 0., training: bool = False): + if drop_prob == 0. or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device) + random_tensor.floor_() # binarize + output = x.div(keep_prob) * random_tensor + return output + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + """ + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = qk_scale or head_dim ** -0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x): + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] + + attn = (q @ k.transpose(-2, -1)) * self.scale + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, C) + x = self.proj(x) + x = self.proj_drop(x) + return x, attn + + +class Block(nn.Module): + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop) + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + def forward(self, x, return_attention=False): + y, attn = self.attn(self.norm1(x)) + if return_attention: + return attn + x = x + self.drop_path(y) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + num_patches = (img_size // patch_size) * (img_size // patch_size) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x): + B, C, H, W = x.shape + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + +class VisionTransformer(nn.Module): + """ Vision Transformer """ + def __init__(self, img_size=[224], patch_size=16, in_chans=3, num_classes=0, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0., norm_layer=nn.LayerNorm, **kwargs): + super().__init__() + self.num_features = self.embed_dim = embed_dim + + self.patch_embed = PatchEmbed( + img_size=img_size[0], patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + self.pos_drop = nn.Dropout(p=drop_rate) + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer) + for i in range(depth)]) + self.norm = norm_layer(embed_dim) + + # Classifier head + self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + trunc_normal_(self.pos_embed, std=.02) + trunc_normal_(self.cls_token, std=.02) + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + def interpolate_pos_encoding(self, x, w, h): + npatch = x.shape[1] - 1 + N = self.pos_embed.shape[1] - 1 + if npatch == N and w == h: + return self.pos_embed + class_pos_embed = self.pos_embed[:, 0] + patch_pos_embed = self.pos_embed[:, 1:] + dim = x.shape[-1] + w0 = w // self.patch_embed.patch_size + h0 = h // self.patch_embed.patch_size + # we add a small number to avoid floating point error in the interpolation + # see discussion at https://github.com/facebookresearch/dino/issues/8 + w0, h0 = w0 + 0.1, h0 + 0.1 + patch_pos_embed = nn.functional.interpolate( + patch_pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), dim).permute(0, 3, 1, 2), + scale_factor=(w0 / math.sqrt(N), h0 / math.sqrt(N)), + mode='bicubic', + ) + assert int(w0) == patch_pos_embed.shape[-2] and int(h0) == patch_pos_embed.shape[-1] + patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim) + return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1) + + def prepare_tokens(self, x): + B, nc, w, h = x.shape + x = self.patch_embed(x) # patch linear embedding + + # add the [CLS] token to the embed patch tokens + cls_tokens = self.cls_token.expand(B, -1, -1) + x = torch.cat((cls_tokens, x), dim=1) + + # add positional encoding to each token + x = x + self.interpolate_pos_encoding(x, w, h) + + return self.pos_drop(x) + + def forward(self, x): + x = self.prepare_tokens(x) + for blk in self.blocks: + x = blk(x) + x = self.norm(x) + return x[:, 0] + + def get_last_selfattention(self, x): + x = self.prepare_tokens(x) + for i, blk in enumerate(self.blocks): + if i < len(self.blocks) - 1: + x = blk(x) + else: + # return attention of the last block + return blk(x, return_attention=True) + + def get_intermediate_layers(self, x, n=1): + x = self.prepare_tokens(x) + # we return the output tokens from the `n` last blocks + output = [] + for i, blk in enumerate(self.blocks): + x = blk(x) + if len(self.blocks) - i <= n: + output.append(self.norm(x)) + return output + + +def vit_tiny(patch_size=16, **kwargs): + model = VisionTransformer( + patch_size=patch_size, embed_dim=192, depth=12, num_heads=3, mlp_ratio=4, + qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs) + return model + + +def vit_small(patch_size=16, **kwargs): + model = VisionTransformer( + patch_size=patch_size, embed_dim=384, depth=12, num_heads=6, mlp_ratio=4, + qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs) + return model + + +def vit_base(patch_size=16, **kwargs): + model = VisionTransformer( + patch_size=patch_size, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, + qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs) + return model + + +class DINOHead(nn.Module): + def __init__(self, in_dim, out_dim, use_bn=False, norm_last_layer=True, nlayers=3, hidden_dim=2048, bottleneck_dim=256): + super().__init__() + nlayers = max(nlayers, 1) + if nlayers == 1: + self.mlp = nn.Linear(in_dim, bottleneck_dim) + else: + layers = [nn.Linear(in_dim, hidden_dim)] + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + for _ in range(nlayers - 2): + layers.append(nn.Linear(hidden_dim, hidden_dim)) + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + layers.append(nn.Linear(hidden_dim, bottleneck_dim)) + self.mlp = nn.Sequential(*layers) + self.apply(self._init_weights) + self.last_layer = nn.utils.weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False)) + self.last_layer.weight_g.data.fill_(1) + if norm_last_layer: + self.last_layer.weight_g.requires_grad = False + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x): + x = self.mlp(x) + x = nn.functional.normalize(x, dim=-1, p=2) + x = self.last_layer(x) + return x \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/dino_src/visualize_dino_attention.py b/concept_attention/binary_segmentation_baselines/dino_src/visualize_dino_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..eae2d6edf58e6914b251886dad56f0341f421331 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/dino_src/visualize_dino_attention.py @@ -0,0 +1,213 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import os +import sys +import argparse +import cv2 +import random +import colorsys +import requests +from io import BytesIO + +import skimage.io +from skimage.measure import find_contours +import matplotlib.pyplot as plt +from matplotlib.patches import Polygon +import torch +import torch.nn as nn +import torchvision +from torchvision import transforms as pth_transforms +import numpy as np +from PIL import Image + +import utils +import vision_transformer as vits + + +def apply_mask(image, mask, color, alpha=0.5): + for c in range(3): + image[:, :, c] = image[:, :, c] * (1 - alpha * mask) + alpha * mask * color[c] * 255 + return image + + +def random_colors(N, bright=True): + """ + Generate random colors. + """ + brightness = 1.0 if bright else 0.7 + hsv = [(i / N, 1, brightness) for i in range(N)] + colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv)) + random.shuffle(colors) + return colors + + +def display_instances(image, mask, fname="test", figsize=(5, 5), blur=False, contour=True, alpha=0.5): + fig = plt.figure(figsize=figsize, frameon=False) + ax = plt.Axes(fig, [0., 0., 1., 1.]) + ax.set_axis_off() + fig.add_axes(ax) + ax = plt.gca() + + N = 1 + mask = mask[None, :, :] + # Generate random colors + colors = random_colors(N) + + # Show area outside image boundaries. + height, width = image.shape[:2] + margin = 0 + ax.set_ylim(height + margin, -margin) + ax.set_xlim(-margin, width + margin) + ax.axis('off') + masked_image = image.astype(np.uint32).copy() + for i in range(N): + color = colors[i] + _mask = mask[i] + if blur: + _mask = cv2.blur(_mask,(10,10)) + # Mask + masked_image = apply_mask(masked_image, _mask, color, alpha) + # Mask Polygon + # Pad to ensure proper polygons for masks that touch image edges. + if contour: + padded_mask = np.zeros((_mask.shape[0] + 2, _mask.shape[1] + 2)) + padded_mask[1:-1, 1:-1] = _mask + contours = find_contours(padded_mask, 0.5) + for verts in contours: + # Subtract the padding and flip (y, x) to (x, y) + verts = np.fliplr(verts) - 1 + p = Polygon(verts, facecolor="none", edgecolor=color) + ax.add_patch(p) + ax.imshow(masked_image.astype(np.uint8), aspect='auto') + fig.savefig(fname) + print(f"{fname} saved.") + return + + +if __name__ == '__main__': + parser = argparse.ArgumentParser('Visualize Self-Attention maps') + parser.add_argument('--arch', default='vit_small', type=str, + choices=['vit_tiny', 'vit_small', 'vit_base'], help='Architecture (support only ViT atm).') + parser.add_argument('--patch_size', default=8, type=int, help='Patch resolution of the model.') + parser.add_argument('--pretrained_weights', default='', type=str, + help="Path to pretrained weights to load.") + parser.add_argument("--checkpoint_key", default="teacher", type=str, + help='Key to use in the checkpoint (example: "teacher")') + parser.add_argument("--image_path", default=None, type=str, help="Path of the image to load.") + parser.add_argument("--image_size", default=(480, 480), type=int, nargs="+", help="Resize image.") + parser.add_argument('--output_dir', default='.', help='Path where to save visualizations.') + parser.add_argument("--threshold", type=float, default=None, help="""We visualize masks + obtained by thresholding the self-attention maps to keep xx% of the mass.""") + args = parser.parse_args() + + device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") + # build model + model = vits.__dict__[args.arch](patch_size=args.patch_size, num_classes=0) + for p in model.parameters(): + p.requires_grad = False + model.eval() + model.to(device) + if os.path.isfile(args.pretrained_weights): + state_dict = torch.load(args.pretrained_weights, map_location="cpu") + if args.checkpoint_key is not None and args.checkpoint_key in state_dict: + print(f"Take key {args.checkpoint_key} in provided checkpoint dict") + state_dict = state_dict[args.checkpoint_key] + # remove `module.` prefix + state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} + # remove `backbone.` prefix induced by multicrop wrapper + state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()} + msg = model.load_state_dict(state_dict, strict=False) + print('Pretrained weights found at {} and loaded with msg: {}'.format(args.pretrained_weights, msg)) + else: + print("Please use the `--pretrained_weights` argument to indicate the path of the checkpoint to evaluate.") + url = None + if args.arch == "vit_small" and args.patch_size == 16: + url = "dino_deitsmall16_pretrain/dino_deitsmall16_pretrain.pth" + elif args.arch == "vit_small" and args.patch_size == 8: + url = "dino_deitsmall8_300ep_pretrain/dino_deitsmall8_300ep_pretrain.pth" # model used for visualizations in our paper + elif args.arch == "vit_base" and args.patch_size == 16: + url = "dino_vitbase16_pretrain/dino_vitbase16_pretrain.pth" + elif args.arch == "vit_base" and args.patch_size == 8: + url = "dino_vitbase8_pretrain/dino_vitbase8_pretrain.pth" + if url is not None: + print("Since no pretrained weights have been provided, we load the reference pretrained DINO weights.") + state_dict = torch.hub.load_state_dict_from_url(url="https://dl.fbaipublicfiles.com/dino/" + url) + model.load_state_dict(state_dict, strict=True) + else: + print("There is no reference weights available for this model => We use random weights.") + + # open image + if args.image_path is None: + # user has not specified any image - we use our own image + print("Please use the `--image_path` argument to indicate the path of the image you wish to visualize.") + print("Since no image path have been provided, we take the first image in our paper.") + response = requests.get("https://dl.fbaipublicfiles.com/dino/img.png") + img = Image.open(BytesIO(response.content)) + img = img.convert('RGB') + elif os.path.isfile(args.image_path): + with open(args.image_path, 'rb') as f: + img = Image.open(f) + img = img.convert('RGB') + else: + print(f"Provided image path {args.image_path} is non valid.") + sys.exit(1) + transform = pth_transforms.Compose([ + pth_transforms.Resize(args.image_size), + pth_transforms.ToTensor(), + pth_transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), + ]) + img = transform(img) + + # make the image divisible by the patch size + w, h = img.shape[1] - img.shape[1] % args.patch_size, img.shape[2] - img.shape[2] % args.patch_size + img = img[:, :w, :h].unsqueeze(0) + + w_featmap = img.shape[-2] // args.patch_size + h_featmap = img.shape[-1] // args.patch_size + + attentions = model.get_last_selfattention(img.to(device)) + + nh = attentions.shape[1] # number of head + + # we keep only the output patch attention + attentions = attentions[0, :, 0, 1:].reshape(nh, -1) + + if args.threshold is not None: + # we keep only a certain percentage of the mass + val, idx = torch.sort(attentions) + val /= torch.sum(val, dim=1, keepdim=True) + cumval = torch.cumsum(val, dim=1) + th_attn = cumval > (1 - args.threshold) + idx2 = torch.argsort(idx) + for head in range(nh): + th_attn[head] = th_attn[head][idx2[head]] + th_attn = th_attn.reshape(nh, w_featmap, h_featmap).float() + # interpolate + th_attn = nn.functional.interpolate(th_attn.unsqueeze(0), scale_factor=args.patch_size, mode="nearest")[0].cpu().numpy() + + attentions = attentions.reshape(nh, w_featmap, h_featmap) + attentions = nn.functional.interpolate(attentions.unsqueeze(0), scale_factor=args.patch_size, mode="nearest")[0].cpu().numpy() + + # save attentions heatmaps + os.makedirs(args.output_dir, exist_ok=True) + torchvision.utils.save_image(torchvision.utils.make_grid(img, normalize=True, scale_each=True), os.path.join(args.output_dir, "img.png")) + for j in range(nh): + fname = os.path.join(args.output_dir, "attn-head" + str(j) + ".png") + plt.imsave(fname=fname, arr=attentions[j], format='png') + print(f"{fname} saved.") + + if args.threshold is not None: + image = skimage.io.imread(os.path.join(args.output_dir, "img.png")) + for j in range(nh): + display_instances(image, th_attn[j], fname=os.path.join(args.output_dir, "mask_th" + str(args.threshold) + "_head" + str(j) +".png"), blur=False) \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/raw_cross_attention.py b/concept_attention/binary_segmentation_baselines/raw_cross_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..f037b39bf28c7212f076aa0d2a0ae35d713efaa1 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/raw_cross_attention.py @@ -0,0 +1,259 @@ +""" + This baseline just returns heatmaps as the raw cross attentions. +""" +from concept_attention.flux.src.flux.sampling import prepare, unpack +import torch +import einops +import PIL + +from concept_attention.image_generator import FluxGenerator +from concept_attention.segmentation import SegmentationAbstractClass, add_noise_to_image, encode_image +from concept_attention.utils import embed_concepts, linear_normalization + + +class RawCrossAttentionBaseline(): + """ + This class implements the cross attention baseline. + """ + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + generator: FluxGenerator = None + ): + """ + Initialize the DAAM model. + """ + super(RawCrossAttentionBaseline, self).__init__() + if generator is None: + # Load up the flux generator + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + else: + self.generator = generator + # Unpack the tokenizer + self.tokenizer = self.generator.t5.tokenizer + + def __call__( + self, + prompt, + concepts, + seed=4, + num_steps=4, + timesteps=None, + layers=None, + softmax=False + ): + """ + Generate cross attention heatmap visualizations. + + Args: + - prompt: str, the prompt to generate the visualizations for + - seed: int, the seed to use for the visualization + + Returns: + - attention_maps: torch.Tensor, the attention maps for the prompt + - tokens: list[str], the tokens in the prompt + - image: torch.Tensor, the image generated by the + """ + if timesteps is None: + timesteps = list(range(num_steps)) + if layers is None: + layers = list(range(19)) + # Run the image generator + image, cross_attention_maps, _ = self.generator.generate_image( + width=1024, + height=1024, + num_steps=num_steps, + guidance=0.0, + seed=seed, + prompt=prompt, + concepts=concepts + ) + # Do softmax + if softmax: + cross_attention_maps = torch.nn.functional.softmax(cross_attention_maps, dim=-2) + # Pull out the desired timesteps + cross_attention_maps = cross_attention_maps[:, timesteps] + # Pull out the desired layers + cross_attention_maps = cross_attention_maps[layers] + # AVerage over the layers, time heads + cross_attention_maps = einops.reduce( + cross_attention_maps, + "layers time heads concepts patches -> concepts patches", + reduction="mean" + ) + # Rearrange + cross_attention_maps = einops.rearrange( + cross_attention_maps, + "concepts (h w) -> concepts h w", + h=64, + w=64 + ) + # Softmax + if softmax: + cross_attention_maps = torch.nn.functional.softmax(cross_attention_maps, dim=0) + + return cross_attention_maps, image + +class RawCrossAttentionSegmentationModel(SegmentationAbstractClass): + + def __init__( + self, + generator=None, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + ): + """ + Initialize the segmentation model. + """ + super(RawCrossAttentionSegmentationModel, self).__init__() + if generator is not None: + self.generator = generator + else: + # Load up the flux generator + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + + self.is_schnell = "schnell" in model_name + + def segment_individual_image( + self, + image: PIL.Image.Image, + concepts: list[str], + caption: str, + device: str = "cuda", + offload: bool = False, + num_samples: int = 1, + num_steps: int = 4, + noise_timestep: int = 2, + seed: int = 4, + width: int = 1024, + height: int = 1024, + stop_after_multimodal_attentions: bool = True, + layers: list[int] = list(range(19)), + timesteps = [-1], + softmax=False, + normalize_concepts=False, + joint_attention_kwargs=None, + **kwargs + ): + """ + Takes a real image and generates segmentation map. + """ + # Encode the image into the VAE latent space + encoded_image_without_noise = encode_image( + image, + self.generator.ae, + offload=offload, + device=device, + ) + # Do N trials + for i in range(num_samples): + # Add noise to image + encoded_image, timesteps = add_noise_to_image( + encoded_image_without_noise, + num_steps=num_steps, + noise_timestep=noise_timestep, + seed=seed + i, + width=width, + height=height, + device=device, + is_schnell=self.is_schnell, + ) + # Now run the diffusion model once on the noisy image + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.to(device), self.generator.clip.to(device) + inp = prepare(t5=self.generator.t5, clip=self.generator.clip, img=encoded_image, prompt=caption) + concept_embeddings, concept_ids, concept_vec = embed_concepts( + self.generator.clip, + self.generator.t5, + concepts, + ) + inp["concepts"] = concept_embeddings.to(encoded_image.device) + inp["concept_ids"] = concept_ids.to(encoded_image.device) + inp["concept_vec"] = concept_vec.to(encoded_image.device) + # offload TEs to CPU, load model to gpu + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.cpu(), self.generator.clip.cpu() + torch.cuda.empty_cache() + self.generator.model = self.generator.model.to(device) + # Denoise the intermediate images + guidance_vec = torch.full((encoded_image.shape[0],), 0.0, device=encoded_image.device, dtype=encoded_image.dtype) + t_curr = timesteps[0] + t_prev = timesteps[1] + t_vec = torch.full((encoded_image.shape[0],), t_curr, dtype=encoded_image.dtype, device=encoded_image.device) + pred, concept_cross_attentions, _ = self.generator.model( + img=inp["img"], + img_ids=inp["img_ids"], + txt=inp["txt"], + txt_ids=inp["txt_ids"], + concepts=inp["concepts"], + concept_ids=inp["concept_ids"], + concept_vec=inp["concept_vec"], + y=inp["concept_vec"], + timesteps=t_vec, + guidance=guidance_vec, + stop_after_multimodal_attentions=stop_after_multimodal_attentions, + joint_attention_kwargs=joint_attention_kwargs + ) + + if not stop_after_multimodal_attentions: + img = inp["img"] + (t_prev - t_curr) * pred + # decode latents to pixel space + img = unpack(img.float(), height, width) + with torch.autocast(device_type=self.generator.device.type, dtype=torch.bfloat16): + img = self.generator.ae.decode(img) + + if self.generator.offload: + self.generator.ae.decoder.cpu() + torch.cuda.empty_cache() + img = img.clamp(-1, 1) + img = einops.rearrange(img[0], "c h w -> h w c") + # reconstructed_image = PIL.Image.fromarray(img.cpu().byte().numpy()) + reconstructed_image = PIL.Image.fromarray((127.5 * (img + 1.0)).cpu().byte().numpy()) + else: + img = None + reconstructed_image = None + # Decode the image + if offload: + self.generator.model.cpu() + torch.cuda.empty_cache() + self.generator.ae.decoder.to(device) + + # Stack layers + concept_cross_attentions = concept_cross_attentions.to(torch.float32) + # Apply linear normalization to concepts + if normalize_concepts: + concept_vectors = linear_normalization(concept_vectors, dim=-2) + # Apply softmax + if softmax: + concept_cross_attentions = torch.nn.functional.softmax(concept_cross_attentions, dim=-2) + # Pull out the layer index + concept_cross_attentions = concept_cross_attentions[layers] + # Pull out the desired timesteps + concept_cross_attentions = concept_cross_attentions[:, timesteps] + # Average over the layers, time heads + concept_cross_attentions = einops.reduce( + concept_cross_attentions, + "layers time heads concepts patches -> concepts patches", + reduction="mean" + ) + # Reshape the concept cross attentions + concept_cross_attentions = einops.rearrange( + concept_cross_attentions, + "concepts (h w) -> concepts h w", + h=64, + w=64 + ) + + return concept_cross_attentions, reconstructed_image \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/raw_output_space.py b/concept_attention/binary_segmentation_baselines/raw_output_space.py new file mode 100644 index 0000000000000000000000000000000000000000..3b3bbeea3d45512b110aeb29b91069ad60acc755 --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/raw_output_space.py @@ -0,0 +1,264 @@ +""" + This baseline just returns heatmaps as the raw cross attentions. +""" +from concept_attention.flux.src.flux.sampling import prepare, unpack +import torch +import einops +import PIL + +from concept_attention.image_generator import FluxGenerator +from concept_attention.segmentation import SegmentationAbstractClass, add_noise_to_image, encode_image +from concept_attention.utils import embed_concepts, linear_normalization + +class RawOutputSpaceBaseline(): + """ + This class implements the cross attention baseline. + """ + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + generator = None + ): + super(RawOutputSpaceBaseline, self).__init__() + # Load up the flux generator + if generator is None: + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + else: + self.generator = generator + # Unpack the tokenizer + self.tokenizer = self.generator.t5.tokenizer + + def __call__( + self, + prompt, + concepts, + seed=4, + num_steps=4, + timesteps=None, + layers=list(range(19)), + softmax=False, + height=1024, + width=1024, + guidance=0.0, + ): + """ + Generate cross attention heatmap visualizations. + + Args: + - prompt: str, the prompt to generate the visualizations for + - seed: int, the seed to use for the visualization + + Returns: + - attention_maps: torch.Tensor, the attention maps for the prompt + - tokens: list[str], the tokens in the prompt + - image: torch.Tensor, the image generated by the + """ + if timesteps is None: + timesteps = list(range(num_steps)) + if layers is None: + layers = list(range(19)) + # Run the image generator + image, _, all_concept_heatmaps = self.generator.generate_image( + width=height, + height=width, + num_steps=num_steps, + guidance=guidance, + seed=seed, + prompt=prompt, + concepts=concepts + ) + # Apply softmax + if softmax: + all_concept_heatmaps = torch.nn.functional.softmax(all_concept_heatmaps, dim=-2) + + concept_heatmaps = all_concept_heatmaps[:, layers] + concept_heatmaps = einops.reduce( + concept_heatmaps, + "time layers batch concepts patches -> batch concepts patches", + reduction="mean" + ) + # Convert to torch float32 + concept_heatmaps = concept_heatmaps.to(torch.float32) + concept_heatmaps = einops.rearrange( + concept_heatmaps, + "batch concepts (h w) -> batch concepts h w", + h=64, + w=64 + ) + + return concept_heatmaps, image + +class RawOutputSpaceSegmentationModel(SegmentationAbstractClass): + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + generator=None, + ): + """ + Initialize the segmentation model. + """ + super(RawOutputSpaceSegmentationModel, self).__init__() + if generator is not None: + self.generator = generator + else: + # Load up the flux generator + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + + self.is_schnell = "schnell" in model_name + + def segment_individual_image( + self, + image: PIL.Image.Image, + concepts: list[str], + caption: str, + device: str = "cuda", + offload: bool = False, + num_samples: int = 1, + num_steps: int = 4, + noise_timestep: int = 2, + seed: int = 4, + width: int = 1024, + height: int = 1024, + stop_after_multimodal_attentions: bool = True, + layers: list[int] = list(range(19)), + normalize_concepts=True, + softmax: bool = False, + joint_attention_kwargs=None, + **kwargs + ): + """ + Takes a real image and generates a segmentation map. + """ + # Encode the image into the VAE latent space + encoded_image_without_noise = encode_image( + image, + self.generator.ae, + offload=offload, + device=device, + ) + # Do N trials + all_concept_heatmaps = [] + for i in range(num_samples): + # Add noise to image + encoded_image, timesteps = add_noise_to_image( + encoded_image_without_noise, + num_steps=num_steps, + noise_timestep=noise_timestep, + seed=seed + i, + width=width, + height=height, + device=device, + is_schnell=self.is_schnell, + ) + # Now run the diffusion model once on the noisy image + # Encode the concept vectors + + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.to(device), self.generator.clip.to(device) + inp = prepare(t5=self.generator.t5, clip=self.generator.clip, img=encoded_image, prompt=caption) + + concept_embeddings, concept_ids, concept_vec = embed_concepts( + self.generator.clip, + self.generator.t5, + concepts, + ) + + inp["concepts"] = concept_embeddings.to(encoded_image.device) + inp["concept_ids"] = concept_ids.to(encoded_image.device) + inp["concept_vec"] = concept_vec.to(encoded_image.device) + # offload TEs to CPU, load model to gpu + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.cpu(), self.generator.clip.cpu() + torch.cuda.empty_cache() + self.generator.model = self.generator.model.to(device) + # Denoise the intermediate images + guidance_vec = torch.full((encoded_image.shape[0],), 0.0, device=encoded_image.device, dtype=encoded_image.dtype) + t_curr = timesteps[0] + t_prev = timesteps[1] + t_vec = torch.full((encoded_image.shape[0],), t_curr, dtype=encoded_image.dtype, device=encoded_image.device) + pred, _, concept_heatmaps = self.generator.model( + img=inp["img"], + img_ids=inp["img_ids"], + txt=inp["txt"], + txt_ids=inp["txt_ids"], + concepts=inp["concepts"], + concept_ids=inp["concept_ids"], + concept_vec=inp["concept_vec"], + y=inp["concept_vec"], + timesteps=t_vec, + guidance=guidance_vec, + stop_after_multimodal_attentions=stop_after_multimodal_attentions, + joint_attention_kwargs=joint_attention_kwargs, + ) + + all_concept_heatmaps.append(concept_heatmaps) + + all_concept_heatmaps = torch.stack(all_concept_heatmaps, dim=0) + + if not stop_after_multimodal_attentions: + img = inp["img"] + (t_prev - t_curr) * pred + # decode latents to pixel space + img = unpack(img.float(), height, width) + with torch.autocast(device_type=self.generator.device.type, dtype=torch.bfloat16): + img = self.generator.ae.decode(img) + + if self.generator.offload: + self.generator.ae.decoder.cpu() + torch.cuda.empty_cache() + img = img.clamp(-1, 1) + img = einops.rearrange(img[0], "c h w -> h w c") + # reconstructed_image = PIL.Image.fromarray(img.cpu().byte().numpy()) + reconstructed_image = PIL.Image.fromarray((127.5 * (img + 1.0)).cpu().byte().numpy()) + else: + img = None + reconstructed_image = None + # Decode the image + if offload: + self.generator.model.cpu() + torch.cuda.empty_cache() + self.generator.ae.decoder.to(device) + + + # if layers is not None: + # # Pull out the layer index + # concept_vectors = concept_vectors[layers] + # image_vectors = image_vectors[layers] + + # Apply linear normalization to concepts + # if normalize_concepts: + # concept_vectors = linear_normalization(concept_vectors, dim=-2) + + # Apply softmax + if softmax: + all_concept_heatmaps = torch.nn.functional.softmax(all_concept_heatmaps, dim=-2) + + concept_heatmaps = all_concept_heatmaps[:, layers] + concept_heatmaps = einops.reduce( + concept_heatmaps, + "samples layers batch concepts patches -> batch concepts patches", + reduction="mean" + ) + # Convert to torch float32 + concept_heatmaps = concept_heatmaps.to(torch.float32) + concept_heatmaps = einops.rearrange( + concept_heatmaps, + "batch concepts (h w) -> batch concepts h w", + h=64, + w=64 + ) + + return concept_heatmaps, reconstructed_image \ No newline at end of file diff --git a/concept_attention/binary_segmentation_baselines/raw_value_space.py b/concept_attention/binary_segmentation_baselines/raw_value_space.py new file mode 100644 index 0000000000000000000000000000000000000000..37c218dcf39d9b9ee831d7c562de3026a9217d9e --- /dev/null +++ b/concept_attention/binary_segmentation_baselines/raw_value_space.py @@ -0,0 +1,301 @@ +""" + This baseline just returns heatmaps as the raw cross attentions. +""" +from concept_attention.flux.src.flux.sampling import prepare, unpack +import torch +import einops +import PIL + +from concept_attention.image_generator import FluxGenerator +from concept_attention.segmentation import SegmentationAbstractClass, add_noise_to_image, encode_image +from concept_attention.utils import embed_concepts, linear_normalization + + +class RawValueSpaceBaseline(): + """ + This class implements the cross attention baseline. + """ + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + generator=None + ): + """ + Initialize the DAAM model. + """ + super(RawValueSpaceBaseline, self).__init__() + # Load up the flux generator + if generator is None: + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + else: + self.generator = generator + # Unpack the tokenizer + self.tokenizer = self.generator.t5.tokenizer + + def __call__( + self, + prompt, + concepts, + seed=4, + num_steps=4, + timesteps=None, + layers=None, + softmax=False + ): + """ + Generate cross attention heatmap visualizations. + + Args: + - prompt: str, the prompt to generate the visualizations for + - seed: int, the seed to use for the visualization + + Returns: + - attention_maps: torch.Tensor, the attention maps for the prompt + - tokens: list[str], the tokens in the prompt + - image: torch.Tensor, the image generated by the + """ + if timesteps is None: + timesteps = list(range(num_steps)) + if layers is None: + layers = list(range(19)) + # Run the image generator + image = self.generator.generate_image( + width=1024, + height=1024, + num_steps=num_steps, + guidance=0.0, + seed=seed, + prompt=prompt, + concepts=concepts + ) + # Pull out and average the attention maps + image_value_vectors = [] + concept_value_vectors = [] + for double_block in self.generator.model.double_blocks: + image_values = torch.stack( + double_block.image_value_vectors + ).squeeze(1) + concept_values = torch.stack( + double_block.concept_value_vectors + ).squeeze(1) + # Clear out the layer (always same) + double_block.clear_cached_vectors() + # Append to the list + image_value_vectors.append(image_values) + concept_value_vectors.append(concept_values) + # Stack layers + image_vectors = torch.stack(image_value_vectors).to(torch.float32) + concept_vectors = torch.stack(concept_value_vectors).to(torch.float32) + # Now compute the heatmap + concept_heatmaps = einops.einsum( + concept_vectors, + image_vectors, + "layers timesteps heads concepts dims, layers timesteps heads pixels dims -> layers timesteps heads concepts pixels" + ) + concept_heatmaps = concept_heatmaps[layers, :] + concept_heatmaps = concept_heatmaps[:, timesteps] + + if softmax: + concept_heatmaps = torch.nn.functional.softmax(concept_heatmaps, dim=-2) + + concept_heatmaps = einops.reduce( + concept_heatmaps, + "layers timesteps heads concepts pixels -> concepts pixels", + reduction="mean" + ) + concept_heatmaps = einops.rearrange( + concept_heatmaps, + "concepts (h w) -> concepts h w", + h=64, + w=64 + ) + + return concept_heatmaps, image + +class RawValueSpaceSegmentationModel(SegmentationAbstractClass): + + def __init__( + self, + model_name: str = "flux-schnell", + device: str = "cuda", + offload: bool = True, + ): + """ + Initialize the segmentation model. + """ + super(RawValueSpaceSegmentationModel, self).__init__() + # Load up the flux generator + self.generator = FluxGenerator( + model_name=model_name, + device=device, + offload=offload, + ) + + self.is_schnell = "schnell" in model_name + + def segment_individual_image( + self, + image: PIL.Image.Image, + concepts: list[str], + caption: str, + device: str = "cuda", + offload: bool = False, + num_samples: int = 1, + num_steps: int = 4, + noise_timestep: int = 2, + seed: int = 4, + width: int = 1024, + height: int = 1024, + stop_after_multimodal_attentions: bool = True, + layers: list[int] = list(range(19)), + timesteps: list[int] = [-1], + normalize_concepts=True, + softmax=False, + joint_attention_kwargs=None, + **kwargs + ): + """ + Takes a real image and generates a segmentation map + """ + # Encode the image into the VAE latent space + encoded_image_without_noise = encode_image( + image, + self.generator.ae, + offload=offload, + device=device, + ) + # Do N trials + for i in range(num_samples): + # Add noise to image + encoded_image, timesteps = add_noise_to_image( + encoded_image_without_noise, + num_steps=num_steps, + noise_timestep=noise_timestep, + seed=seed + i, + width=width, + height=height, + device=device, + is_schnell=self.is_schnell, + ) + # Now run the diffusion model once on the noisy image + # Encode the concept vectors + + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.to(device), self.generator.clip.to(device) + inp = prepare(t5=self.generator.t5, clip=self.generator.clip, img=encoded_image, prompt=caption) + + concept_embeddings, concept_ids, concept_vec = embed_concepts( + self.generator.clip, + self.generator.t5, + concepts, + ) + + inp["concepts"] = concept_embeddings.to(encoded_image.device) + inp["concept_ids"] = concept_ids.to(encoded_image.device) + inp["concept_vec"] = concept_vec.to(encoded_image.device) + # offload TEs to CPU, load model to gpu + if offload: + self.generator.t5, self.generator.clip = self.generator.t5.cpu(), self.generator.clip.cpu() + torch.cuda.empty_cache() + self.generator.model = self.generator.model.to(device) + # Denoise the intermediate images + guidance_vec = torch.full((encoded_image.shape[0],), 0.0, device=encoded_image.device, dtype=encoded_image.dtype) + t_curr = timesteps[0] + t_prev = timesteps[1] + t_vec = torch.full((encoded_image.shape[0],), t_curr, dtype=encoded_image.dtype, device=encoded_image.device) + pred = self.generator.model( + img=inp["img"], + img_ids=inp["img_ids"], + txt=inp["txt"], + txt_ids=inp["txt_ids"], + concepts=inp["concepts"], + concept_ids=inp["concept_ids"], + concept_vec=inp["concept_vec"], + y=inp["concept_vec"], + timesteps=t_vec, + guidance=guidance_vec, + stop_after_multimodal_attentions=stop_after_multimodal_attentions, + joint_attention_kwargs=joint_attention_kwargs + ) + + if not stop_after_multimodal_attentions: + img = inp["img"] + (t_prev - t_curr) * pred + # decode latents to pixel space + img = unpack(img.float(), height, width) + with torch.autocast(device_type=self.generator.device.type, dtype=torch.bfloat16): + img = self.generator.ae.decode(img) + + if self.generator.offload: + self.generator.ae.decoder.cpu() + torch.cuda.empty_cache() + img = img.clamp(-1, 1) + img = einops.rearrange(img[0], "c h w -> h w c") + # reconstructed_image = PIL.Image.fromarray(img.cpu().byte().numpy()) + reconstructed_image = PIL.Image.fromarray((127.5 * (img + 1.0)).cpu().byte().numpy()) + else: + img = None + reconstructed_image = None + # Decode the image + if offload: + self.generator.model.cpu() + torch.cuda.empty_cache() + self.generator.ae.decoder.to(device) + + # Pull out the concept basis and image queries + concept_vectors = [] + image_vectors = [] + for double_block in self.generator.model.double_blocks: + # Target space is the cross attention space + image_vecs = torch.stack( + double_block.image_value_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_value_vectors + ).squeeze(1) + # Clear out the layer (always same) + double_block.clear_cached_vectors() + # Add to list + concept_vectors.append(concept_vecs) + image_vectors.append(image_vecs) + # Stack layers + concept_vectors = torch.stack(concept_vectors).to(torch.float32) + image_vectors = torch.stack(image_vectors).to(torch.float32) + + if layers is not None: + # Pull out the layer index + concept_vectors = concept_vectors[layers] + image_vectors = image_vectors[layers] + + # Apply linear normalization to concepts + if normalize_concepts: + concept_vectors = linear_normalization(concept_vectors, dim=-2) + + # Now compute the heatmap + concept_heatmaps = einops.einsum( + concept_vectors, + image_vectors, + "layers timesteps heads concepts dims, layers timesteps heads pixels dims -> layers timesteps heads concepts pixels" + ) + if softmax: + concept_heatmaps = torch.nn.functional.softmax(concept_heatmaps, dim=-2) + + concept_heatmaps = einops.reduce( + concept_heatmaps, + "layers timesteps heads concepts pixels -> concepts pixels", + reduction="mean" + ) + concept_heatmaps = einops.rearrange( + concept_heatmaps, + "concepts (h w) -> concepts h w", + h=64, + w=64 + ) + + return concept_heatmaps, reconstructed_image \ No newline at end of file diff --git a/concept_attention/concept_attention_pipeline.py b/concept_attention/concept_attention_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..72f3d3beea03df5e990787fe4052f415ae1bfad4 --- /dev/null +++ b/concept_attention/concept_attention_pipeline.py @@ -0,0 +1,163 @@ +""" + Wrapper pipeline for concept attention. +""" +from dataclasses import dataclass +import PIL +import numpy as np +import matplotlib.pyplot as plt + +from concept_attention.binary_segmentation_baselines.raw_cross_attention import RawCrossAttentionBaseline, RawCrossAttentionSegmentationModel +from concept_attention.binary_segmentation_baselines.raw_output_space import RawOutputSpaceBaseline, RawOutputSpaceSegmentationModel +from concept_attention.image_generator import FluxGenerator + +@dataclass +class ConceptAttentionPipelineOutput(): + image: PIL.Image.Image | np.ndarray + concept_heatmaps: list[PIL.Image.Image] + +class ConceptAttentionFluxPipeline(): + """ + This is an object that allows you to generate images with flux, and + 'encode' images with flux. + """ + + def __init__( + self, + model_name: str = "flux-schnell", + offload_model=False, + device="cuda:0" + ): + self.model_name = model_name + self.offload_model = False + # Load the generator + self.flux_generator = FluxGenerator( + model_name=model_name, + offload=offload_model, + device=device + ) + # Make a Raw Cross Attention Segmentation Model and Raw Output space segmentation model + self.cross_attention_segmentation_model = RawCrossAttentionSegmentationModel( + generator=self.flux_generator + ) + self.output_space_segmentation_model = RawOutputSpaceSegmentationModel( + generator=self.flux_generator + ) + self.raw_output_space_generator = RawOutputSpaceBaseline( + generator=self.flux_generator + ) + self.raw_cross_attention_generator = RawCrossAttentionBaseline( + generator=self.flux_generator + ) + + def generate_image( + self, + prompt: str, + concepts: list[str], + width: int = 1024, + height: int = 1024, + return_cross_attention = False, + layer_indices = list(range(15, 19)), + return_pil_heatmaps = True, + seed: int = 0, + num_inference_steps: int = 4, + guidance: float = 0.0, + timesteps=None, + softmax: bool = True, + cmap="plasma" + ) -> ConceptAttentionPipelineOutput: + """ + Generate an image with flux, given a list of concepts. + """ + assert return_cross_attention is False, "Not supported yet" + assert all([layer_index >= 0 and layer_index < 19 for layer_index in layer_indices]), "Invalid layer index" + assert height == width, "Height and width must be the same for now" + + if timesteps is None: + timesteps = list(range(num_inference_steps)) + # Run the raw output space object + concept_heatmaps, image = self.raw_output_space_generator( + prompt, + concepts, + seed=seed, + num_steps=num_inference_steps, + timesteps=timesteps, + layers=layer_indices, + softmax=softmax, + height=width, + width=width, + guidance=guidance, + ) + # Convert to numpy + concept_heatmaps = concept_heatmaps.detach().cpu().numpy()[0] + # Convert the torch heatmaps to PIL images. + if return_pil_heatmaps: + # Convert to a matplotlib color scheme + colored_heatmaps = [] + for concept_heatmap in concept_heatmaps: + concept_heatmap = (concept_heatmap - concept_heatmap.min()) / (concept_heatmap.max() - concept_heatmap.min()) + colored_heatmap = plt.get_cmap(cmap)(concept_heatmap) + rgb_image = (colored_heatmap[:, :, :3] * 255).astype(np.uint8) + colored_heatmaps.append(rgb_image) + + concept_heatmaps = [PIL.Image.fromarray(concept_heatmap) for concept_heatmap in colored_heatmaps] + + return ConceptAttentionPipelineOutput( + image=image, + concept_heatmaps=concept_heatmaps + ) + + def encode_image( + self, + image: PIL.Image.Image, + concepts: list[str], + prompt: str = "", # Optional + width: int = 1024, + height: int = 1024, + return_cross_attention = False, + layer_indices = list(range(15, 19)), + num_samples: int = 1, + device: str = "cuda:0", + return_pil_heatmaps: bool = True, + seed: int = 0, + cmap="plasma" + ) -> ConceptAttentionPipelineOutput: + """ + Encode an image with flux, given a list of concepts. + """ + assert return_cross_attention is False, "Not supported yet" + assert all([layer_index >= 0 and layer_index < 19 for layer_index in layer_indices]), "Invalid layer index" + assert height == width, "Height and width must be the same for now" + # Run the raw output space object + concept_heatmaps, _ = self.output_space_segmentation_model.segment_individual_image( + image=image, + concepts=concepts, + caption=prompt, + device=device, + softmax=True, + layers=layer_indices, + num_samples=num_samples, + height=height, + width=width + ) + concept_heatmaps = concept_heatmaps.detach().cpu().numpy() + + # Convert the torch heatmaps to PIL images. + if return_pil_heatmaps: + min_val = concept_heatmaps.min() + max_val = concept_heatmaps.max() + # Convert to a matplotlib color scheme + colored_heatmaps = [] + for concept_heatmap in concept_heatmaps: + # concept_heatmap = (concept_heatmap - concept_heatmap.min()) / (concept_heatmap.max() - concept_heatmap.min()) + concept_heatmap = (concept_heatmap - min_val) / (max_val - min_val) + colored_heatmap = plt.get_cmap(cmap)(concept_heatmap) + rgb_image = (colored_heatmap[:, :, :3] * 255).astype(np.uint8) + colored_heatmaps.append(rgb_image) + + concept_heatmaps = [PIL.Image.fromarray(concept_heatmap) for concept_heatmap in colored_heatmaps] + + return ConceptAttentionPipelineOutput( + image=image, + concept_heatmaps=concept_heatmaps + ) + diff --git a/concept_attention/concept_encoding.py b/concept_attention/concept_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..598ea370cc150c1b50e2a18e4aa168e3467134cd --- /dev/null +++ b/concept_attention/concept_encoding.py @@ -0,0 +1,111 @@ +import torch +import einops + +from concept_attention.utils import linear_normalization +from concept_attention.image_generator import FluxGenerator + +def generate_concept_basis_and_image_queries( + prompt: str, + concepts: list[str], + layer_index: list[int] = [18], + average_over_time: bool=True, + model_name="flux-dev", + num_steps=50, + seed=42, + average_after=0, + target_space="output", + generator=None, + normalize_concepts=False, + device="cuda", + include_images_in_basis=False, + offload=True, + joint_attention_kwargs=None +): + """ + Given a prompt, generate the set basis of concept vectors + for a particular layer in the model and the encoded image queries. + """ + assert target_space in ["output", "value", "cross_attention"], "Invalid target space" + if generator is None: + generator = FluxGenerator( + model_name, + device, + offload=offload, + ) + + image = generator.generate_image( + width=1024, + height=1024, + num_steps=num_steps, + guidance=0.0, + seed=seed, + prompt=prompt, + concepts=concepts, + joint_attention_kwargs=joint_attention_kwargs, + ) + + concept_vectors = [] + image_vectors = [] + supplemental_vectors = [] + for double_block in generator.model.double_blocks: + if target_space == "output": + image_vecs = torch.stack( + double_block.image_output_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_output_vectors + ).squeeze(1) + image_supplemental_vecs = image_vecs + # Clear out the layer + double_block.clear_cached_vectors() + elif target_space == "value": + image_vecs = torch.stack( + double_block.image_value_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_value_vectors + ).squeeze(1) + image_supplemental_vecs = image_vecs + # Clear out the layer + double_block.clear_cached_vectors() + elif target_space == "cross_attention": + image_vecs = torch.stack( + double_block.image_query_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_key_vectors + ).squeeze(1) + image_supplemental_vecs = torch.stack( + double_block.image_key_vectors + ).squeeze(1) + # Clear out the layer + double_block.clear_cached_vectors() + else: + raise ValueError("Invalid target space") + # Average over time + if average_over_time: + image_vecs = image_vecs[average_after:].mean(dim=0) + concept_vecs = concept_vecs[average_after:].mean(dim=0) + image_supplemental_vecs = image_supplemental_vecs[average_after:].mean(dim=0) + # Add to list + concept_vectors.append(concept_vecs) + image_vectors.append(image_vecs) + supplemental_vectors.append(image_supplemental_vecs) + # Stack layers + concept_vectors = torch.stack(concept_vectors) + if include_images_in_basis: + supplemental_vectors = torch.stack(supplemental_vectors) + concept_vectors = torch.cat([concept_vectors, supplemental_vectors], dim=-2) + image_vectors = torch.stack(image_vectors) + + if layer_index is not None: + # Pull out the layer index + concept_vectors = concept_vectors[layer_index] + image_vectors = image_vectors[layer_index] + + # Apply linear normalization to concepts + # NOTE: This is very important, as it makes up for not being able to do softmax + if normalize_concepts: + concept_vectors = linear_normalization(concept_vectors, dim=-2) + + return image, concept_vectors, image_vectors \ No newline at end of file diff --git a/concept_attention/diffusers/flux/__init__.py b/concept_attention/diffusers/flux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9f9a2eea851fca06bf8219ffe960e753615b0a11 --- /dev/null +++ b/concept_attention/diffusers/flux/__init__.py @@ -0,0 +1,2 @@ +from concept_attention.diffusers.flux.flux_with_concept_attention_pipeline import FluxWithConceptAttentionPipeline +from concept_attention.diffusers.flux.flux_dit_with_concept_attention import FluxTransformer2DModelWithConceptAttention \ No newline at end of file diff --git a/concept_attention/diffusers/flux/flux_dit_block_with_concept_attention.py b/concept_attention/diffusers/flux/flux_dit_block_with_concept_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..da92c0dc65e5f73b6fb39635538ea8bffb048333 --- /dev/null +++ b/concept_attention/diffusers/flux/flux_dit_block_with_concept_attention.py @@ -0,0 +1,122 @@ + +import torch +from typing import Any, Dict, Optional, Tuple +from torch import nn +import einops + +concept_attention_default_kwargs = { + "concept_attention_layers": list(range(10, 18)), + "concepts": None, +} + +from diffusers.models.transformers.transformer_flux import FluxTransformerBlock + +class FluxTransformerBlockWithConceptAttention(FluxTransformerBlock): + r""" + A Transformer block following the MMDiT architecture, introduced in Stable Diffusion 3 with Concept Attention. + """ + + @torch.no_grad() + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + concept_hidden_states: torch.Tensor, + temb: torch.Tensor, + concept_temb: torch.Tensor, + image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + concept_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + concept_attention_kwargs: Optional[Dict[str, Any]] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1( + hidden_states, + emb=temb + ) + norm_encoder_hidden_states, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp = self.norm1_context( + encoder_hidden_states, + emb=temb + ) + joint_attention_kwargs = joint_attention_kwargs or {} + # Attention + attention_outputs = self.attn( + hidden_states=norm_hidden_states, + encoder_hidden_states=norm_encoder_hidden_states, + image_rotary_emb=image_rotary_emb, + **joint_attention_kwargs, + ) + + if len(attention_outputs) == 2: + attn_output, context_attn_output = attention_outputs + elif len(attention_outputs) == 3: + attn_output, context_attn_output, ip_attn_output = attention_outputs + ################################ Do Concept Attention ################################ + if concept_attention_kwargs is not None and concept_hidden_states is not None: + # Normalize the concept hidden states + norm_concept_hidden_states, concept_gate_msa, concept_shift_mlp, concept_scale_mlp, concept_gate_mlp = self.norm1_context( + concept_hidden_states, + emb=concept_temb + ) + # Process the attention outputs for the concept_hidden_states. + # NOTE: This does some unecessary computations, but it is fine for now. + concept_attention_outputs = self.attn( + hidden_states=norm_hidden_states, + encoder_hidden_states=norm_concept_hidden_states, + image_rotary_emb=concept_rotary_emb, + **joint_attention_kwargs, + ) + # Unpack the attention outputs + if len(attention_outputs) == 2: + _, concept_attn_output = concept_attention_outputs + elif len(attention_outputs) == 3: + _, concept_attn_output, _ = concept_attention_outputs + # Now compute the concept attention maps + concept_attention_map = einops.einsum( + concept_attn_output, # Concept attention output + attn_output, # Image attention output + "batch concepts dim, batch patches dim -> batch concepts patches", # Einsum equation + ) + # Detach and move to cpu the concept attention map + concept_attention_map = concept_attention_map.detach().cpu() + # Now do the residual stream update + concept_attn_output = concept_gate_msa.unsqueeze(1) * concept_attn_output + concept_hidden_states = concept_hidden_states + concept_attn_output + norm_concept_hidden_states = self.norm2_context(concept_hidden_states) + norm_concept_hidden_states = norm_concept_hidden_states * (1 + concept_scale_mlp[:, None]) + concept_shift_mlp[:, None] + concept_ff_output = self.ff_context(norm_concept_hidden_states) + concept_hidden_states = concept_hidden_states + concept_gate_mlp.unsqueeze(1) * concept_ff_output + if concept_hidden_states.dtype == torch.float16: + concept_hidden_states = concept_hidden_states.clip(-65504, 65504) + else: + concept_attention_map = None + concept_hidden_states = None + ###################################################################################### + + # Process attention outputs for the `hidden_states`. + attn_output = gate_msa.unsqueeze(1) * attn_output + hidden_states = hidden_states + attn_output + + norm_hidden_states = self.norm2(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] + + ff_output = self.ff(norm_hidden_states) + ff_output = gate_mlp.unsqueeze(1) * ff_output + + hidden_states = hidden_states + ff_output + if len(attention_outputs) == 3: + hidden_states = hidden_states + ip_attn_output + + # Process attention outputs for the `encoder_hidden_states`. + + context_attn_output = c_gate_msa.unsqueeze(1) * context_attn_output + encoder_hidden_states = encoder_hidden_states + context_attn_output + + norm_encoder_hidden_states = self.norm2_context(encoder_hidden_states) + norm_encoder_hidden_states = norm_encoder_hidden_states * (1 + c_scale_mlp[:, None]) + c_shift_mlp[:, None] + + context_ff_output = self.ff_context(norm_encoder_hidden_states) + encoder_hidden_states = encoder_hidden_states + c_gate_mlp.unsqueeze(1) * context_ff_output + if encoder_hidden_states.dtype == torch.float16: + encoder_hidden_states = encoder_hidden_states.clip(-65504, 65504) + + return encoder_hidden_states, hidden_states, concept_hidden_states, concept_attention_map \ No newline at end of file diff --git a/concept_attention/diffusers/flux/flux_dit_with_concept_attention.py b/concept_attention/diffusers/flux/flux_dit_with_concept_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..097006f7239adf1f5758a2f8e2d7c9c921450b7e --- /dev/null +++ b/concept_attention/diffusers/flux/flux_dit_with_concept_attention.py @@ -0,0 +1,281 @@ + +import torch +import numpy as np +from typing import Any, Dict, Optional, Tuple, Union +from torch import nn + +from diffusers.models.transformers.transformer_flux import FluxTransformer2DModel +from diffusers.models.transformers.transformer_flux import FluxSingleTransformerBlock +from diffusers.models.normalization import AdaLayerNormContinuous +from diffusers.utils import USE_PEFT_BACKEND, is_torch_version, logging, scale_lora_layers, unscale_lora_layers, BaseOutput +from diffusers.utils.import_utils import is_torch_npu_available +from diffusers.utils.torch_utils import maybe_allow_in_graph +from diffusers.models.embeddings import CombinedTimestepGuidanceTextProjEmbeddings, CombinedTimestepTextProjEmbeddings, FluxPosEmbed + +from concept_attention.diffusers.flux.flux_dit_block_with_concept_attention import FluxTransformerBlockWithConceptAttention + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +class FluxTransformer2DOutputWithConceptAttention(BaseOutput): + sample: torch.Tensor + concept_attention_maps: torch.Tensor + +class FluxTransformer2DModelWithConceptAttention(FluxTransformer2DModel): + """ + The Transformer model introduced in Flux with Concept Attention. + """ + + + def __init__( + self, + patch_size: int = 1, + in_channels: int = 64, + out_channels: Optional[int] = None, + num_layers: int = 19, + num_single_layers: int = 38, + attention_head_dim: int = 128, + num_attention_heads: int = 24, + joint_attention_dim: int = 4096, + pooled_projection_dim: int = 768, + guidance_embeds: bool = False, + axes_dims_rope: Tuple[int] = (16, 56, 56), + ): + super().__init__() + self.out_channels = out_channels or in_channels + self.inner_dim = self.config.num_attention_heads * self.config.attention_head_dim + + self.pos_embed = FluxPosEmbed(theta=10000, axes_dim=axes_dims_rope) + + text_time_guidance_cls = ( + CombinedTimestepGuidanceTextProjEmbeddings if guidance_embeds else CombinedTimestepTextProjEmbeddings + ) + self.time_text_embed = text_time_guidance_cls( + embedding_dim=self.inner_dim, pooled_projection_dim=self.config.pooled_projection_dim + ) + + self.context_embedder = nn.Linear(self.config.joint_attention_dim, self.inner_dim) + self.x_embedder = nn.Linear(self.config.in_channels, self.inner_dim) + + self.transformer_blocks = nn.ModuleList( + [ + FluxTransformerBlockWithConceptAttention( + dim=self.inner_dim, + num_attention_heads=self.config.num_attention_heads, + attention_head_dim=self.config.attention_head_dim, + ) + for i in range(self.config.num_layers) + ] + ) + + self.single_transformer_blocks = nn.ModuleList( + [ + FluxSingleTransformerBlock( + dim=self.inner_dim, + num_attention_heads=self.config.num_attention_heads, + attention_head_dim=self.config.attention_head_dim, + ) + for i in range(self.config.num_single_layers) + ] + ) + + self.norm_out = AdaLayerNormContinuous(self.inner_dim, self.inner_dim, elementwise_affine=False, eps=1e-6) + self.proj_out = nn.Linear(self.inner_dim, patch_size * patch_size * self.out_channels, bias=True) + + self.gradient_checkpointing = False + + @torch.no_grad() + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor = None, + concept_hidden_states: torch.Tensor = None, + pooled_projections: torch.Tensor = None, + pooled_concept_embeds: torch.Tensor = None, + timestep: torch.LongTensor = None, + img_ids: torch.Tensor = None, + txt_ids: torch.Tensor = None, + concept_ids: torch.Tensor = None, + guidance: torch.Tensor = None, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + concept_attention_kwargs: Optional[Dict[str, Any]] = None, + controlnet_block_samples=None, + controlnet_single_block_samples=None, + return_dict: bool = True, + controlnet_blocks_repeat: bool = False, + ) -> Union[torch.Tensor, FluxTransformer2DOutputWithConceptAttention]: + """ + The [`FluxTransformer2DModel`] forward method. + + Args: + hidden_states (`torch.Tensor` of shape `(batch_size, image_sequence_length, in_channels)`): + Input `hidden_states`. + encoder_hidden_states (`torch.Tensor` of shape `(batch_size, text_sequence_length, joint_attention_dim)`): + Conditional embeddings (embeddings computed from the input conditions such as prompts) to use. + pooled_projections (`torch.Tensor` of shape `(batch_size, projection_dim)`): Embeddings projected + from the embeddings of input conditions. + timestep ( `torch.LongTensor`): + Used to indicate denoising step. + block_controlnet_hidden_states: (`list` of `torch.Tensor`): + A list of tensors that if specified are added to the residuals of transformer blocks. + joint_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + concept_attention_kwargs (`dict`, *optional*): + A kwargs dictionary with parameters for Concept Attention. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.transformer_2d.Transformer2DModelOutput`] instead of a plain + tuple. + + Returns: + If `return_dict` is True, an [`~models.transformer_2d.Transformer2DModelOutput`] is returned, otherwise a + `tuple` where the first element is the sample tensor. + """ + if joint_attention_kwargs is not None: + joint_attention_kwargs = joint_attention_kwargs.copy() + lora_scale = joint_attention_kwargs.pop("scale", 1.0) + else: + lora_scale = 1.0 + + if USE_PEFT_BACKEND: + # weight the lora layers by setting `lora_scale` for each PEFT layer + scale_lora_layers(self, lora_scale) + else: + if joint_attention_kwargs is not None and joint_attention_kwargs.get("scale", None) is not None: + logger.warning( + "Passing `scale` via `joint_attention_kwargs` when not using the PEFT backend is ineffective." + ) + + hidden_states = self.x_embedder(hidden_states) + + timestep = timestep.to(hidden_states.dtype) * 1000 + if guidance is not None: + guidance = guidance.to(hidden_states.dtype) * 1000 + else: + guidance = None + + temb = ( + self.time_text_embed(timestep, pooled_projections) + if guidance is None + else self.time_text_embed(timestep, guidance, pooled_projections) + ) + encoder_hidden_states = self.context_embedder(encoder_hidden_states) + + if pooled_concept_embeds is not None: + if guidance is None: + concept_temb = self.time_text_embed(timestep, pooled_concept_embeds) + else: + concept_temb = self.time_text_embed(timestep, guidance, pooled_concept_embeds) + + # Apply the context embedder to the concept_hidden_states + if concept_hidden_states is not None: + concept_hidden_states = self.context_embedder(concept_hidden_states) + + if txt_ids.ndim == 3: + logger.warning( + "Passing `txt_ids` 3d torch.Tensor is deprecated." + "Please remove the batch dimension and pass it as a 2d torch Tensor" + ) + txt_ids = txt_ids[0] + if img_ids.ndim == 3: + logger.warning( + "Passing `img_ids` 3d torch.Tensor is deprecated." + "Please remove the batch dimension and pass it as a 2d torch Tensor" + ) + img_ids = img_ids[0] + + ids = torch.cat((txt_ids, img_ids), dim=0) + image_rotary_emb = self.pos_embed(ids) + + concept_image_ids = torch.cat((concept_ids, img_ids), dim=0) + concept_rotary_emb = self.pos_embed(concept_image_ids) + + if joint_attention_kwargs is not None and "ip_adapter_image_embeds" in joint_attention_kwargs: + ip_adapter_image_embeds = joint_attention_kwargs.pop("ip_adapter_image_embeds") + ip_hidden_states = self.encoder_hid_proj(ip_adapter_image_embeds) + joint_attention_kwargs.update({"ip_hidden_states": ip_hidden_states}) + + all_concept_attention_maps = [] + for index_block, block in enumerate(self.transformer_blocks): + if torch.is_grad_enabled() and self.gradient_checkpointing: + encoder_hidden_states, hidden_states = self._gradient_checkpointing_func( + block, + hidden_states, + encoder_hidden_states, + temb, + image_rotary_emb, + ) + else: + encoder_hidden_states, hidden_states, concept_hidden_states, concept_attention_maps = block( + hidden_states=hidden_states, + encoder_hidden_states=encoder_hidden_states, + concept_hidden_states=concept_hidden_states, + temb=temb, + concept_temb=concept_temb, + image_rotary_emb=image_rotary_emb, + concept_rotary_emb=concept_rotary_emb, + joint_attention_kwargs=joint_attention_kwargs, + concept_attention_kwargs=concept_attention_kwargs, + ) + if concept_attention_maps is not None and index_block in concept_attention_kwargs["layers"]: + all_concept_attention_maps.append(concept_attention_maps) + del concept_attention_maps + + # controlnet residual + if controlnet_block_samples is not None: + interval_control = len(self.transformer_blocks) / len(controlnet_block_samples) + interval_control = int(np.ceil(interval_control)) + # For Xlabs ControlNet. + if controlnet_blocks_repeat: + hidden_states = ( + hidden_states + controlnet_block_samples[index_block % len(controlnet_block_samples)] + ) + else: + hidden_states = hidden_states + controlnet_block_samples[index_block // interval_control] + + if concept_hidden_states is not None: + concept_hidden_states = concept_hidden_states.cpu() + hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1) + + if len(all_concept_attention_maps) > 0: + all_concept_attention_maps = torch.stack(all_concept_attention_maps, dim=0) + else: + all_concept_attention_maps = None + + for index_block, block in enumerate(self.single_transformer_blocks): + if torch.is_grad_enabled() and self.gradient_checkpointing: + hidden_states = self._gradient_checkpointing_func( + block, + hidden_states, + temb, + image_rotary_emb, + ) + else: + hidden_states = block( + hidden_states=hidden_states, + temb=temb, + image_rotary_emb=image_rotary_emb, + joint_attention_kwargs=joint_attention_kwargs, + ) + # controlnet residual + if controlnet_single_block_samples is not None: + interval_control = len(self.single_transformer_blocks) / len(controlnet_single_block_samples) + interval_control = int(np.ceil(interval_control)) + hidden_states[:, encoder_hidden_states.shape[1] :, ...] = ( + hidden_states[:, encoder_hidden_states.shape[1] :, ...] + + controlnet_single_block_samples[index_block // interval_control] + ) + + hidden_states = hidden_states[:, encoder_hidden_states.shape[1] :, ...] + + hidden_states = self.norm_out(hidden_states, temb) + output = self.proj_out(hidden_states) + + if USE_PEFT_BACKEND: + # remove `lora_scale` from each PEFT layer + unscale_lora_layers(self, lora_scale) + + if not return_dict: + return (output, all_concept_attention_maps) + + return FluxTransformer2DOutputWithConceptAttention(sample=output, concept_attention_maps=all_concept_attention_maps) diff --git a/concept_attention/diffusers/flux/flux_with_concept_attention_pipeline.py b/concept_attention/diffusers/flux/flux_with_concept_attention_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..68d1d605aaf28ad97d46dd2ef099e0bbced5f210 --- /dev/null +++ b/concept_attention/diffusers/flux/flux_with_concept_attention_pipeline.py @@ -0,0 +1,1022 @@ +""" + Here we make various wrapper classes for the FluxPipeline from diffusers + to add the concept attention functionality. + + We opt for a wrapper functionality +""" +import torch +import numpy as np +from typing import List, Union, Optional, Dict, Any, Callable +import PIL.Image +import einops +import matplotlib.pyplot as plt + +from diffusers import DiffusionPipeline +from diffusers.image_processor import PipelineImageInput +from diffusers.pipelines.flux.pipeline_flux import retrieve_timesteps, calculate_shift +from diffusers.utils import is_torch_xla_available, BaseOutput, logging, USE_PEFT_BACKEND, \ + scale_lora_layers, unscale_lora_layers + +from diffusers.utils.torch_utils import randn_tensor + +from diffusers.image_processor import PipelineImageInput, VaeImageProcessor +from diffusers.loaders import FluxIPAdapterMixin, FluxLoraLoaderMixin, FromSingleFileMixin, TextualInversionLoaderMixin +from diffusers.models.autoencoders import AutoencoderKL +from diffusers.models.transformers import FluxTransformer2DModel +from diffusers.schedulers import FlowMatchEulerDiscreteScheduler + +from transformers import ( + CLIPImageProcessor, + CLIPTextModel, + CLIPTokenizer, + CLIPVisionModelWithProjection, + T5EncoderModel, + T5TokenizerFast, +) + +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm + + XLA_AVAILABLE = True +else: + XLA_AVAILABLE = False + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +class FluxConceptAttentionOutput(BaseOutput): + """ + Output class for the FluxPipeline with concept attention functionality. + + Args: + images (`List[PIL.Image.Image]` or `np.ndarray`) + The generated images. + concept_attention_maps (`List[PIL.Image.Image]` or `np.ndarray`) + The concept attention maps. + """ + images: Union[List[PIL.Image.Image], np.ndarray] + concept_attention_maps: Union[List[PIL.Image.Image], np.ndarray] + +class FluxWithConceptAttentionPipeline( + DiffusionPipeline, + FluxLoraLoaderMixin, + FromSingleFileMixin, + TextualInversionLoaderMixin, + FluxIPAdapterMixin, +): + r""" + The Flux pipeline for text-to-image generation with added Concept Attention. + + Reference: https://blackforestlabs.ai/announcing-black-forest-labs/ + + Args: + transformer ([`FluxTransformer2DModel`]): + Conditional Transformer (MMDiT) architecture to denoise the encoded image latents. + scheduler ([`FlowMatchEulerDiscreteScheduler`]): + A scheduler to be used in combination with `transformer` to denoise the encoded image latents. + vae ([`AutoencoderKL`]): + Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. + text_encoder ([`CLIPTextModel`]): + [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically + the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant. + text_encoder_2 ([`T5EncoderModel`]): + [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically + the [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) variant. + tokenizer (`CLIPTokenizer`): + Tokenizer of class + [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer). + tokenizer_2 (`T5TokenizerFast`): + Second Tokenizer of class + [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast). + """ + + model_cpu_offload_seq = "text_encoder->text_encoder_2->image_encoder->transformer->vae" + _optional_components = ["image_encoder", "feature_extractor"] + _callback_tensor_inputs = ["latents", "prompt_embeds"] + + def __init__( + self, + scheduler: FlowMatchEulerDiscreteScheduler, + vae: AutoencoderKL, + text_encoder: CLIPTextModel, + tokenizer: CLIPTokenizer, + text_encoder_2: T5EncoderModel, + tokenizer_2: T5TokenizerFast, + transformer: FluxTransformer2DModel, + image_encoder: CLIPVisionModelWithProjection = None, + feature_extractor: CLIPImageProcessor = None, + ): + super().__init__() + + self.register_modules( + vae=vae, + text_encoder=text_encoder, + text_encoder_2=text_encoder_2, + tokenizer=tokenizer, + tokenizer_2=tokenizer_2, + transformer=transformer, + scheduler=scheduler, + image_encoder=image_encoder, + feature_extractor=feature_extractor, + ) + self.vae_scale_factor = ( + 2 ** (len(self.vae.config.block_out_channels) - 1) if hasattr(self, "vae") and self.vae is not None else 8 + ) + # Flux latents are turned into 2x2 patches and packed. This means the latent width and height has to be divisible + # by the patch size. So the vae scale factor is multiplied by the patch size to account for this + self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor * 2) + self.tokenizer_max_length = ( + self.tokenizer.model_max_length if hasattr(self, "tokenizer") and self.tokenizer is not None else 77 + ) + self.default_sample_size = 128 + + def _get_t5_prompt_embeds( + self, + prompt: Union[str, List[str]] = None, + num_images_per_prompt: int = 1, + max_sequence_length: int = 512, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + ): + device = device or self._execution_device + dtype = dtype or self.text_encoder.dtype + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + if isinstance(self, TextualInversionLoaderMixin): + prompt = self.maybe_convert_prompt(prompt, self.tokenizer_2) + + text_inputs = self.tokenizer_2( + prompt, + padding="max_length", + max_length=max_sequence_length, + truncation=True, + return_length=False, + return_overflowing_tokens=False, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer_2(prompt, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = self.tokenizer_2.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because `max_sequence_length` is set to " + f" {max_sequence_length} tokens: {removed_text}" + ) + + prompt_embeds = self.text_encoder_2(text_input_ids.to(device), output_hidden_states=False)[0] + + dtype = self.text_encoder_2.dtype + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + _, seq_len, _ = prompt_embeds.shape + + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + return prompt_embeds + + def _get_clip_prompt_embeds( + self, + prompt: Union[str, List[str]], + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + ): + device = device or self._execution_device + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + if isinstance(self, TextualInversionLoaderMixin): + prompt = self.maybe_convert_prompt(prompt, self.tokenizer) + + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=self.tokenizer_max_length, + truncation=True, + return_overflowing_tokens=False, + return_length=False, + return_tensors="pt", + ) + + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because CLIP can only handle sequences up to" + f" {self.tokenizer_max_length} tokens: {removed_text}" + ) + prompt_embeds = self.text_encoder(text_input_ids.to(device), output_hidden_states=False) + + # Use pooled output of CLIPTextModel + prompt_embeds = prompt_embeds.pooler_output + prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device) + + # duplicate text embeddings for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, -1) + + return prompt_embeds + + def encode_prompt( + self, + prompt: Union[str, List[str]], + prompt_2: Union[str, List[str]], + device: Optional[torch.device] = None, + num_images_per_prompt: int = 1, + prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + max_sequence_length: int = 512, + lora_scale: Optional[float] = None, + ): + r""" + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + used in all text-encoders + device: (`torch.device`): + torch device + num_images_per_prompt (`int`): + number of images that should be generated per prompt + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + lora_scale (`float`, *optional*): + A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded. + """ + device = device or self._execution_device + + # set lora scale so that monkey patched LoRA + # function of text encoder can correctly access it + if lora_scale is not None and isinstance(self, FluxLoraLoaderMixin): + self._lora_scale = lora_scale + + # dynamically adjust the LoRA scale + if self.text_encoder is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder, lora_scale) + if self.text_encoder_2 is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder_2, lora_scale) + + prompt = [prompt] if isinstance(prompt, str) else prompt + + if prompt_embeds is None: + prompt_2 = prompt_2 or prompt + prompt_2 = [prompt_2] if isinstance(prompt_2, str) else prompt_2 + + # We only use the pooled prompt output from the CLIPTextModel + pooled_prompt_embeds = self._get_clip_prompt_embeds( + prompt=prompt, + device=device, + num_images_per_prompt=num_images_per_prompt, + ) + prompt_embeds = self._get_t5_prompt_embeds( + prompt=prompt_2, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + device=device, + ) + + if self.text_encoder is not None: + if isinstance(self, FluxLoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder, lora_scale) + + if self.text_encoder_2 is not None: + if isinstance(self, FluxLoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder_2, lora_scale) + + dtype = self.text_encoder.dtype if self.text_encoder is not None else self.transformer.dtype + text_ids = torch.zeros(prompt_embeds.shape[1], 3).to(device=device, dtype=dtype) + + return prompt_embeds, pooled_prompt_embeds, text_ids + + def encode_concepts(self, concepts: List[str], device: Optional[torch.device] = None): + """ + Encodes our concept vectors using the T5 Encoder. + """ + """ + # Utils for concept encoding + def embed_concepts( + clip, + t5, + concepts: list[str], + batch_size=1 + ): + # Code pulled from concept_attention.flux/sampling.py: prepare() + # Embed each concept separately + concept_embeddings = [] + for concept in concepts: + concept_embedding = t5(concept) + # Pull out the first token + token_embedding = concept_embedding[0, 0, :] # First token of first prompt + concept_embeddings.append(token_embedding) + concept_embeddings = torch.stack(concept_embeddings).unsqueeze(0) + # Add filler tokens of zeros + concept_ids = torch.zeros(batch_size, concept_embeddings.shape[1], 3) + + # Embed the concepts to a clip vector + prompt = " ".join(concepts) + vec = clip(prompt) + vec = torch.zeros_like(vec).to(vec.device) + + return concept_embeddings, concept_ids, vec + """ + + concept_embeds = self._get_t5_prompt_embeds( + prompt=concepts, + num_images_per_prompt=1, + max_sequence_length=64, + device=device, + ) + # Pull out the first token of each embedded concept to get the concept embeddings + concept_embeds = concept_embeds[:, 0, :] + concept_embeds = concept_embeds.unsqueeze(0) + # Make the CLIP vector for the concepts + clip_vec = self._get_clip_prompt_embeds( + prompt=" ".join(concepts), + num_images_per_prompt=1, + device=device, + ) + # # Set the vec to zero + # clip_vec = torch.zeros_like(clip_vec).to(clip_vec.device) + # # Add filler tokens of zeros + concept_ids = torch.zeros(concept_embeds.shape[1], 3).to(device=device, dtype=concept_embeds.dtype) + + return concept_embeds, clip_vec, concept_ids + + def encode_image(self, image, device, num_images_per_prompt): + dtype = next(self.image_encoder.parameters()).dtype + + if not isinstance(image, torch.Tensor): + image = self.feature_extractor(image, return_tensors="pt").pixel_values + + image = image.to(device=device, dtype=dtype) + image_embeds = self.image_encoder(image).image_embeds + image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0) + return image_embeds + + def prepare_ip_adapter_image_embeds( + self, ip_adapter_image, ip_adapter_image_embeds, device, num_images_per_prompt + ): + image_embeds = [] + if ip_adapter_image_embeds is None: + if not isinstance(ip_adapter_image, list): + ip_adapter_image = [ip_adapter_image] + + if len(ip_adapter_image) != len(self.transformer.encoder_hid_proj.image_projection_layers): + raise ValueError( + f"`ip_adapter_image` must have same length as the number of IP Adapters. Got {len(ip_adapter_image)} images and {len(self.transformer.encoder_hid_proj.image_projection_layers)} IP Adapters." + ) + + for single_ip_adapter_image, image_proj_layer in zip( + ip_adapter_image, self.transformer.encoder_hid_proj.image_projection_layers + ): + single_image_embeds = self.encode_image(single_ip_adapter_image, device, 1) + + image_embeds.append(single_image_embeds[None, :]) + else: + for single_image_embeds in ip_adapter_image_embeds: + image_embeds.append(single_image_embeds) + + ip_adapter_image_embeds = [] + for i, single_image_embeds in enumerate(image_embeds): + single_image_embeds = torch.cat([single_image_embeds] * num_images_per_prompt, dim=0) + single_image_embeds = single_image_embeds.to(device=device) + ip_adapter_image_embeds.append(single_image_embeds) + + return ip_adapter_image_embeds + + def check_inputs( + self, + prompt, + prompt_2, + height, + width, + negative_prompt=None, + negative_prompt_2=None, + prompt_embeds=None, + negative_prompt_embeds=None, + pooled_prompt_embeds=None, + negative_pooled_prompt_embeds=None, + callback_on_step_end_tensor_inputs=None, + max_sequence_length=None, + ): + if height % (self.vae_scale_factor * 2) != 0 or width % (self.vae_scale_factor * 2) != 0: + logger.warning( + f"`height` and `width` have to be divisible by {self.vae_scale_factor * 2} but are {height} and {width}. Dimensions will be resized accordingly" + ) + + if callback_on_step_end_tensor_inputs is not None and not all( + k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs + ): + raise ValueError( + f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}" + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt_2 is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt_2`: {prompt_2} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + elif prompt_2 is not None and (not isinstance(prompt_2, str) and not isinstance(prompt_2, list)): + raise ValueError(f"`prompt_2` has to be of type `str` or `list` but is {type(prompt_2)}") + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + elif negative_prompt_2 is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt_2`: {negative_prompt_2} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + + if prompt_embeds is not None and pooled_prompt_embeds is None: + raise ValueError( + "If `prompt_embeds` are provided, `pooled_prompt_embeds` also have to be passed. Make sure to generate `pooled_prompt_embeds` from the same text encoder that was used to generate `prompt_embeds`." + ) + if negative_prompt_embeds is not None and negative_pooled_prompt_embeds is None: + raise ValueError( + "If `negative_prompt_embeds` are provided, `negative_pooled_prompt_embeds` also have to be passed. Make sure to generate `negative_pooled_prompt_embeds` from the same text encoder that was used to generate `negative_prompt_embeds`." + ) + + if max_sequence_length is not None and max_sequence_length > 512: + raise ValueError(f"`max_sequence_length` cannot be greater than 512 but is {max_sequence_length}") + + @staticmethod + def _prepare_latent_image_ids(batch_size, height, width, device, dtype): + latent_image_ids = torch.zeros(height, width, 3) + latent_image_ids[..., 1] = latent_image_ids[..., 1] + torch.arange(height)[:, None] + latent_image_ids[..., 2] = latent_image_ids[..., 2] + torch.arange(width)[None, :] + + latent_image_id_height, latent_image_id_width, latent_image_id_channels = latent_image_ids.shape + + latent_image_ids = latent_image_ids.reshape( + latent_image_id_height * latent_image_id_width, latent_image_id_channels + ) + + return latent_image_ids.to(device=device, dtype=dtype) + + @staticmethod + def _pack_latents(latents, batch_size, num_channels_latents, height, width): + latents = latents.view(batch_size, num_channels_latents, height // 2, 2, width // 2, 2) + latents = latents.permute(0, 2, 4, 1, 3, 5) + latents = latents.reshape(batch_size, (height // 2) * (width // 2), num_channels_latents * 4) + + return latents + + @staticmethod + def _unpack_latents(latents, height, width, vae_scale_factor): + batch_size, num_patches, channels = latents.shape + + # VAE applies 8x compression on images but we must also account for packing which requires + # latent height and width to be divisible by 2. + height = 2 * (int(height) // (vae_scale_factor * 2)) + width = 2 * (int(width) // (vae_scale_factor * 2)) + + latents = latents.view(batch_size, height // 2, width // 2, channels // 4, 2, 2) + latents = latents.permute(0, 3, 1, 4, 2, 5) + + latents = latents.reshape(batch_size, channels // (2 * 2), height, width) + + return latents + + def enable_vae_slicing(self): + r""" + Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + """ + self.vae.enable_slicing() + + def disable_vae_slicing(self): + r""" + Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to + computing decoding in one step. + """ + self.vae.disable_slicing() + + def enable_vae_tiling(self): + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger images. + """ + self.vae.enable_tiling() + + def disable_vae_tiling(self): + r""" + Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to + computing decoding in one step. + """ + self.vae.disable_tiling() + + def prepare_latents( + self, + batch_size, + num_channels_latents, + height, + width, + dtype, + device, + generator, + latents=None, + ): + # VAE applies 8x compression on images but we must also account for packing which requires + # latent height and width to be divisible by 2. + height = 2 * (int(height) // (self.vae_scale_factor * 2)) + width = 2 * (int(width) // (self.vae_scale_factor * 2)) + + shape = (batch_size, num_channels_latents, height, width) + + if latents is not None: + latent_image_ids = self._prepare_latent_image_ids(batch_size, height // 2, width // 2, device, dtype) + return latents.to(device=device, dtype=dtype), latent_image_ids + + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + latents = self._pack_latents(latents, batch_size, num_channels_latents, height, width) + + latent_image_ids = self._prepare_latent_image_ids(batch_size, height // 2, width // 2, device, dtype) + + return latents, latent_image_ids + + @property + def guidance_scale(self): + return self._guidance_scale + + @property + def joint_attention_kwargs(self): + return self._joint_attention_kwargs + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + + @torch.no_grad() + def __call__( + self, + prompt: Union[str, List[str]] = None, + prompt_2: Optional[Union[str, List[str]]] = None, + negative_prompt: Union[str, List[str]] = None, + negative_prompt_2: Optional[Union[str, List[str]]] = None, + true_cfg_scale: float = 1.0, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 28, + sigmas: Optional[List[float]] = None, + guidance_scale: float = 3.5, + num_images_per_prompt: Optional[int] = 1, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + ip_adapter_image: Optional[PipelineImageInput] = None, + ip_adapter_image_embeds: Optional[List[torch.Tensor]] = None, + negative_ip_adapter_image: Optional[PipelineImageInput] = None, + negative_ip_adapter_image_embeds: Optional[List[torch.Tensor]] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + concept_attention_kwargs: Optional[Dict[str, Any]] = None, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], + max_sequence_length: int = 512, + ): + r""" + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + will be used instead. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `true_cfg_scale` is + not greater than `1`). + negative_prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and + `text_encoder_2`. If not defined, `negative_prompt` is used in all the text-encoders. + true_cfg_scale (`float`, *optional*, defaults to 1.0): + When > 1.0 and a provided `negative_prompt`, enables true classifier-free guidance. + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. This is set to 1024 by default for the best results. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. This is set to 1024 by default for the best results. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + sigmas (`List[float]`, *optional*): + Custom sigmas to use for the denoising process with schedulers which support a `sigmas` argument in + their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is passed + will be used. + guidance_scale (`float`, *optional*, defaults to 7.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + ip_adapter_image: (`PipelineImageInput`, *optional*): Optional image input to work with IP Adapters. + ip_adapter_image_embeds (`List[torch.Tensor]`, *optional*): + Pre-generated image embeddings for IP-Adapter. It should be a list of length same as number of + IP-adapters. Each element should be a tensor of shape `(batch_size, num_images, emb_dim)`. If not + provided, embeddings are computed from the `ip_adapter_image` input argument. + negative_ip_adapter_image: + (`PipelineImageInput`, *optional*): Optional image input to work with IP Adapters. + negative_ip_adapter_image_embeds (`List[torch.Tensor]`, *optional*): + Pre-generated image embeddings for IP-Adapter. It should be a list of length same as number of + IP-adapters. Each element should be a tensor of shape `(batch_size, num_images, emb_dim)`. If not + provided, embeddings are computed from the `ip_adapter_image` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` + input argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.flux.FluxPipelineOutput`] instead of a plain tuple. + joint_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`List`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. + max_sequence_length (`int` defaults to 512): Maximum sequence length to use with the `prompt`. + + Examples: + + Returns: + [`~pipelines.flux.FluxPipelineOutput`] or `tuple`: [`~pipelines.flux.FluxPipelineOutput`] if `return_dict` + is True, otherwise a `tuple`. When returning a tuple, the first element is a list with the generated + images. + """ + # Verify the concept kwargs inputs + if concept_attention_kwargs is not None: + assert "concepts" in concept_attention_kwargs, "Concepts must be passed in the concept_attention_kwargs" + assert isinstance(concept_attention_kwargs["concepts"], list), "Concepts must be a list of strings" + assert len(concept_attention_kwargs["concepts"]) > 0, "Concepts must not be an empty list" + assert "timesteps" in concept_attention_kwargs, "Timesteps must be passed in the concept_attention_kwargs" + assert isinstance(concept_attention_kwargs["timesteps"], list), "Timesteps must be a list of integers" + assert len(concept_attention_kwargs["timesteps"]) > 0, "Timesteps must not be an empty list" + assert "layers" in concept_attention_kwargs, "Layers must be passed in the concept_attention_kwargs" + assert isinstance(concept_attention_kwargs["layers"], list), "Layers must be a list of integers" + assert len(concept_attention_kwargs["layers"]) > 0, "Layers must not be an empty list" + + height = height or self.default_sample_size * self.vae_scale_factor + width = width or self.default_sample_size * self.vae_scale_factor + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + prompt_2, + height, + width, + negative_prompt=negative_prompt, + negative_prompt_2=negative_prompt_2, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + max_sequence_length=max_sequence_length, + ) + + self._guidance_scale = guidance_scale + self._joint_attention_kwargs = joint_attention_kwargs + self._current_timestep = None + self._interrupt = False + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + lora_scale = ( + self.joint_attention_kwargs.get("scale", None) if self.joint_attention_kwargs is not None else None + ) + has_neg_prompt = negative_prompt is not None or ( + negative_prompt_embeds is not None and negative_pooled_prompt_embeds is not None + ) + do_true_cfg = true_cfg_scale > 1 and has_neg_prompt + ( + prompt_embeds, + pooled_prompt_embeds, + text_ids, + ) = self.encode_prompt( + prompt=prompt, + prompt_2=prompt_2, + prompt_embeds=prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + device=device, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + lora_scale=lora_scale, + ) + if do_true_cfg: + ( + negative_prompt_embeds, + negative_pooled_prompt_embeds, + _, + ) = self.encode_prompt( + prompt=negative_prompt, + prompt_2=negative_prompt_2, + prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=negative_pooled_prompt_embeds, + device=device, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + lora_scale=lora_scale, + ) + + # Embed concepts + concept_embeddings, pooled_concept_embeds, concept_ids = self.encode_concepts( + concept_attention_kwargs["concepts"], + device=device + ) + # Add the concept embeddings to the concept_attention_kwargs + # if concept_attention_kwargs is not None: + # concept_attention_kwargs["concept_embeddings"] = concept_embeddings + # concept_attention_kwargs["concept_vec"] = concept_vec + + # 4. Prepare latent variables + num_channels_latents = self.transformer.config.in_channels // 4 + latents, latent_image_ids = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 5. Prepare timesteps + sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas + image_seq_len = latents.shape[1] + mu = calculate_shift( + image_seq_len, + self.scheduler.config.get("base_image_seq_len", 256), + self.scheduler.config.get("max_image_seq_len", 4096), + self.scheduler.config.get("base_shift", 0.5), + self.scheduler.config.get("max_shift", 1.16), + ) + timesteps, num_inference_steps = retrieve_timesteps( + self.scheduler, + num_inference_steps, + device, + sigmas=sigmas, + mu=mu, + ) + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) + + # handle guidance + if self.transformer.config.guidance_embeds: + guidance = torch.full([1], guidance_scale, device=device, dtype=torch.float32) + guidance = guidance.expand(latents.shape[0]) + else: + guidance = None + + if (ip_adapter_image is not None or ip_adapter_image_embeds is not None) and ( + negative_ip_adapter_image is None and negative_ip_adapter_image_embeds is None + ): + negative_ip_adapter_image = np.zeros((width, height, 3), dtype=np.uint8) + elif (ip_adapter_image is None and ip_adapter_image_embeds is None) and ( + negative_ip_adapter_image is not None or negative_ip_adapter_image_embeds is not None + ): + ip_adapter_image = np.zeros((width, height, 3), dtype=np.uint8) + + if self.joint_attention_kwargs is None: + self._joint_attention_kwargs = {} + + image_embeds = None + negative_image_embeds = None + if ip_adapter_image is not None or ip_adapter_image_embeds is not None: + image_embeds = self.prepare_ip_adapter_image_embeds( + ip_adapter_image, + ip_adapter_image_embeds, + device, + batch_size * num_images_per_prompt, + ) + if negative_ip_adapter_image is not None or negative_ip_adapter_image_embeds is not None: + negative_image_embeds = self.prepare_ip_adapter_image_embeds( + negative_ip_adapter_image, + negative_ip_adapter_image_embeds, + device, + batch_size * num_images_per_prompt, + ) + + # Make concept attention maps + all_concept_attention_maps = [] + + # 6. Denoising loop + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + if self.interrupt: + continue + + self._current_timestep = t + if image_embeds is not None: + self._joint_attention_kwargs["ip_adapter_image_embeds"] = image_embeds + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latents.shape[0]).to(latents.dtype) + + # Don't do concept attention if the timestep is not in the concept_attention_kwargs + if concept_attention_kwargs is not None and not i in concept_attention_kwargs["timesteps"]: + current_concept_embeddings = None + else: + current_concept_embeddings = concept_embeddings + + transformer_output = self.transformer( + hidden_states=latents, + timestep=timestep / 1000, + guidance=guidance, + pooled_projections=pooled_prompt_embeds, + pooled_concept_embeds=pooled_concept_embeds, + encoder_hidden_states=prompt_embeds, + concept_hidden_states=current_concept_embeddings, + txt_ids=text_ids, + img_ids=latent_image_ids, + concept_ids=concept_ids, + joint_attention_kwargs=self.joint_attention_kwargs, + concept_attention_kwargs=concept_attention_kwargs, + return_dict=False, + ) + noise_pred, concept_attention_maps = transformer_output + if i in concept_attention_kwargs["timesteps"]: + all_concept_attention_maps.append(concept_attention_maps) + + if do_true_cfg: + if negative_image_embeds is not None: + self._joint_attention_kwargs["ip_adapter_image_embeds"] = negative_image_embeds + neg_noise_pred = self.transformer( + hidden_states=latents, + timestep=timestep / 1000, + guidance=guidance, + pooled_projections=negative_pooled_prompt_embeds, + encoder_hidden_states=negative_prompt_embeds, + txt_ids=text_ids, + img_ids=latent_image_ids, + joint_attention_kwargs=self.joint_attention_kwargs, + return_dict=False, + )[0] + noise_pred = neg_noise_pred + true_cfg_scale * (noise_pred - neg_noise_pred) + + # compute the previous noisy sample x_t -> x_t-1 + latents_dtype = latents.dtype + latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0] + + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + + if XLA_AVAILABLE: + xm.mark_step() + + self._current_timestep = None + + if output_type == "latent": + image = latents + else: + latents = self._unpack_latents(latents, height, width, self.vae_scale_factor) + latents = (latents / self.vae.config.scaling_factor) + self.vae.config.shift_factor + image = self.vae.decode(latents, return_dict=False)[0] + image = image.detach() + image = self.image_processor.postprocess(image, output_type=output_type) + + ################### Process the concept attention maps ################### + concept_attention_maps = torch.stack(all_concept_attention_maps).to(torch.float32) + # Apply a softmax over the concept dimension + concept_attention_maps = torch.softmax(concept_attention_maps, dim=-1) + concept_attention_maps = concept_attention_maps.detach().cpu().numpy() + # Average over time and layers + concept_attention_maps = einops.reduce( + concept_attention_maps, + "time layers batch concepts patches -> batch concepts patches", + reduction="mean" + ) + # Reshape to image size + concept_attention_maps = einops.rearrange( + concept_attention_maps, + "batch concepts (h w) -> batch concepts h w", + h=height // 16, + w=width // 16 + ) + if not output_type == "latent": + concept_attention_maps = (concept_attention_maps - concept_attention_maps.min()) / (concept_attention_maps.max() - concept_attention_maps.min()) + # Convert to cmap + convert_to_plasma = lambda x: np.uint8(plt.get_cmap("plasma")(x)[:, :, :3] * 255) + concept_attention_maps = [ + [ + PIL.Image.fromarray( + convert_to_plasma(concept_attention_map) + ) + for concept_attention_map in concept_attention_maps[batch_index] + ] + for batch_index in range(concept_attention_maps.shape[0]) + ] + ########################################################################### + + # Offload all models + self.maybe_free_model_hooks() + + if not return_dict: + return (image, concept_attention_maps) + + return FluxConceptAttentionOutput( + images=image, + concept_attention_maps=concept_attention_maps, + ) \ No newline at end of file diff --git a/concept_attention/diffusers_concept_attention/__init__.py b/concept_attention/diffusers_concept_attention/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/diffusers_concept_attention/concept_attention_dit.py b/concept_attention/diffusers_concept_attention/concept_attention_dit.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/diffusers_concept_attention/concept_attention_double_stream_block.py b/concept_attention/diffusers_concept_attention/concept_attention_double_stream_block.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/concept_attention/diffusers_concept_attention/concept_attention_flux_pipeline.py b/concept_attention/diffusers_concept_attention/concept_attention_flux_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..503f5b4ea9ea2da563424805f223b7772d83a377 --- /dev/null +++ b/concept_attention/diffusers_concept_attention/concept_attention_flux_pipeline.py @@ -0,0 +1,629 @@ +from typing import Any, Callable, Dict, List, Optional, Union + +import numpy as np +import torch +from transformers import ( + CLIPImageProcessor, + CLIPTextModel, + CLIPTokenizer, + CLIPVisionModelWithProjection, + T5EncoderModel, + T5TokenizerFast, +) + +from diffusers.utils import logging, scale_lora_layers, \ + unscale_lora_layers +from diffusers.utils.torch_utils import randn_tensor, USE_PEFT_BACKEND +from diffusers import FluxPipeline + +from diffusers.schedulers import FlowMatchEulerDiscreteScheduler +from diffusers.image_processor import PipelineImageInput, VaeImageProcessor +from diffusers.loaders import FluxIPAdapterMixin, FluxLoraLoaderMixin, FromSingleFileMixin, TextualInversionLoaderMixin +from diffusers.models import AutoencoderKL, FluxTransformer2DModel + +from diffusers.pipelines.flux.pipeline_flux import calculate_shift, retrieve_timesteps + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +XLA_AVAILABLE = False + +class ConceptAttentionFluxPipeline(FluxPipeline): + r""" + The Flux pipeline for text-to-image generation. + + Reference: https://blackforestlabs.ai/announcing-black-forest-labs/ + + Args: + transformer ([`FluxTransformer2DModel`]): + Conditional Transformer (MMDiT) architecture to denoise the encoded image latents. + scheduler ([`FlowMatchEulerDiscreteScheduler`]): + A scheduler to be used in combination with `transformer` to denoise the encoded image latents. + vae ([`AutoencoderKL`]): + Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. + text_encoder ([`CLIPTextModel`]): + [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically + the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant. + text_encoder_2 ([`T5EncoderModel`]): + [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically + the [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) variant. + tokenizer (`CLIPTokenizer`): + Tokenizer of class + [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer). + tokenizer_2 (`T5TokenizerFast`): + Second Tokenizer of class + [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast). + """ + + model_cpu_offload_seq = "text_encoder->text_encoder_2->image_encoder->transformer->vae" + _optional_components = ["image_encoder", "feature_extractor"] + _callback_tensor_inputs = ["latents", "prompt_embeds"] + + def __init__( + self, + scheduler: FlowMatchEulerDiscreteScheduler, + vae: AutoencoderKL, + text_encoder: CLIPTextModel, + tokenizer: CLIPTokenizer, + text_encoder_2: T5EncoderModel, + tokenizer_2: T5TokenizerFast, + transformer: FluxTransformer2DModel, + image_encoder: CLIPVisionModelWithProjection = None, + feature_extractor: CLIPImageProcessor = None, + ): + super().__init__() + + self.register_modules( + vae=vae, + text_encoder=text_encoder, + text_encoder_2=text_encoder_2, + tokenizer=tokenizer, + tokenizer_2=tokenizer_2, + transformer=transformer, + scheduler=scheduler, + image_encoder=image_encoder, + feature_extractor=feature_extractor, + ) + self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) if getattr(self, "vae", None) else 8 + # Flux latents are turned into 2x2 patches and packed. This means the latent width and height has to be divisible + # by the patch size. So the vae scale factor is multiplied by the patch size to account for this + self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor * 2) + self.tokenizer_max_length = ( + self.tokenizer.model_max_length if hasattr(self, "tokenizer") and self.tokenizer is not None else 77 + ) + self.default_sample_size = 128 + + def _get_t5_prompt_embeds( + self, + prompt: Union[str, List[str]] = None, + num_images_per_prompt: int = 1, + max_sequence_length: int = 512, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + ): + device = device or self._execution_device + dtype = dtype or self.text_encoder.dtype + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + if isinstance(self, TextualInversionLoaderMixin): + prompt = self.maybe_convert_prompt(prompt, self.tokenizer_2) + + text_inputs = self.tokenizer_2( + prompt, + padding="max_length", + max_length=max_sequence_length, + truncation=True, + return_length=False, + return_overflowing_tokens=False, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer_2(prompt, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = self.tokenizer_2.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because `max_sequence_length` is set to " + f" {max_sequence_length} tokens: {removed_text}" + ) + + prompt_embeds = self.text_encoder_2(text_input_ids.to(device), output_hidden_states=False)[0] + + dtype = self.text_encoder_2.dtype + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + _, seq_len, _ = prompt_embeds.shape + + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + return prompt_embeds + + def _get_clip_prompt_embeds( + self, + prompt: Union[str, List[str]], + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + ): + device = device or self._execution_device + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + if isinstance(self, TextualInversionLoaderMixin): + prompt = self.maybe_convert_prompt(prompt, self.tokenizer) + + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=self.tokenizer_max_length, + truncation=True, + return_overflowing_tokens=False, + return_length=False, + return_tensors="pt", + ) + + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because CLIP can only handle sequences up to" + f" {self.tokenizer_max_length} tokens: {removed_text}" + ) + prompt_embeds = self.text_encoder(text_input_ids.to(device), output_hidden_states=False) + + # Use pooled output of CLIPTextModel + prompt_embeds = prompt_embeds.pooler_output + prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device) + + # duplicate text embeddings for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, -1) + + return prompt_embeds + + def encode_prompt( + self, + prompt: Union[str, List[str]], + prompt_2: Union[str, List[str]], + device: Optional[torch.device] = None, + num_images_per_prompt: int = 1, + prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + max_sequence_length: int = 512, + lora_scale: Optional[float] = None, + ): + r""" + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + used in all text-encoders + device: (`torch.device`): + torch device + num_images_per_prompt (`int`): + number of images that should be generated per prompt + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + lora_scale (`float`, *optional*): + A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded. + """ + device = device or self._execution_device + + # set lora scale so that monkey patched LoRA + # function of text encoder can correctly access it + if lora_scale is not None and isinstance(self, FluxLoraLoaderMixin): + self._lora_scale = lora_scale + + # dynamically adjust the LoRA scale + if self.text_encoder is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder, lora_scale) + if self.text_encoder_2 is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder_2, lora_scale) + + prompt = [prompt] if isinstance(prompt, str) else prompt + + if prompt_embeds is None: + prompt_2 = prompt_2 or prompt + prompt_2 = [prompt_2] if isinstance(prompt_2, str) else prompt_2 + + # We only use the pooled prompt output from the CLIPTextModel + pooled_prompt_embeds = self._get_clip_prompt_embeds( + prompt=prompt, + device=device, + num_images_per_prompt=num_images_per_prompt, + ) + prompt_embeds = self._get_t5_prompt_embeds( + prompt=prompt_2, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + device=device, + ) + + if self.text_encoder is not None: + if isinstance(self, FluxLoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder, lora_scale) + + if self.text_encoder_2 is not None: + if isinstance(self, FluxLoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder_2, lora_scale) + + dtype = self.text_encoder.dtype if self.text_encoder is not None else self.transformer.dtype + text_ids = torch.zeros(prompt_embeds.shape[1], 3).to(device=device, dtype=dtype) + + return prompt_embeds, pooled_prompt_embeds, text_ids + + def encode_image(self, image, device, num_images_per_prompt): + dtype = next(self.image_encoder.parameters()).dtype + + if not isinstance(image, torch.Tensor): + image = self.feature_extractor(image, return_tensors="pt").pixel_values + + image = image.to(device=device, dtype=dtype) + image_embeds = self.image_encoder(image).image_embeds + image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0) + return image_embeds + + @torch.no_grad() + def __call__( + self, + prompt: Union[str, List[str]] = None, + prompt_2: Optional[Union[str, List[str]]] = None, + negative_prompt: Union[str, List[str]] = None, + negative_prompt_2: Optional[Union[str, List[str]]] = None, + true_cfg_scale: float = 1.0, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 28, + sigmas: Optional[List[float]] = None, + guidance_scale: float = 3.5, + num_images_per_prompt: Optional[int] = 1, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + ip_adapter_image: Optional[PipelineImageInput] = None, + ip_adapter_image_embeds: Optional[List[torch.Tensor]] = None, + negative_ip_adapter_image: Optional[PipelineImageInput] = None, + negative_ip_adapter_image_embeds: Optional[List[torch.Tensor]] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], + max_sequence_length: int = 512, + ): + r""" + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + will be used instead. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `true_cfg_scale` is + not greater than `1`). + negative_prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and + `text_encoder_2`. If not defined, `negative_prompt` is used in all the text-encoders. + true_cfg_scale (`float`, *optional*, defaults to 1.0): + When > 1.0 and a provided `negative_prompt`, enables true classifier-free guidance. + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. This is set to 1024 by default for the best results. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. This is set to 1024 by default for the best results. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + sigmas (`List[float]`, *optional*): + Custom sigmas to use for the denoising process with schedulers which support a `sigmas` argument in + their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is passed + will be used. + guidance_scale (`float`, *optional*, defaults to 7.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + ip_adapter_image: (`PipelineImageInput`, *optional*): Optional image input to work with IP Adapters. + ip_adapter_image_embeds (`List[torch.Tensor]`, *optional*): + Pre-generated image embeddings for IP-Adapter. It should be a list of length same as number of + IP-adapters. Each element should be a tensor of shape `(batch_size, num_images, emb_dim)`. If not + provided, embeddings are computed from the `ip_adapter_image` input argument. + negative_ip_adapter_image: + (`PipelineImageInput`, *optional*): Optional image input to work with IP Adapters. + negative_ip_adapter_image_embeds (`List[torch.Tensor]`, *optional*): + Pre-generated image embeddings for IP-Adapter. It should be a list of length same as number of + IP-adapters. Each element should be a tensor of shape `(batch_size, num_images, emb_dim)`. If not + provided, embeddings are computed from the `ip_adapter_image` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` + input argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.flux.FluxPipelineOutput`] instead of a plain tuple. + joint_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`List`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. + max_sequence_length (`int` defaults to 512): Maximum sequence length to use with the `prompt`. + + Examples: + + Returns: + [`~pipelines.flux.FluxPipelineOutput`] or `tuple`: [`~pipelines.flux.FluxPipelineOutput`] if `return_dict` + is True, otherwise a `tuple`. When returning a tuple, the first element is a list with the generated + images. + """ + + height = height or self.default_sample_size * self.vae_scale_factor + width = width or self.default_sample_size * self.vae_scale_factor + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + prompt_2, + height, + width, + negative_prompt=negative_prompt, + negative_prompt_2=negative_prompt_2, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + max_sequence_length=max_sequence_length, + ) + + self._guidance_scale = guidance_scale + self._joint_attention_kwargs = joint_attention_kwargs + self._current_timestep = None + self._interrupt = False + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + lora_scale = ( + self.joint_attention_kwargs.get("scale", None) if self.joint_attention_kwargs is not None else None + ) + has_neg_prompt = negative_prompt is not None or ( + negative_prompt_embeds is not None and negative_pooled_prompt_embeds is not None + ) + do_true_cfg = true_cfg_scale > 1 and has_neg_prompt + ( + prompt_embeds, + pooled_prompt_embeds, + text_ids, + ) = self.encode_prompt( + prompt=prompt, + prompt_2=prompt_2, + prompt_embeds=prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + device=device, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + lora_scale=lora_scale, + ) + if do_true_cfg: + ( + negative_prompt_embeds, + negative_pooled_prompt_embeds, + _, + ) = self.encode_prompt( + prompt=negative_prompt, + prompt_2=negative_prompt_2, + prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=negative_pooled_prompt_embeds, + device=device, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + lora_scale=lora_scale, + ) + + # 4. Prepare latent variables + num_channels_latents = self.transformer.config.in_channels // 4 + latents, latent_image_ids = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 5. Prepare timesteps + sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas + image_seq_len = latents.shape[1] + mu = calculate_shift( + image_seq_len, + self.scheduler.config.get("base_image_seq_len", 256), + self.scheduler.config.get("max_image_seq_len", 4096), + self.scheduler.config.get("base_shift", 0.5), + self.scheduler.config.get("max_shift", 1.16), + ) + timesteps, num_inference_steps = retrieve_timesteps( + self.scheduler, + num_inference_steps, + device, + sigmas=sigmas, + mu=mu, + ) + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) + + # handle guidance + if self.transformer.config.guidance_embeds: + guidance = torch.full([1], guidance_scale, device=device, dtype=torch.float32) + guidance = guidance.expand(latents.shape[0]) + else: + guidance = None + + if (ip_adapter_image is not None or ip_adapter_image_embeds is not None) and ( + negative_ip_adapter_image is None and negative_ip_adapter_image_embeds is None + ): + negative_ip_adapter_image = np.zeros((width, height, 3), dtype=np.uint8) + elif (ip_adapter_image is None and ip_adapter_image_embeds is None) and ( + negative_ip_adapter_image is not None or negative_ip_adapter_image_embeds is not None + ): + ip_adapter_image = np.zeros((width, height, 3), dtype=np.uint8) + + if self.joint_attention_kwargs is None: + self._joint_attention_kwargs = {} + + image_embeds = None + negative_image_embeds = None + if ip_adapter_image is not None or ip_adapter_image_embeds is not None: + image_embeds = self.prepare_ip_adapter_image_embeds( + ip_adapter_image, + ip_adapter_image_embeds, + device, + batch_size * num_images_per_prompt, + ) + if negative_ip_adapter_image is not None or negative_ip_adapter_image_embeds is not None: + negative_image_embeds = self.prepare_ip_adapter_image_embeds( + negative_ip_adapter_image, + negative_ip_adapter_image_embeds, + device, + batch_size * num_images_per_prompt, + ) + + # 6. Denoising loop + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + if self.interrupt: + continue + + self._current_timestep = t + if image_embeds is not None: + self._joint_attention_kwargs["ip_adapter_image_embeds"] = image_embeds + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latents.shape[0]).to(latents.dtype) + + noise_pred = self.transformer( + hidden_states=latents, + timestep=timestep / 1000, + guidance=guidance, + pooled_projections=pooled_prompt_embeds, + encoder_hidden_states=prompt_embeds, + txt_ids=text_ids, + img_ids=latent_image_ids, + joint_attention_kwargs=self.joint_attention_kwargs, + return_dict=False, + )[0] + + if do_true_cfg: + if negative_image_embeds is not None: + self._joint_attention_kwargs["ip_adapter_image_embeds"] = negative_image_embeds + neg_noise_pred = self.transformer( + hidden_states=latents, + timestep=timestep / 1000, + guidance=guidance, + pooled_projections=negative_pooled_prompt_embeds, + encoder_hidden_states=negative_prompt_embeds, + txt_ids=text_ids, + img_ids=latent_image_ids, + joint_attention_kwargs=self.joint_attention_kwargs, + return_dict=False, + )[0] + noise_pred = neg_noise_pred + true_cfg_scale * (noise_pred - neg_noise_pred) + + # compute the previous noisy sample x_t -> x_t-1 + latents_dtype = latents.dtype + latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0] + + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + + if XLA_AVAILABLE: + raise Exception("XLA Not supported") + xm.mark_step() + + self._current_timestep = None + + if output_type == "latent": + image = latents + else: + latents = self._unpack_latents(latents, height, width, self.vae_scale_factor) + latents = (latents / self.vae.config.scaling_factor) + self.vae.config.shift_factor + image = self.vae.decode(latents, return_dict=False)[0] + image = self.image_processor.postprocess(image, output_type=output_type) + + # Offload all models + self.maybe_free_model_hooks() + + if not return_dict: + return (image,) + + return FluxPipelineOutput(images=image) \ No newline at end of file diff --git a/concept_attention/flux/LICENSE b/concept_attention/flux/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/concept_attention/flux/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/concept_attention/flux/README.md b/concept_attention/flux/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a04b669defcd3c21e43d8158dfa55f37aa1d4960 --- /dev/null +++ b/concept_attention/flux/README.md @@ -0,0 +1,194 @@ +# FLUX +by Black Forest Labs: https://blackforestlabs.ai. Documentation for our API can be found here: [docs.bfl.ml](https://docs.bfl.ml/). + +![grid](assets/grid.jpg) + +This repo contains minimal inference code to run text-to-image and image-to-image with our Flux latent rectified flow transformers. + +### Inference partners + +We are happy to partner with [Replicate](https://replicate.com/), [FAL](https://fal.ai/), [Mystic](https://www.mystic.ai), and [Together](https://www.together.ai/). You can sample our models using their services. +Below we list relevant links. + +Replicate: + +- https://replicate.com/collections/flux +- https://replicate.com/collections/flux-fine-tunes +- https://replicate.com/black-forest-labs/flux-pro +- https://replicate.com/black-forest-labs/flux-dev +- https://replicate.com/black-forest-labs/flux-schnell + +FAL: + +- https://fal.ai/models/fal-ai/flux-pro +- https://fal.ai/models/fal-ai/flux/dev +- https://fal.ai/models/fal-ai/flux/schnell + +Mystic: + +- https://www.mystic.ai/black-forest-labs +- https://www.mystic.ai/black-forest-labs/flux1-pro +- https://www.mystic.ai/black-forest-labs/flux1-dev +- https://www.mystic.ai/black-forest-labs/flux1-schnell + +Together: +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-schnell-Free (ends December 31, 2024) +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-schnell +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1.1-pro +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-pro + +## Local installation + +```bash +cd $HOME && git clone https://github.com/black-forest-labs/flux +cd $HOME/flux +python3.10 -m venv .venv +source .venv/bin/activate +pip install -e ".[all]" +``` + +### Models + +We are offering three models: + +- `FLUX1.1 [pro]` available via API only +- `FLUX.1 [pro]` available via API only +- `FLUX.1 [dev]` guidance-distilled variant +- `FLUX.1 [schnell]` guidance and step-distilled variant + +| Name | HuggingFace repo | License | md5sum | +| ------------------ | ------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------- | +| `FLUX.1 [schnell]` | https://huggingface.co/black-forest-labs/FLUX.1-schnell | [apache-2.0](model_licenses/LICENSE-FLUX1-schnell) | a9e1e277b9b16add186f38e3f5a34044 | +| `FLUX.1 [dev]` | https://huggingface.co/black-forest-labs/FLUX.1-dev | [FLUX.1-dev Non-Commercial License](model_licenses/LICENSE-FLUX1-dev) | a6bd8c16dfc23db6aee2f63a2eba78c0 | +| `FLUX.1 [pro]` | Only available in our API. | +| `FLUX1.1 [pro]` | Only available in our API. | + +The weights of the autoencoder are also released under [apache-2.0](https://huggingface.co/datasets/choosealicense/licenses/blob/main/markdown/apache-2.0.md) and can be found in either of the two HuggingFace repos above. They are the same for both models. + +## Usage + +The weights will be downloaded automatically from HuggingFace once you start one of the demos. To download `FLUX.1 [dev]`, you will need to be logged in, see [here](https://huggingface.co/docs/huggingface_hub/guides/cli#huggingface-cli-login). +If you have downloaded the model weights manually, you can specify the downloaded paths via environment-variables: + +```bash +export FLUX_SCHNELL= +export FLUX_DEV= +export AE= +``` + +For interactive sampling run + +```bash +python -m flux --name --loop +``` + +Or to generate a single sample run + +```bash +python -m flux --name \ + --height --width \ + --prompt "" +``` + +We also provide a streamlit demo that does both text-to-image and image-to-image. The demo can be run via + +```bash +streamlit run demo_st.py +``` + +We also offer a Gradio-based demo for an interactive experience. To run the Gradio demo: + +```bash +python demo_gr.py --name flux-schnell --device cuda +``` + +Options: + +- `--name`: Choose the model to use (options: "flux-schnell", "flux-dev") +- `--device`: Specify the device to use (default: "cuda" if available, otherwise "cpu") +- `--offload`: Offload model to CPU when not in use +- `--share`: Create a public link to your demo + +To run the demo with the dev model and create a public link: + +```bash +python demo_gr.py --name flux-dev --share +``` + +## Diffusers integration + +`FLUX.1 [schnell]` and `FLUX.1 [dev]` are integrated with the [🧨 diffusers](https://github.com/huggingface/diffusers) library. To use it with diffusers, install it: + +```shell +pip install git+https://github.com/huggingface/diffusers.git +``` + +Then you can use `FluxPipeline` to run the model + +```python +import torch +from diffusers import FluxPipeline + +model_id = "black-forest-labs/FLUX.1-schnell" #you can also use `black-forest-labs/FLUX.1-dev` + +pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16) +pipe.enable_model_cpu_offload() #save some VRAM by offloading the model to CPU. Remove this if you have enough GPU power + +prompt = "A cat holding a sign that says hello world" +seed = 42 +image = pipe( + prompt, + output_type="pil", + num_inference_steps=4, #use a larger number if you are using [dev] + generator=torch.Generator("cpu").manual_seed(seed) +).images[0] +image.save("flux-schnell.png") +``` + +To learn more check out the [diffusers](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) documentation + +## API usage + +Our API offers access to our models. It is documented here: +[docs.bfl.ml](https://docs.bfl.ml/). + +In this repository we also offer an easy python interface. To use this, you +first need to register with the API on [api.bfl.ml](https://api.bfl.ml/), and +create a new API key. + +To use the API key either run `export BFL_API_KEY=` or provide +it via the `api_key=` parameter. It is also expected that you +have installed the package as above. + +Usage from python: + +```python +from concept_attention.flux.src.flux.api import ImageRequest + +# this will create an api request directly but not block until the generation is finished +request = ImageRequest("A beautiful beach", name="flux.1.1-pro") +# or: request = ImageRequest("A beautiful beach", name="flux.1.1-pro", api_key="your_key_here") + +# any of the following will block until the generation is finished +request.url +# -> https:<...>/sample.jpg +request.bytes +# -> b"..." bytes for the generated image +request.save("outputs/api.jpg") +# saves the sample to local storage +request.image +# -> a PIL image +``` + +Usage from the command line: + +```bash +$ python -m flux.api --prompt="A beautiful beach" url +https:<...>/sample.jpg + +# generate and save the result +$ python -m flux.api --prompt="A beautiful beach" save outputs/api + +# open the image directly +$ python -m flux.api --prompt="A beautiful beach" image show +``` diff --git a/concept_attention/flux/demo_gr.py b/concept_attention/flux/demo_gr.py new file mode 100644 index 0000000000000000000000000000000000000000..9fd23a649efb6b4cc9cf6497b63cbb42668336cc --- /dev/null +++ b/concept_attention/flux/demo_gr.py @@ -0,0 +1,217 @@ +import os +import time +import uuid + +import torch +import gradio as gr +import numpy as np +from einops import rearrange +from PIL import Image, ExifTags +from transformers import pipeline + +from concept_attention.flux.src.flux.cli import SamplingOptions +from concept_attention.flux.src.flux.sampling import denoise, get_noise, get_schedule, prepare, unpack +from concept_attention.flux.src.flux.util import configs, embed_watermark, load_ae, load_clip, load_flow_model, load_t5 + +NSFW_THRESHOLD = 0.85 + +def get_models(name: str, device: torch.device, offload: bool, is_schnell: bool): + t5 = load_t5(device, max_length=256 if is_schnell else 512) + clip = load_clip(device) + model = load_flow_model(name, device="cpu" if offload else device) + ae = load_ae(name, device="cpu" if offload else device) + nsfw_classifier = pipeline("image-classification", model="Falconsai/nsfw_image_detection", device=device) + return model, ae, t5, clip, nsfw_classifier + +class FluxGenerator: + def __init__(self, model_name: str, device: str, offload: bool): + self.device = torch.device(device) + self.offload = offload + self.model_name = model_name + self.is_schnell = model_name == "flux-schnell" + self.model, self.ae, self.t5, self.clip, self.nsfw_classifier = get_models( + model_name, + device=self.device, + offload=self.offload, + is_schnell=self.is_schnell, + ) + + @torch.inference_mode() + def generate_image( + self, + width, + height, + num_steps, + guidance, + seed, + prompt, + init_image=None, + image2image_strength=0.0, + add_sampling_metadata=True, + ): + seed = int(seed) + if seed == -1: + seed = None + + opts = SamplingOptions( + prompt=prompt, + width=width, + height=height, + num_steps=num_steps, + guidance=guidance, + seed=seed, + ) + + if opts.seed is None: + opts.seed = torch.Generator(device="cpu").seed() + print(f"Generating '{opts.prompt}' with seed {opts.seed}") + t0 = time.perf_counter() + + if init_image is not None: + if isinstance(init_image, np.ndarray): + init_image = torch.from_numpy(init_image).permute(2, 0, 1).float() / 255.0 + init_image = init_image.unsqueeze(0) + init_image = init_image.to(self.device) + init_image = torch.nn.functional.interpolate(init_image, (opts.height, opts.width)) + if self.offload: + self.ae.encoder.to(self.device) + init_image = self.ae.encode(init_image.to()) + if self.offload: + self.ae = self.ae.cpu() + torch.cuda.empty_cache() + + # prepare input + x = get_noise( + 1, + opts.height, + opts.width, + device=self.device, + dtype=torch.bfloat16, + seed=opts.seed, + ) + timesteps = get_schedule( + opts.num_steps, + x.shape[-1] * x.shape[-2] // 4, + shift=(not self.is_schnell), + ) + if init_image is not None: + t_idx = int((1 - image2image_strength) * num_steps) + t = timesteps[t_idx] + timesteps = timesteps[t_idx:] + x = t * x + (1.0 - t) * init_image.to(x.dtype) + + if self.offload: + self.t5, self.clip = self.t5.to(self.device), self.clip.to(self.device) + inp = prepare(t5=self.t5, clip=self.clip, img=x, prompt=opts.prompt) + + # offload TEs to CPU, load model to gpu + if self.offload: + self.t5, self.clip = self.t5.cpu(), self.clip.cpu() + torch.cuda.empty_cache() + self.model = self.model.to(self.device) + + # denoise initial noise + x = denoise(self.model, **inp, timesteps=timesteps, guidance=opts.guidance) + + # offload model, load autoencoder to gpu + if self.offload: + self.model.cpu() + torch.cuda.empty_cache() + self.ae.decoder.to(x.device) + + # decode latents to pixel space + x = unpack(x.float(), opts.height, opts.width) + with torch.autocast(device_type=self.device.type, dtype=torch.bfloat16): + x = self.ae.decode(x) + + if self.offload: + self.ae.decoder.cpu() + torch.cuda.empty_cache() + + t1 = time.perf_counter() + + print(f"Done in {t1 - t0:.1f}s.") + # bring into PIL format + x = x.clamp(-1, 1) + x = embed_watermark(x.float()) + x = rearrange(x[0], "c h w -> h w c") + + img = Image.fromarray((127.5 * (x + 1.0)).cpu().byte().numpy()) + nsfw_score = [x["score"] for x in self.nsfw_classifier(img) if x["label"] == "nsfw"][0] + + if nsfw_score < NSFW_THRESHOLD: + filename = f"output/gradio/{uuid.uuid4()}.jpg" + os.makedirs(os.path.dirname(filename), exist_ok=True) + exif_data = Image.Exif() + if init_image is None: + exif_data[ExifTags.Base.Software] = "AI generated;txt2img;flux" + else: + exif_data[ExifTags.Base.Software] = "AI generated;img2img;flux" + exif_data[ExifTags.Base.Make] = "Black Forest Labs" + exif_data[ExifTags.Base.Model] = self.model_name + if add_sampling_metadata: + exif_data[ExifTags.Base.ImageDescription] = prompt + + img.save(filename, format="jpeg", exif=exif_data, quality=95, subsampling=0) + + return img, str(opts.seed), filename, None + else: + return None, str(opts.seed), None, "Your generated image may contain NSFW content." + +def create_demo(model_name: str, device: str = "cuda" if torch.cuda.is_available() else "cpu", offload: bool = False): + generator = FluxGenerator(model_name, device, offload) + is_schnell = model_name == "flux-schnell" + + with gr.Blocks() as demo: + gr.Markdown(f"# Flux Image Generation Demo - Model: {model_name}") + + with gr.Row(): + with gr.Column(): + prompt = gr.Textbox(label="Prompt", value="a photo of a forest with mist swirling around the tree trunks. The word \"FLUX\" is painted over it in big, red brush strokes with visible texture") + do_img2img = gr.Checkbox(label="Image to Image", value=False, interactive=not is_schnell) + init_image = gr.Image(label="Input Image", visible=False) + image2image_strength = gr.Slider(0.0, 1.0, 0.8, step=0.1, label="Noising strength", visible=False) + + with gr.Accordion("Advanced Options", open=False): + width = gr.Slider(128, 8192, 1360, step=16, label="Width") + height = gr.Slider(128, 8192, 768, step=16, label="Height") + num_steps = gr.Slider(1, 50, 4 if is_schnell else 50, step=1, label="Number of steps") + guidance = gr.Slider(1.0, 10.0, 3.5, step=0.1, label="Guidance", interactive=not is_schnell) + seed = gr.Textbox(-1, label="Seed (-1 for random)") + add_sampling_metadata = gr.Checkbox(label="Add sampling parameters to metadata?", value=True) + + generate_btn = gr.Button("Generate") + + with gr.Column(): + output_image = gr.Image(label="Generated Image") + seed_output = gr.Number(label="Used Seed") + warning_text = gr.Textbox(label="Warning", visible=False) + download_btn = gr.File(label="Download full-resolution") + + def update_img2img(do_img2img): + return { + init_image: gr.update(visible=do_img2img), + image2image_strength: gr.update(visible=do_img2img), + } + + do_img2img.change(update_img2img, do_img2img, [init_image, image2image_strength]) + + generate_btn.click( + fn=generator.generate_image, + inputs=[width, height, num_steps, guidance, seed, prompt, init_image, image2image_strength, add_sampling_metadata], + outputs=[output_image, seed_output, download_btn, warning_text], + ) + + return demo + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description="Flux") + parser.add_argument("--name", type=str, default="flux-schnell", choices=list(configs.keys()), help="Model name") + parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device to use") + parser.add_argument("--offload", action="store_true", help="Offload model to CPU when not in use") + parser.add_argument("--share", action="store_true", help="Create a public link to your demo") + args = parser.parse_args() + + demo = create_demo(args.name, args.device, args.offload) + demo.launch(share=args.share) diff --git a/concept_attention/flux/demo_st.py b/concept_attention/flux/demo_st.py new file mode 100644 index 0000000000000000000000000000000000000000..350ee6a97d9c07a9f820244fe65b4ae2283e4d4d --- /dev/null +++ b/concept_attention/flux/demo_st.py @@ -0,0 +1,293 @@ +import os +import re +import time +from glob import iglob +from io import BytesIO + +import streamlit as st +import torch +from einops import rearrange +from fire import Fire +from PIL import ExifTags, Image +from st_keyup import st_keyup +from torchvision import transforms +from transformers import pipeline + +from concept_attention.flux.src.flux.cli import SamplingOptions +from concept_attention.flux.src.flux.sampling import denoise, get_noise, get_schedule, prepare, unpack +from concept_attention.flux.src.flux.util import ( + configs, + embed_watermark, + load_ae, + load_clip, + load_flow_model, + load_t5, +) + +NSFW_THRESHOLD = 0.85 + + +@st.cache_resource() +def get_models(name: str, device: torch.device, offload: bool, is_schnell: bool): + t5 = load_t5(device, max_length=256 if is_schnell else 512) + clip = load_clip(device) + model = load_flow_model(name, device="cpu" if offload else device) + ae = load_ae(name, device="cpu" if offload else device) + nsfw_classifier = pipeline("image-classification", model="Falconsai/nsfw_image_detection", device=device) + return model, ae, t5, clip, nsfw_classifier + + +def get_image() -> torch.Tensor | None: + image = st.file_uploader("Input", type=["jpg", "JPEG", "png"]) + if image is None: + return None + image = Image.open(image).convert("RGB") + + transform = transforms.Compose( + [ + transforms.ToTensor(), + transforms.Lambda(lambda x: 2.0 * x - 1.0), + ] + ) + img: torch.Tensor = transform(image) + return img[None, ...] + + +@torch.inference_mode() +def main( + device: str = "cuda" if torch.cuda.is_available() else "cpu", + offload: bool = False, + output_dir: str = "output", +): + torch_device = torch.device(device) + names = list(configs.keys()) + name = st.selectbox("Which model to load?", names) + if name is None or not st.checkbox("Load model", False): + return + + is_schnell = name == "flux-schnell" + model, ae, t5, clip, nsfw_classifier = get_models( + name, + device=torch_device, + offload=offload, + is_schnell=is_schnell, + ) + + do_img2img = ( + st.checkbox( + "Image to Image", + False, + disabled=is_schnell, + help="Partially noise an image and denoise again to get variations.\n\nOnly works for flux-dev", + ) + and not is_schnell + ) + if do_img2img: + init_image = get_image() + if init_image is None: + st.warning("Please add an image to do image to image") + image2image_strength = st.number_input("Noising strength", min_value=0.0, max_value=1.0, value=0.8) + if init_image is not None: + h, w = init_image.shape[-2:] + st.write(f"Got image of size {w}x{h} ({h*w/1e6:.2f}MP)") + resize_img = st.checkbox("Resize image", False) or init_image is None + else: + init_image = None + resize_img = True + image2image_strength = 0.0 + + # allow for packing and conversion to latent space + width = int( + 16 * (st.number_input("Width", min_value=128, value=1360, step=16, disabled=not resize_img) // 16) + ) + height = int( + 16 * (st.number_input("Height", min_value=128, value=768, step=16, disabled=not resize_img) // 16) + ) + num_steps = int(st.number_input("Number of steps", min_value=1, value=(4 if is_schnell else 50))) + guidance = float(st.number_input("Guidance", min_value=1.0, value=3.5, disabled=is_schnell)) + seed_str = st.text_input("Seed", disabled=is_schnell) + if seed_str.isdecimal(): + seed = int(seed_str) + else: + st.info("No seed set, set to positive integer to enable") + seed = None + save_samples = st.checkbox("Save samples?", not is_schnell) + add_sampling_metadata = st.checkbox("Add sampling parameters to metadata?", True) + + default_prompt = ( + "a photo of a forest with mist swirling around the tree trunks. The word " + '"FLUX" is painted over it in big, red brush strokes with visible texture' + ) + prompt = st_keyup("Enter a prompt", value=default_prompt, debounce=300, key="interactive_text") + + output_name = os.path.join(output_dir, "img_{idx}.jpg") + if not os.path.exists(output_dir): + os.makedirs(output_dir) + idx = 0 + else: + fns = [fn for fn in iglob(output_name.format(idx="*")) if re.search(r"img_[0-9]+\.jpg$", fn)] + if len(fns) > 0: + idx = max(int(fn.split("_")[-1].split(".")[0]) for fn in fns) + 1 + else: + idx = 0 + + rng = torch.Generator(device="cpu") + + if "seed" not in st.session_state: + st.session_state.seed = rng.seed() + + def increment_counter(): + st.session_state.seed += 1 + + def decrement_counter(): + if st.session_state.seed > 0: + st.session_state.seed -= 1 + + opts = SamplingOptions( + prompt=prompt, + width=width, + height=height, + num_steps=num_steps, + guidance=guidance, + seed=seed, + ) + + if name == "flux-schnell": + cols = st.columns([5, 1, 1, 5]) + with cols[1]: + st.button("↩", on_click=increment_counter) + with cols[2]: + st.button("↪", on_click=decrement_counter) + if is_schnell or st.button("Sample"): + if is_schnell: + opts.seed = st.session_state.seed + elif opts.seed is None: + opts.seed = rng.seed() + print(f"Generating '{opts.prompt}' with seed {opts.seed}") + t0 = time.perf_counter() + + if init_image is not None: + if resize_img: + init_image = torch.nn.functional.interpolate(init_image, (opts.height, opts.width)) + else: + h, w = init_image.shape[-2:] + init_image = init_image[..., : 16 * (h // 16), : 16 * (w // 16)] + opts.height = init_image.shape[-2] + opts.width = init_image.shape[-1] + if offload: + ae.encoder.to(torch_device) + init_image = ae.encode(init_image.to(torch_device)) + if offload: + ae = ae.cpu() + torch.cuda.empty_cache() + + # prepare input + x = get_noise( + 1, + opts.height, + opts.width, + device=torch_device, + dtype=torch.bfloat16, + seed=opts.seed, + ) + # divide pixel space by 16**2 to account for latent space conversion + timesteps = get_schedule( + opts.num_steps, + (x.shape[-1] * x.shape[-2]) // 4, + shift=(not is_schnell), + ) + if init_image is not None: + t_idx = int((1 - image2image_strength) * num_steps) + t = timesteps[t_idx] + timesteps = timesteps[t_idx:] + x = t * x + (1.0 - t) * init_image.to(x.dtype) + + if offload: + t5, clip = t5.to(torch_device), clip.to(torch_device) + inp = prepare(t5=t5, clip=clip, img=x, prompt=opts.prompt) + + # offload TEs to CPU, load model to gpu + if offload: + t5, clip = t5.cpu(), clip.cpu() + torch.cuda.empty_cache() + model = model.to(torch_device) + + # denoise initial noise + x = denoise(model, **inp, timesteps=timesteps, guidance=opts.guidance) + + # offload model, load autoencoder to gpu + if offload: + model.cpu() + torch.cuda.empty_cache() + ae.decoder.to(x.device) + + # decode latents to pixel space + x = unpack(x.float(), opts.height, opts.width) + with torch.autocast(device_type=torch_device.type, dtype=torch.bfloat16): + x = ae.decode(x) + + if offload: + ae.decoder.cpu() + torch.cuda.empty_cache() + + t1 = time.perf_counter() + + fn = output_name.format(idx=idx) + print(f"Done in {t1 - t0:.1f}s.") + # bring into PIL format and save + x = x.clamp(-1, 1) + x = embed_watermark(x.float()) + x = rearrange(x[0], "c h w -> h w c") + + img = Image.fromarray((127.5 * (x + 1.0)).cpu().byte().numpy()) + nsfw_score = [x["score"] for x in nsfw_classifier(img) if x["label"] == "nsfw"][0] + + if nsfw_score < NSFW_THRESHOLD: + buffer = BytesIO() + exif_data = Image.Exif() + if init_image is None: + exif_data[ExifTags.Base.Software] = "AI generated;txt2img;flux" + else: + exif_data[ExifTags.Base.Software] = "AI generated;img2img;flux" + exif_data[ExifTags.Base.Make] = "Black Forest Labs" + exif_data[ExifTags.Base.Model] = name + if add_sampling_metadata: + exif_data[ExifTags.Base.ImageDescription] = prompt + img.save(buffer, format="jpeg", exif=exif_data, quality=95, subsampling=0) + + img_bytes = buffer.getvalue() + if save_samples: + print(f"Saving {fn}") + with open(fn, "wb") as file: + file.write(img_bytes) + idx += 1 + + st.session_state["samples"] = { + "prompt": opts.prompt, + "img": img, + "seed": opts.seed, + "bytes": img_bytes, + } + opts.seed = None + else: + st.warning("Your generated image may contain NSFW content.") + st.session_state["samples"] = None + + samples = st.session_state.get("samples", None) + if samples is not None: + st.image(samples["img"], caption=samples["prompt"]) + st.download_button( + "Download full-resolution", + samples["bytes"], + file_name="generated.jpg", + mime="image/jpg", + ) + st.write(f"Seed: {samples['seed']}") + + +def app(): + Fire(main) + + +if __name__ == "__main__": + app() diff --git a/concept_attention/flux/model_cards/FLUX.1-dev.md b/concept_attention/flux/model_cards/FLUX.1-dev.md new file mode 100644 index 0000000000000000000000000000000000000000..a8d6d8e1766b4383d35c783b4dbc52102193951c --- /dev/null +++ b/concept_attention/flux/model_cards/FLUX.1-dev.md @@ -0,0 +1,46 @@ +![FLUX.1 [dev] Grid](../assets/dev_grid.jpg) + +`FLUX.1 [dev]` is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions. +For more information, please read our [blog post](https://blackforestlabs.ai/announcing-black-forest-labs/). + +# Key Features +1. Cutting-edge output quality, second only to our state-of-the-art model `FLUX.1 [pro]`. +2. Competitive prompt following, matching the performance of closed source alternatives. +3. Trained using guidance distillation, making `FLUX.1 [dev]` more efficient. +4. Open weights to drive new scientific research, and empower artists to develop innovative workflows. +5. Generated outputs can be used for personal, scientific, and commercial purposes, as described in the [flux-1-dev-non-commercial-license](./licence.md). + +# Usage +We provide a reference implementation of `FLUX.1 [dev]`, as well as sampling code, in a dedicated [github repository](https://github.com/black-forest-labs/flux). +Developers and creatives looking to build on top of `FLUX.1 [dev]` are encouraged to use this as a starting point. + +## API Endpoints +The FLUX.1 models are also available via API from the following sources +1. [bfl.ml](https://docs.bfl.ml/) (currently `FLUX.1 [pro]`) +2. [replicate.com](https://replicate.com/collections/flux) +3. [fal.ai](https://fal.ai/models/fal-ai/flux/dev) + +## ComfyUI +`FLUX.1 [dev]` is also available in [Comfy UI](https://github.com/comfyanonymous/ComfyUI) for local inference with a node-based workflow. + +--- +# Limitations +- This model is not intended or able to provide factual information. +- As a statistical model this checkpoint might amplify existing societal biases. +- The model may fail to generate output that matches the prompts. +- Prompt following is heavily influenced by the prompting-style. + +# Out-of-Scope Use +The model and its derivatives may not be used + +- In any way that violates any applicable national, federal, state, local or international law or regulation. +- For the purpose of exploiting, harming or attempting to exploit or harm minors in any way; including but not limited to the solicitation, creation, acquisition, or dissemination of child exploitative content. +- To generate or disseminate verifiably false information and/or content with the purpose of harming others. +- To generate or disseminate personal identifiable information that can be used to harm an individual. +- To harass, abuse, threaten, stalk, or bully individuals or groups of individuals. +- To create non-consensual nudity or illegal pornographic content. +- For fully automated decision making that adversely impacts an individual's legal rights or otherwise creates or modifies a binding, enforceable obligation. +- Generating or facilitating large-scale disinformation campaigns. + +# License +This model falls under the [`FLUX.1 [dev]` Non-Commercial License](https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.md). diff --git a/concept_attention/flux/model_cards/FLUX.1-schnell.md b/concept_attention/flux/model_cards/FLUX.1-schnell.md new file mode 100644 index 0000000000000000000000000000000000000000..4694d82131b52b9830f3a16c0c76b3a9c1905427 --- /dev/null +++ b/concept_attention/flux/model_cards/FLUX.1-schnell.md @@ -0,0 +1,41 @@ +![FLUX.1 [schnell] Grid](../assets/schnell_grid.jpg) + +`FLUX.1 [schnell]` is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions. +For more information, please read our [blog post](https://blackforestlabs.ai/announcing-black-forest-labs/). + +# Key Features +1. Cutting-edge output quality and competitive prompt following, matching the performance of closed source alternatives. +2. Trained using latent adversarial diffusion distillation, `FLUX.1 [schnell]` can generate high-quality images in only 1 to 4 steps. +3. Released under the `apache-2.0` licence, the model can be used for personal, scientific, and commercial purposes. + +# Usage +We provide a reference implementation of `FLUX.1 [schnell]`, as well as sampling code, in a dedicated [github repository](https://github.com/black-forest-labs/flux). +Developers and creatives looking to build on top of `FLUX.1 [schnell]` are encouraged to use this as a starting point. + +## API Endpoints +The FLUX.1 models are also available via API from the following sources +1. [bfl.ml](https://docs.bfl.ml/) (currently `FLUX.1 [pro]`) +2. [replicate.com](https://replicate.com/collections/flux) +3. [fal.ai](https://fal.ai/models/fal-ai/flux/schnell) + +## ComfyUI +`FLUX.1 [schnell]` is also available in [Comfy UI](https://github.com/comfyanonymous/ComfyUI) for local inference with a node-based workflow. + +--- +# Limitations +- This model is not intended or able to provide factual information. +- As a statistical model this checkpoint might amplify existing societal biases. +- The model may fail to generate output that matches the prompts. +- Prompt following is heavily influenced by the prompting-style. + +# Out-of-Scope Use +The model and its derivatives may not be used + +- In any way that violates any applicable national, federal, state, local or international law or regulation. +- For the purpose of exploiting, harming or attempting to exploit or harm minors in any way; including but not limited to the solicitation, creation, acquisition, or dissemination of child exploitative content. +- To generate or disseminate verifiably false information and/or content with the purpose of harming others. +- To generate or disseminate personal identifiable information that can be used to harm an individual. +- To harass, abuse, threaten, stalk, or bully individuals or groups of individuals. +- To create non-consensual nudity or illegal pornographic content. +- For fully automated decision making that adversely impacts an individual's legal rights or otherwise creates or modifies a binding, enforceable obligation. +- Generating or facilitating large-scale disinformation campaigns. diff --git a/concept_attention/flux/model_licenses/LICENSE-FLUX1-dev b/concept_attention/flux/model_licenses/LICENSE-FLUX1-dev new file mode 100644 index 0000000000000000000000000000000000000000..d91cf0bcef46f7ab49551034ccf3bea6b765f8d6 --- /dev/null +++ b/concept_attention/flux/model_licenses/LICENSE-FLUX1-dev @@ -0,0 +1,42 @@ +FLUX.1 [dev] Non-Commercial License +Black Forest Labs, Inc. (“we” or “our” or “Company”) is pleased to make available the weights, parameters and inference code for the FLUX.1 [dev] Model (as defined below) freely available for your non-commercial and non-production use as set forth in this FLUX.1 [dev] Non-Commercial License (“License”). The “FLUX.1 [dev] Model” means the FLUX.1 [dev] text-to-image AI model and its elements which includes algorithms, software, checkpoints, parameters, source code (inference code, evaluation code, and if applicable, fine-tuning code) and any other materials associated with the FLUX.1 [dev] AI model made available by Company under this License, including if any, the technical documentation, manuals and instructions for the use and operation thereof (collectively, “FLUX.1 [dev] Model”). +By downloading, accessing, use, Distributing (as defined below), or creating a Derivative (as defined below) of the FLUX.1 [dev] Model, you agree to the terms of this License. If you do not agree to this License, then you do not have any rights to access, use, Distribute or create a Derivative of the FLUX.1 [dev] Model and you must immediately cease using the FLUX.1 [dev] Model. If you are agreeing to be bound by the terms of this License on behalf of your employer or other entity, you represent and warrant to us that you have full legal authority to bind your employer or such entity to this License. If you do not have the requisite authority, you may not accept the License or access the FLUX.1 [dev] Model on behalf of your employer or other entity. + 1. Definitions. Capitalized terms used in this License but not defined herein have the following meanings: + a. “Derivative” means any (i) modified version of the FLUX.1 [dev] Model (including but not limited to any customized or fine-tuned version thereof), (ii) work based on the FLUX.1 [dev] Model, or (iii) any other derivative work thereof. For the avoidance of doubt, Outputs are not considered Derivatives under this License. + b. “Distribution” or “Distribute” or “Distributing” means providing or making available, by any means, a copy of the FLUX.1 [dev] Models and/or the Derivatives as the case may be. + c. “Non-Commercial Purpose” means any of the following uses, but only so far as you do not receive any direct or indirect payment arising from the use of the model or its output: (i) personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, or otherwise not directly or indirectly connected to any commercial activities, business operations, or employment responsibilities; (ii) use by commercial or for-profit entities for testing, evaluation, or non-commercial research and development in a non-production environment, (iii) use by any charitable organization for charitable purposes, or for testing or evaluation. For clarity, use for revenue-generating activity or direct interactions with or impacts on end users, or use to train, fine tune or distill other models for commercial use is not a Non-Commercial purpose. + d. “Outputs” means any content generated by the operation of the FLUX.1 [dev] Models or the Derivatives from a prompt (i.e., text instructions) provided by users. For the avoidance of doubt, Outputs do not include any components of a FLUX.1 [dev] Models, such as any fine-tuned versions of the FLUX.1 [dev] Models, the weights, or parameters. + e. “you” or “your” means the individual or entity entering into this License with Company. + 2. License Grant. + a. License. Subject to your compliance with this License, Company grants you a non-exclusive, worldwide, non-transferable, non-sublicensable, revocable, royalty free and limited license to access, use, create Derivatives of, and Distribute the FLUX.1 [dev] Models solely for your Non-Commercial Purposes. The foregoing license is personal to you, and you may not assign or sublicense this License or any other rights or obligations under this License without Company’s prior written consent; any such assignment or sublicense will be void and will automatically and immediately terminate this License. Any restrictions set forth herein in regarding the FLUX.1 [dev] Model also applies to any Derivative you create or that are created on your behalf. + b. Non-Commercial Use Only. You may only access, use, Distribute, or creative Derivatives of or the FLUX.1 [dev] Model or Derivatives for Non-Commercial Purposes. If You want to use a FLUX.1 [dev] Model a Derivative for any purpose that is not expressly authorized under this License, such as for a commercial activity, you must request a license from Company, which Company may grant to you in Company’s sole discretion and which additional use may be subject to a fee, royalty or other revenue share. Please contact Company at the following e-mail address if you want to discuss such a license: info@blackforestlabs.ai. + c. Reserved Rights. The grant of rights expressly set forth in this License are the complete grant of rights to you in the FLUX.1 [dev] Model, and no other licenses are granted, whether by waiver, estoppel, implication, equity or otherwise. Company and its licensors reserve all rights not expressly granted by this License. + d. Outputs. We claim no ownership rights in and to the Outputs. You are solely responsible for the Outputs you generate and their subsequent uses in accordance with this License. You may use Output for any purpose (including for commercial purposes), except as expressly prohibited herein. You may not use the Output to train, fine-tune or distill a model that is competitive with the FLUX.1 [dev] Model. + 3. Distribution. Subject to this License, you may Distribute copies of the FLUX.1 [dev] Model and/or Derivatives made by you, under the following conditions: + a. you must make available a copy of this License to third-party recipients of the FLUX.1 [dev] Models and/or Derivatives you Distribute, and specify that any rights to use the FLUX.1 [dev] Models and/or Derivatives shall be directly granted by Company to said third-party recipients pursuant to this License; + b. you must make prominently display the following notice alongside the Distribution of the FLUX.1 [dev] Model or Derivative (such as via a “Notice” text file distributed as part of such FLUX.1 [dev] Model or Derivative) (the “Attribution Notice”): +“The FLUX.1 [dev] Model is licensed by Black Forest Labs. Inc. under the FLUX.1 [dev] Non-Commercial License. Copyright Black Forest Labs. Inc. +IN NO EVENT SHALL BLACK FOREST LABS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH USE OF THIS MODEL.” + c. in the case of Distribution of Derivatives made by you, you must also include in the Attribution Notice a statement that you have modified the applicable FLUX.1 [dev] Model; and + d. in the case of Distribution of Derivatives made by you, any terms and conditions you impose on any third-party recipients relating to Derivatives made by or for you shall neither limit such third-party recipients’ use of the FLUX.1 [dev] Model or any Derivatives made by or for Company in accordance with this License nor conflict with any of its terms and conditions. + e. In the case of Distribution of Derivatives made by you, you must not misrepresent or imply, through any means, that the Derivatives made by or for you and/or any modified version of the FLUX.1 [dev] Model you Distribute under your name and responsibility is an official product of the Company or has been endorsed, approved or validated by the Company, unless you are authorized by Company to do so in writing. + 4. Restrictions. You will not, and will not permit, assist or cause any third party to + a. use, modify, copy, reproduce, create Derivatives of, or Distribute the FLUX.1 [dev] Model (or any Derivative thereof, or any data produced by the FLUX.1 [dev] Model), in whole or in part, for (i) any commercial or production purposes, (ii) military purposes, (iii) purposes of surveillance, including any research or development relating to surveillance, (iv) biometric processing, (v) in any manner that infringes, misappropriates, or otherwise violates any third-party rights, or (vi) in any manner that violates any applicable law and violating any privacy or security laws, rules, regulations, directives, or governmental requirements (including the General Data Privacy Regulation (Regulation (EU) 2016/679), the California Consumer Privacy Act, and any and all laws governing the processing of biometric information), as well as all amendments and successor laws to any of the foregoing; + b. alter or remove copyright and other proprietary notices which appear on or in any portion of the FLUX.1 [dev] Model; + c. utilize any equipment, device, software, or other means to circumvent or remove any security or protection used by Company in connection with the FLUX.1 [dev] Model, or to circumvent or remove any usage restrictions, or to enable functionality disabled by FLUX.1 [dev] Model; or + d. offer or impose any terms on the FLUX.1 [dev] Model that alter, restrict, or are inconsistent with the terms of this License. + e. violate any applicable U.S. and non-U.S. export control and trade sanctions laws (“Export Laws”) in connection with your use or Distribution of any FLUX.1 [dev] Model; + f. directly or indirectly Distribute, export, or otherwise transfer FLUX.1 [dev] Model (a) to any individual, entity, or country prohibited by Export Laws; (b) to anyone on U.S. or non-U.S. government restricted parties lists; or (c) for any purpose prohibited by Export Laws, including nuclear, chemical or biological weapons, or missile technology applications; 3) use or download FLUX.1 [dev] Model if you or they are (a) located in a comprehensively sanctioned jurisdiction, (b) currently listed on any U.S. or non-U.S. restricted parties list, or (c) for any purpose prohibited by Export Laws; and (4) will not disguise your location through IP proxying or other methods. + 5. DISCLAIMERS. THE FLUX.1 [dev] MODEL IS PROVIDED “AS IS” AND “WITH ALL FAULTS” WITH NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. COMPANY EXPRESSLY DISCLAIMS ALL REPRESENTATIONS AND WARRANTIES, EXPRESS OR IMPLIED, WHETHER BY STATUTE, CUSTOM, USAGE OR OTHERWISE AS TO ANY MATTERS RELATED TO THE FLUX.1 [dev] MODEL, INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, SATISFACTORY QUALITY, OR NON-INFRINGEMENT. COMPANY MAKES NO WARRANTIES OR REPRESENTATIONS THAT THE FLUX.1 [dev] MODEL WILL BE ERROR FREE OR FREE OF VIRUSES OR OTHER HARMFUL COMPONENTS, OR PRODUCE ANY PARTICULAR RESULTS. + 6. LIMITATION OF LIABILITY. TO THE FULLEST EXTENT PERMITTED BY LAW, IN NO EVENT WILL COMPANY BE LIABLE TO YOU OR YOUR EMPLOYEES, AFFILIATES, USERS, OFFICERS OR DIRECTORS (A) UNDER ANY THEORY OF LIABILITY, WHETHER BASED IN CONTRACT, TORT, NEGLIGENCE, STRICT LIABILITY, WARRANTY, OR OTHERWISE UNDER THIS LICENSE, OR (B) FOR ANY INDIRECT, CONSEQUENTIAL, EXEMPLARY, INCIDENTAL, PUNITIVE OR SPECIAL DAMAGES OR LOST PROFITS, EVEN IF COMPANY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE FLUX.1 [dev] MODEL, ITS CONSTITUENT COMPONENTS, AND ANY OUTPUT (COLLECTIVELY, “MODEL MATERIALS”) ARE NOT DESIGNED OR INTENDED FOR USE IN ANY APPLICATION OR SITUATION WHERE FAILURE OR FAULT OF THE MODEL MATERIALS COULD REASONABLY BE ANTICIPATED TO LEAD TO SERIOUS INJURY OF ANY PERSON, INCLUDING POTENTIAL DISCRIMINATION OR VIOLATION OF AN INDIVIDUAL’S PRIVACY RIGHTS, OR TO SEVERE PHYSICAL, PROPERTY, OR ENVIRONMENTAL DAMAGE (EACH, A “HIGH-RISK USE”). IF YOU ELECT TO USE ANY OF THE MODEL MATERIALS FOR A HIGH-RISK USE, YOU DO SO AT YOUR OWN RISK. YOU AGREE TO DESIGN AND IMPLEMENT APPROPRIATE DECISION-MAKING AND RISK-MITIGATION PROCEDURES AND POLICIES IN CONNECTION WITH A HIGH-RISK USE SUCH THAT EVEN IF THERE IS A FAILURE OR FAULT IN ANY OF THE MODEL MATERIALS, THE SAFETY OF PERSONS OR PROPERTY AFFECTED BY THE ACTIVITY STAYS AT A LEVEL THAT IS REASONABLE, APPROPRIATE, AND LAWFUL FOR THE FIELD OF THE HIGH-RISK USE. + 7. INDEMNIFICATION + +You will indemnify, defend and hold harmless Company and our subsidiaries and affiliates, and each of our respective shareholders, directors, officers, employees, agents, successors, and assigns (collectively, the “Company Parties”) from and against any losses, liabilities, damages, fines, penalties, and expenses (including reasonable attorneys’ fees) incurred by any Company Party in connection with any claim, demand, allegation, lawsuit, proceeding, or investigation (collectively, “Claims”) arising out of or related to (a) your access to or use of the FLUX.1 [dev] Model (as well as any Output, results or data generated from such access or use), including any High-Risk Use (defined below); (b) your violation of this License; or (c) your violation, misappropriation or infringement of any rights of another (including intellectual property or other proprietary rights and privacy rights). You will promptly notify the Company Parties of any such Claims, and cooperate with Company Parties in defending such Claims. You will also grant the Company Parties sole control of the defense or settlement, at Company’s sole option, of any Claims. This indemnity is in addition to, and not in lieu of, any other indemnities or remedies set forth in a written agreement between you and Company or the other Company Parties. + 8. Termination; Survival. + a. This License will automatically terminate upon any breach by you of the terms of this License. + b. We may terminate this License, in whole or in part, at any time upon notice (including electronic) to you. + c. If You initiate any legal action or proceedings against Company or any other entity (including a cross-claim or counterclaim in a lawsuit), alleging that the FLUX.1 [dev] Model or any Derivative, or any part thereof, infringe upon intellectual property or other rights owned or licensable by you, then any licenses granted to you under this License will immediately terminate as of the date such legal action or claim is filed or initiated. + d. Upon termination of this License, you must cease all use, access or Distribution of the FLUX.1 [dev] Model and any Derivatives. The following sections survive termination of this License 2(c), 2(d), 4-11. + 9. Third Party Materials. The FLUX.1 [dev] Model may contain third-party software or other components (including free and open source software) (all of the foregoing, “Third Party Materials”), which are subject to the license terms of the respective third-party licensors. Your dealings or correspondence with third parties and your use of or interaction with any Third Party Materials are solely between you and the third party. Company does not control or endorse, and makes no representations or warranties regarding, any Third Party Materials, and your access to and use of such Third Party Materials are at your own risk. + 10. Trademarks. You have not been granted any trademark license as part of this License and may not use any name or mark associated with Company without the prior written permission of Company, except to the extent necessary to make the reference required in the Attribution Notice as specified above or as is reasonably necessary in describing the FLUX.1 [dev] Model and its creators. + 11. General. This License will be governed and construed under the laws of the State of Delaware without regard to conflicts of law provisions. If any provision or part of a provision of this License is unlawful, void or unenforceable, that provision or part of the provision is deemed severed from this License, and will not affect the validity and enforceability of any remaining provisions. The failure of Company to exercise or enforce any right or provision of this License will not operate as a waiver of such right or provision. This License does not confer any third-party beneficiary rights upon any other person or entity. This License, together with the Documentation, contains the entire understanding between you and Company regarding the subject matter of this License, and supersedes all other written or oral agreements and understandings between you and Company regarding such subject matter. No change or addition to any provision of this License will be binding unless it is in writing and signed by an authorized representative of both you and Company. \ No newline at end of file diff --git a/concept_attention/flux/model_licenses/LICENSE-FLUX1-schnell b/concept_attention/flux/model_licenses/LICENSE-FLUX1-schnell new file mode 100644 index 0000000000000000000000000000000000000000..263e72a4a315b23a3cf29ed43dda8204459c4da3 --- /dev/null +++ b/concept_attention/flux/model_licenses/LICENSE-FLUX1-schnell @@ -0,0 +1,54 @@ + + +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + +You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/concept_attention/flux/pyproject.toml b/concept_attention/flux/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..72f921b41bf56921051eb0d5d70496e82c4c7cc6 --- /dev/null +++ b/concept_attention/flux/pyproject.toml @@ -0,0 +1,97 @@ +[project] +name = "flux" +authors = [ + { name = "Black Forest Labs", email = "support@blackforestlabs.ai" }, +] +description = "Inference codebase for FLUX" +readme = "README.md" +requires-python = ">=3.10" +license = { file = "LICENSE.md" } +dynamic = ["version"] +dependencies = [ + "torch >= 2.0.0", + "torchvision", + "einops", + "fire >= 0.6.0", + "huggingface-hub", + "safetensors", + "sentencepiece", + "transformers", + "tokenizers", + "protobuf", + "requests", + "invisible-watermark", +] + +[project.optional-dependencies] +streamlit = [ + "streamlit", + "streamlit-keyup", +] +gradio = [ + "gradio", +] +all = [ + "flux[streamlit]", + "flux[gradio]", +] + +[project.scripts] +flux = "flux.cli:app" + +[build-system] +build-backend = "setuptools.build_meta" +requires = ["setuptools>=64", "wheel", "setuptools_scm>=8"] + +[tool.ruff] +line-length = 110 +target-version = "py310" +extend-exclude = ["/usr/lib/*"] + +[tool.ruff.lint] +ignore = [ + "E501", # line too long - will be fixed in format +] + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +line-ending = "auto" +skip-magic-trailing-comma = false +docstring-code-format = true +exclude = [ + "src/flux/_version.py", # generated by setuptools_scm +] + +[tool.ruff.lint.isort] +combine-as-imports = true +force-wrap-aliases = true +known-local-folder = ["src"] +known-first-party = ["flux"] + +[tool.pyright] +include = ["src"] +exclude = [ + "**/__pycache__", # cache directories + "./typings", # generated type stubs +] +stubPath = "./typings" + +[tool.tomlsort] +in_place = true +no_sort_tables = true +spaces_before_inline_comment = 1 +spaces_indent_inline_array = 2 +trailing_comma_inline_array = true +sort_first = [ + "project", + "build-system", + "tool.setuptools", +] + +# needs to be last for CI reasons +[tool.setuptools_scm] +write_to = "src/flux/_version.py" +parentdir_prefix_version = "flux-" +fallback_version = "0.0.0" +version_scheme = "post-release" diff --git a/concept_attention/flux/setup.py b/concept_attention/flux/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..b908cbe55cb344569d32de1dfc10ca7323828dc5 --- /dev/null +++ b/concept_attention/flux/setup.py @@ -0,0 +1,3 @@ +import setuptools + +setuptools.setup() diff --git a/concept_attention/flux/src/flux.egg-info/PKG-INFO b/concept_attention/flux/src/flux.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..421d20032de6d7da850b2bcbbbd03e0db057bbe4 --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/PKG-INFO @@ -0,0 +1,223 @@ +Metadata-Version: 2.1 +Name: flux +Version: 0.0.post39+g478338d.d20241111 +Summary: Inference codebase for FLUX +Author-email: Black Forest Labs +Requires-Python: >=3.10 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: torch>=2.0.0 +Requires-Dist: torchvision +Requires-Dist: einops +Requires-Dist: fire>=0.6.0 +Requires-Dist: huggingface-hub +Requires-Dist: safetensors +Requires-Dist: sentencepiece +Requires-Dist: transformers +Requires-Dist: tokenizers +Requires-Dist: protobuf +Requires-Dist: requests +Requires-Dist: invisible-watermark +Provides-Extra: streamlit +Requires-Dist: streamlit; extra == "streamlit" +Requires-Dist: streamlit-keyup; extra == "streamlit" +Provides-Extra: gradio +Requires-Dist: gradio; extra == "gradio" +Provides-Extra: all +Requires-Dist: flux[streamlit]; extra == "all" +Requires-Dist: flux[gradio]; extra == "all" + +# FLUX +by Black Forest Labs: https://blackforestlabs.ai. Documentation for our API can be found here: [docs.bfl.ml](https://docs.bfl.ml/). + +![grid](assets/grid.jpg) + +This repo contains minimal inference code to run text-to-image and image-to-image with our Flux latent rectified flow transformers. + +### Inference partners + +We are happy to partner with [Replicate](https://replicate.com/), [FAL](https://fal.ai/), [Mystic](https://www.mystic.ai), and [Together](https://www.together.ai/). You can sample our models using their services. +Below we list relevant links. + +Replicate: + +- https://replicate.com/collections/flux +- https://replicate.com/collections/flux-fine-tunes +- https://replicate.com/black-forest-labs/flux-pro +- https://replicate.com/black-forest-labs/flux-dev +- https://replicate.com/black-forest-labs/flux-schnell + +FAL: + +- https://fal.ai/models/fal-ai/flux-pro +- https://fal.ai/models/fal-ai/flux/dev +- https://fal.ai/models/fal-ai/flux/schnell + +Mystic: + +- https://www.mystic.ai/black-forest-labs +- https://www.mystic.ai/black-forest-labs/flux1-pro +- https://www.mystic.ai/black-forest-labs/flux1-dev +- https://www.mystic.ai/black-forest-labs/flux1-schnell + +Together: +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-schnell-Free (ends December 31, 2024) +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-schnell +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1.1-pro +- https://api.together.xyz/playground/image/black-forest-labs/FLUX.1-pro + +## Local installation + +```bash +cd $HOME && git clone https://github.com/black-forest-labs/flux +cd $HOME/flux +python3.10 -m venv .venv +source .venv/bin/activate +pip install -e ".[all]" +``` + +### Models + +We are offering three models: + +- `FLUX1.1 [pro]` available via API only +- `FLUX.1 [pro]` available via API only +- `FLUX.1 [dev]` guidance-distilled variant +- `FLUX.1 [schnell]` guidance and step-distilled variant + +| Name | HuggingFace repo | License | md5sum | +| ------------------ | ------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------- | +| `FLUX.1 [schnell]` | https://huggingface.co/black-forest-labs/FLUX.1-schnell | [apache-2.0](model_licenses/LICENSE-FLUX1-schnell) | a9e1e277b9b16add186f38e3f5a34044 | +| `FLUX.1 [dev]` | https://huggingface.co/black-forest-labs/FLUX.1-dev | [FLUX.1-dev Non-Commercial License](model_licenses/LICENSE-FLUX1-dev) | a6bd8c16dfc23db6aee2f63a2eba78c0 | +| `FLUX.1 [pro]` | Only available in our API. | +| `FLUX1.1 [pro]` | Only available in our API. | + +The weights of the autoencoder are also released under [apache-2.0](https://huggingface.co/datasets/choosealicense/licenses/blob/main/markdown/apache-2.0.md) and can be found in either of the two HuggingFace repos above. They are the same for both models. + +## Usage + +The weights will be downloaded automatically from HuggingFace once you start one of the demos. To download `FLUX.1 [dev]`, you will need to be logged in, see [here](https://huggingface.co/docs/huggingface_hub/guides/cli#huggingface-cli-login). +If you have downloaded the model weights manually, you can specify the downloaded paths via environment-variables: + +```bash +export FLUX_SCHNELL= +export FLUX_DEV= +export AE= +``` + +For interactive sampling run + +```bash +python -m flux --name --loop +``` + +Or to generate a single sample run + +```bash +python -m flux --name \ + --height --width \ + --prompt "" +``` + +We also provide a streamlit demo that does both text-to-image and image-to-image. The demo can be run via + +```bash +streamlit run demo_st.py +``` + +We also offer a Gradio-based demo for an interactive experience. To run the Gradio demo: + +```bash +python demo_gr.py --name flux-schnell --device cuda +``` + +Options: + +- `--name`: Choose the model to use (options: "flux-schnell", "flux-dev") +- `--device`: Specify the device to use (default: "cuda" if available, otherwise "cpu") +- `--offload`: Offload model to CPU when not in use +- `--share`: Create a public link to your demo + +To run the demo with the dev model and create a public link: + +```bash +python demo_gr.py --name flux-dev --share +``` + +## Diffusers integration + +`FLUX.1 [schnell]` and `FLUX.1 [dev]` are integrated with the [🧨 diffusers](https://github.com/huggingface/diffusers) library. To use it with diffusers, install it: + +```shell +pip install git+https://github.com/huggingface/diffusers.git +``` + +Then you can use `FluxPipeline` to run the model + +```python +import torch +from diffusers import FluxPipeline + +model_id = "black-forest-labs/FLUX.1-schnell" #you can also use `black-forest-labs/FLUX.1-dev` + +pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16) +pipe.enable_model_cpu_offload() #save some VRAM by offloading the model to CPU. Remove this if you have enough GPU power + +prompt = "A cat holding a sign that says hello world" +seed = 42 +image = pipe( + prompt, + output_type="pil", + num_inference_steps=4, #use a larger number if you are using [dev] + generator=torch.Generator("cpu").manual_seed(seed) +).images[0] +image.save("flux-schnell.png") +``` + +To learn more check out the [diffusers](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) documentation + +## API usage + +Our API offers access to our models. It is documented here: +[docs.bfl.ml](https://docs.bfl.ml/). + +In this repository we also offer an easy python interface. To use this, you +first need to register with the API on [api.bfl.ml](https://api.bfl.ml/), and +create a new API key. + +To use the API key either run `export BFL_API_KEY=` or provide +it via the `api_key=` parameter. It is also expected that you +have installed the package as above. + +Usage from python: + +```python +from flux.api import ImageRequest + +# this will create an api request directly but not block until the generation is finished +request = ImageRequest("A beautiful beach", name="flux.1.1-pro") +# or: request = ImageRequest("A beautiful beach", name="flux.1.1-pro", api_key="your_key_here") + +# any of the following will block until the generation is finished +request.url +# -> https:<...>/sample.jpg +request.bytes +# -> b"..." bytes for the generated image +request.save("outputs/api.jpg") +# saves the sample to local storage +request.image +# -> a PIL image +``` + +Usage from the command line: + +```bash +$ python -m flux.api --prompt="A beautiful beach" url +https:<...>/sample.jpg + +# generate and save the result +$ python -m flux.api --prompt="A beautiful beach" save outputs/api + +# open the image directly +$ python -m flux.api --prompt="A beautiful beach" image show +``` diff --git a/concept_attention/flux/src/flux.egg-info/SOURCES.txt b/concept_attention/flux/src/flux.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..0c188884491e90063c75a680b3723924300c73c1 --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/SOURCES.txt @@ -0,0 +1,31 @@ +LICENSE +README.md +demo_gr.py +demo_st.py +pyproject.toml +setup.py +assets/dev_grid.jpg +assets/grid.jpg +assets/schnell_grid.jpg +model_cards/FLUX.1-dev.md +model_cards/FLUX.1-schnell.md +model_licenses/LICENSE-FLUX1-dev +model_licenses/LICENSE-FLUX1-schnell +src/flux/__init__.py +src/flux/__main__.py +src/flux/_version.py +src/flux/api.py +src/flux/cli.py +src/flux/math.py +src/flux/model.py +src/flux/sampling.py +src/flux/util.py +src/flux.egg-info/PKG-INFO +src/flux.egg-info/SOURCES.txt +src/flux.egg-info/dependency_links.txt +src/flux.egg-info/entry_points.txt +src/flux.egg-info/requires.txt +src/flux.egg-info/top_level.txt +src/flux/modules/autoencoder.py +src/flux/modules/conditioner.py +src/flux/modules/layers.py \ No newline at end of file diff --git a/concept_attention/flux/src/flux.egg-info/dependency_links.txt b/concept_attention/flux/src/flux.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/concept_attention/flux/src/flux.egg-info/entry_points.txt b/concept_attention/flux/src/flux.egg-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ad07442a1f4f10ed77867dae7c2dcdb53b1f648 --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +flux = flux.cli:app diff --git a/concept_attention/flux/src/flux.egg-info/requires.txt b/concept_attention/flux/src/flux.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..8231c0998010fdee4beb9b8f87c2391b2c607c9e --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/requires.txt @@ -0,0 +1,23 @@ +torch>=2.0.0 +torchvision +einops +fire>=0.6.0 +huggingface-hub +safetensors +sentencepiece +transformers +tokenizers +protobuf +requests +invisible-watermark + +[all] +flux[streamlit] +flux[gradio] + +[gradio] +gradio + +[streamlit] +streamlit +streamlit-keyup diff --git a/concept_attention/flux/src/flux.egg-info/top_level.txt b/concept_attention/flux/src/flux.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..2bf04427280c2092c1a5db088486a70fb74457bf --- /dev/null +++ b/concept_attention/flux/src/flux.egg-info/top_level.txt @@ -0,0 +1 @@ +flux diff --git a/concept_attention/flux/src/flux/__init__.py b/concept_attention/flux/src/flux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..43c365a49d6980e88acba10ef3069f110a59644a --- /dev/null +++ b/concept_attention/flux/src/flux/__init__.py @@ -0,0 +1,11 @@ +try: + from ._version import version as __version__ # type: ignore + from ._version import version_tuple +except ImportError: + __version__ = "unknown (no version information available)" + version_tuple = (0, 0, "unknown", "noinfo") + +from pathlib import Path + +PACKAGE = __package__.replace("_", "-") +PACKAGE_ROOT = Path(__file__).parent diff --git a/concept_attention/flux/src/flux/__main__.py b/concept_attention/flux/src/flux/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..d5cf0fd2444d4cda4053fa74dad3371556b886e5 --- /dev/null +++ b/concept_attention/flux/src/flux/__main__.py @@ -0,0 +1,4 @@ +from .cli import app + +if __name__ == "__main__": + app() diff --git a/concept_attention/flux/src/flux/_version.py b/concept_attention/flux/src/flux/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..b20b62f6644708807c912b70ba1d26422618402b --- /dev/null +++ b/concept_attention/flux/src/flux/_version.py @@ -0,0 +1,16 @@ +# file generated by setuptools_scm +# don't change, don't track in version control +TYPE_CHECKING = False +if TYPE_CHECKING: + from typing import Tuple, Union + VERSION_TUPLE = Tuple[Union[int, str], ...] +else: + VERSION_TUPLE = object + +version: str +__version__: str +__version_tuple__: VERSION_TUPLE +version_tuple: VERSION_TUPLE + +__version__ = version = '0.0.post39+g478338d.d20241111' +__version_tuple__ = version_tuple = (0, 0, 'g478338d.d20241111') diff --git a/concept_attention/flux/src/flux/api.py b/concept_attention/flux/src/flux/api.py new file mode 100644 index 0000000000000000000000000000000000000000..ae60d91a9065e84d73a91b131f93223571b10889 --- /dev/null +++ b/concept_attention/flux/src/flux/api.py @@ -0,0 +1,242 @@ +import io +import os +import time +from pathlib import Path + +import requests +from PIL import Image + +API_URL = "https://api.bfl.ml" +API_ENDPOINTS = { + "flux.1-pro": "flux-pro", + "flux.1-dev": "flux-dev", + "flux.1.1-pro": "flux-pro-1.1", +} + + +class ApiException(Exception): + def __init__(self, status_code: int, detail: str | list[dict] | None = None): + super().__init__() + self.detail = detail + self.status_code = status_code + + def __str__(self) -> str: + return self.__repr__() + + def __repr__(self) -> str: + if self.detail is None: + message = None + elif isinstance(self.detail, str): + message = self.detail + else: + message = "[" + ",".join(d["msg"] for d in self.detail) + "]" + return f"ApiException({self.status_code=}, {message=}, detail={self.detail})" + + +class ImageRequest: + def __init__( + self, + # api inputs + prompt: str, + name: str = "flux.1.1-pro", + width: int | None = None, + height: int | None = None, + num_steps: int | None = None, + prompt_upsampling: bool | None = None, + seed: int | None = None, + guidance: float | None = None, + interval: float | None = None, + safety_tolerance: int | None = None, + # behavior of this class + validate: bool = True, + launch: bool = True, + api_key: str | None = None, + ): + """ + Manages an image generation request to the API. + + All parameters not specified will use the API defaults. + + Args: + prompt: Text prompt for image generation. + width: Width of the generated image in pixels. Must be a multiple of 32. + height: Height of the generated image in pixels. Must be a multiple of 32. + name: Which model version to use + num_steps: Number of steps for the image generation process. + prompt_upsampling: Whether to perform upsampling on the prompt. + seed: Optional seed for reproducibility. + guidance: Guidance scale for image generation. + safety_tolerance: Tolerance level for input and output moderation. + Between 0 and 6, 0 being most strict, 6 being least strict. + validate: Run input validation + launch: Directly launches request + api_key: Your API key if not provided by the environment + + Raises: + ValueError: For invalid input, when `validate` + ApiException: For errors raised from the API + """ + if validate: + if name not in API_ENDPOINTS.keys(): + raise ValueError(f"Invalid model {name}") + elif width is not None and width % 32 != 0: + raise ValueError(f"width must be divisible by 32, got {width}") + elif width is not None and not (256 <= width <= 1440): + raise ValueError(f"width must be between 256 and 1440, got {width}") + elif height is not None and height % 32 != 0: + raise ValueError(f"height must be divisible by 32, got {height}") + elif height is not None and not (256 <= height <= 1440): + raise ValueError(f"height must be between 256 and 1440, got {height}") + elif num_steps is not None and not (1 <= num_steps <= 50): + raise ValueError(f"steps must be between 1 and 50, got {num_steps}") + elif guidance is not None and not (1.5 <= guidance <= 5.0): + raise ValueError(f"guidance must be between 1.5 and 4, got {guidance}") + elif interval is not None and not (1.0 <= interval <= 4.0): + raise ValueError(f"interval must be between 1 and 4, got {interval}") + elif safety_tolerance is not None and not (0 <= safety_tolerance <= 6.0): + raise ValueError( + f"safety_tolerance must be between 0 and 6, got {interval}" + ) + + if name == "flux.1-dev": + if interval is not None: + raise ValueError("Interval is not supported for flux.1-dev") + if name == "flux.1.1-pro": + if ( + interval is not None + or num_steps is not None + or guidance is not None + ): + raise ValueError( + "Interval, num_steps and guidance are not supported for " + "flux.1.1-pro" + ) + + self.name = name + self.request_json = { + "prompt": prompt, + "width": width, + "height": height, + "steps": num_steps, + "prompt_upsampling": prompt_upsampling, + "seed": seed, + "guidance": guidance, + "interval": interval, + "safety_tolerance": safety_tolerance, + } + self.request_json = { + key: value for key, value in self.request_json.items() if value is not None + } + + self.request_id: str | None = None + self.result: dict | None = None + self._image_bytes: bytes | None = None + self._url: str | None = None + if api_key is None: + self.api_key = os.environ.get("BFL_API_KEY") + else: + self.api_key = api_key + + if launch: + self.request() + + def request(self): + """ + Request to generate the image. + """ + if self.request_id is not None: + return + response = requests.post( + f"{API_URL}/v1/{API_ENDPOINTS[self.name]}", + headers={ + "accept": "application/json", + "x-key": self.api_key, + "Content-Type": "application/json", + }, + json=self.request_json, + ) + result = response.json() + if response.status_code != 200: + raise ApiException( + status_code=response.status_code, detail=result.get("detail") + ) + self.request_id = response.json()["id"] + + def retrieve(self) -> dict: + """ + Wait for the generation to finish and retrieve response. + """ + if self.request_id is None: + self.request() + while self.result is None: + response = requests.get( + f"{API_URL}/v1/get_result", + headers={ + "accept": "application/json", + "x-key": self.api_key, + }, + params={ + "id": self.request_id, + }, + ) + result = response.json() + if "status" not in result: + raise ApiException( + status_code=response.status_code, detail=result.get("detail") + ) + elif result["status"] == "Ready": + self.result = result["result"] + elif result["status"] == "Pending": + time.sleep(0.5) + else: + raise ApiException( + status_code=200, detail=f"API returned status '{result['status']}'" + ) + return self.result + + @property + def bytes(self) -> bytes: + """ + Generated image as bytes. + """ + if self._image_bytes is None: + response = requests.get(self.url) + if response.status_code == 200: + self._image_bytes = response.content + else: + raise ApiException(status_code=response.status_code) + return self._image_bytes + + @property + def url(self) -> str: + """ + Public url to retrieve the image from + """ + if self._url is None: + result = self.retrieve() + self._url = result["sample"] + return self._url + + @property + def image(self) -> Image.Image: + """ + Load the image as a PIL Image + """ + return Image.open(io.BytesIO(self.bytes)) + + def save(self, path: str): + """ + Save the generated image to a local path + """ + suffix = Path(self.url).suffix + if not path.endswith(suffix): + path = path + suffix + Path(path).resolve().parent.mkdir(parents=True, exist_ok=True) + with open(path, "wb") as file: + file.write(self.bytes) + + +if __name__ == "__main__": + from fire import Fire + + Fire(ImageRequest) diff --git a/concept_attention/flux/src/flux/cli.py b/concept_attention/flux/src/flux/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..6641a288c93376cd2bcf8e9ee8f5657016d53d9f --- /dev/null +++ b/concept_attention/flux/src/flux/cli.py @@ -0,0 +1,257 @@ +import os +import re +import time +from dataclasses import dataclass +from glob import iglob + +import torch +from einops import rearrange +from fire import Fire +from PIL import ExifTags, Image + +from concept_attention.flux.src.flux.sampling import denoise, get_noise, get_schedule, prepare, unpack +from concept_attention.flux.src.flux.util import (configs, embed_watermark, load_ae, load_clip, + load_flow_model, load_t5) +from transformers import pipeline + +NSFW_THRESHOLD = 0.85 + +@dataclass +class SamplingOptions: + prompt: str + width: int + height: int + num_steps: int + guidance: float + seed: int | None + + +def parse_prompt(options: SamplingOptions) -> SamplingOptions | None: + user_question = "Next prompt (write /h for help, /q to quit and leave empty to repeat):\n" + usage = ( + "Usage: Either write your prompt directly, leave this field empty " + "to repeat the prompt or write a command starting with a slash:\n" + "- '/w ' will set the width of the generated image\n" + "- '/h ' will set the height of the generated image\n" + "- '/s ' sets the next seed\n" + "- '/g ' sets the guidance (flux-dev only)\n" + "- '/n ' sets the number of steps\n" + "- '/q' to quit" + ) + + while (prompt := input(user_question)).startswith("/"): + if prompt.startswith("/w"): + if prompt.count(" ") != 1: + print(f"Got invalid command '{prompt}'\n{usage}") + continue + _, width = prompt.split() + options.width = 16 * (int(width) // 16) + print( + f"Setting resolution to {options.width} x {options.height} " + f"({options.height *options.width/1e6:.2f}MP)" + ) + elif prompt.startswith("/h"): + if prompt.count(" ") != 1: + print(f"Got invalid command '{prompt}'\n{usage}") + continue + _, height = prompt.split() + options.height = 16 * (int(height) // 16) + print( + f"Setting resolution to {options.width} x {options.height} " + f"({options.height *options.width/1e6:.2f}MP)" + ) + elif prompt.startswith("/g"): + if prompt.count(" ") != 1: + print(f"Got invalid command '{prompt}'\n{usage}") + continue + _, guidance = prompt.split() + options.guidance = float(guidance) + print(f"Setting guidance to {options.guidance}") + elif prompt.startswith("/s"): + if prompt.count(" ") != 1: + print(f"Got invalid command '{prompt}'\n{usage}") + continue + _, seed = prompt.split() + options.seed = int(seed) + print(f"Setting seed to {options.seed}") + elif prompt.startswith("/n"): + if prompt.count(" ") != 1: + print(f"Got invalid command '{prompt}'\n{usage}") + continue + _, steps = prompt.split() + options.num_steps = int(steps) + print(f"Setting number of steps to {options.num_steps}") + elif prompt.startswith("/q"): + print("Quitting") + return None + else: + if not prompt.startswith("/h"): + print(f"Got invalid command '{prompt}'\n{usage}") + print(usage) + if prompt != "": + options.prompt = prompt + return options + + +@torch.inference_mode() +def main( + name: str = "flux-schnell", + width: int = 1360, + height: int = 768, + seed: int | None = None, + prompt: str = ( + "a photo of a forest with mist swirling around the tree trunks. The word " + '"FLUX" is painted over it in big, red brush strokes with visible texture' + ), + device: str = "cuda" if torch.cuda.is_available() else "cpu", + num_steps: int | None = None, + loop: bool = False, + guidance: float = 3.5, + offload: bool = False, + output_dir: str = "output", + add_sampling_metadata: bool = True, +): + """ + Sample the flux model. Either interactively (set `--loop`) or run for a + single image. + + Args: + name: Name of the model to load + height: height of the sample in pixels (should be a multiple of 16) + width: width of the sample in pixels (should be a multiple of 16) + seed: Set a seed for sampling + output_name: where to save the output image, `{idx}` will be replaced + by the index of the sample + prompt: Prompt used for sampling + device: Pytorch device + num_steps: number of sampling steps (default 4 for schnell, 50 for guidance distilled) + loop: start an interactive session and sample multiple times + guidance: guidance value used for guidance distillation + add_sampling_metadata: Add the prompt to the image Exif metadata + """ + nsfw_classifier = pipeline("image-classification", model="Falconsai/nsfw_image_detection", device=device) + + if name not in configs: + available = ", ".join(configs.keys()) + raise ValueError(f"Got unknown model name: {name}, chose from {available}") + + torch_device = torch.device(device) + if num_steps is None: + num_steps = 4 if name == "flux-schnell" else 50 + + # allow for packing and conversion to latent space + height = 16 * (height // 16) + width = 16 * (width // 16) + + output_name = os.path.join(output_dir, "img_{idx}.jpg") + if not os.path.exists(output_dir): + os.makedirs(output_dir) + idx = 0 + else: + fns = [fn for fn in iglob(output_name.format(idx="*")) if re.search(r"img_[0-9]+\.jpg$", fn)] + if len(fns) > 0: + idx = max(int(fn.split("_")[-1].split(".")[0]) for fn in fns) + 1 + else: + idx = 0 + + # init all components + t5 = load_t5(torch_device, max_length=256 if name == "flux-schnell" else 512) + clip = load_clip(torch_device) + model = load_flow_model(name, device="cpu" if offload else torch_device) + ae = load_ae(name, device="cpu" if offload else torch_device) + + rng = torch.Generator(device="cpu") + opts = SamplingOptions( + prompt=prompt, + width=width, + height=height, + num_steps=num_steps, + guidance=guidance, + seed=seed, + ) + + if loop: + opts = parse_prompt(opts) + + while opts is not None: + if opts.seed is None: + opts.seed = rng.seed() + print(f"Generating with seed {opts.seed}:\n{opts.prompt}") + t0 = time.perf_counter() + + # prepare input + x = get_noise( + 1, + opts.height, + opts.width, + device=torch_device, + dtype=torch.bfloat16, + seed=opts.seed, + ) + opts.seed = None + if offload: + ae = ae.cpu() + torch.cuda.empty_cache() + t5, clip = t5.to(torch_device), clip.to(torch_device) + inp = prepare(t5, clip, x, prompt=opts.prompt) + timesteps = get_schedule(opts.num_steps, inp["img"].shape[1], shift=(name != "flux-schnell")) + + # offload TEs to CPU, load model to gpu + if offload: + t5, clip = t5.cpu(), clip.cpu() + torch.cuda.empty_cache() + model = model.to(torch_device) + + # denoise initial noise + x = denoise(model, **inp, timesteps=timesteps, guidance=opts.guidance) + + # offload model, load autoencoder to gpu + if offload: + model.cpu() + torch.cuda.empty_cache() + ae.decoder.to(x.device) + + # decode latents to pixel space + x = unpack(x.float(), opts.height, opts.width) + with torch.autocast(device_type=torch_device.type, dtype=torch.bfloat16): + x = ae.decode(x) + + if torch.cuda.is_available(): + torch.cuda.synchronize() + t1 = time.perf_counter() + + fn = output_name.format(idx=idx) + print(f"Done in {t1 - t0:.1f}s. Saving {fn}") + # bring into PIL format and save + x = x.clamp(-1, 1) + x = embed_watermark(x.float()) + x = rearrange(x[0], "c h w -> h w c") + + img = Image.fromarray((127.5 * (x + 1.0)).cpu().byte().numpy()) + nsfw_score = [x["score"] for x in nsfw_classifier(img) if x["label"] == "nsfw"][0] + + if nsfw_score < NSFW_THRESHOLD: + exif_data = Image.Exif() + exif_data[ExifTags.Base.Software] = "AI generated;txt2img;flux" + exif_data[ExifTags.Base.Make] = "Black Forest Labs" + exif_data[ExifTags.Base.Model] = name + if add_sampling_metadata: + exif_data[ExifTags.Base.ImageDescription] = prompt + img.save(fn, exif=exif_data, quality=95, subsampling=0) + idx += 1 + else: + print("Your generated image may contain NSFW content.") + + if loop: + print("-" * 80) + opts = parse_prompt(opts) + else: + opts = None + + +def app(): + Fire(main) + + +if __name__ == "__main__": + app() diff --git a/concept_attention/flux/src/flux/math.py b/concept_attention/flux/src/flux/math.py new file mode 100644 index 0000000000000000000000000000000000000000..0156bb6a205dec340e029f0c87cf70ae8709ae12 --- /dev/null +++ b/concept_attention/flux/src/flux/math.py @@ -0,0 +1,30 @@ +import torch +from einops import rearrange +from torch import Tensor + + +def attention(q: Tensor, k: Tensor, v: Tensor, pe: Tensor) -> Tensor: + q, k = apply_rope(q, k, pe) + + x = torch.nn.functional.scaled_dot_product_attention(q, k, v) + x = rearrange(x, "B H L D -> B L (H D)") + + return x + + +def rope(pos: Tensor, dim: int, theta: int) -> Tensor: + assert dim % 2 == 0 + scale = torch.arange(0, dim, 2, dtype=torch.float64, device=pos.device) / dim + omega = 1.0 / (theta**scale) + out = torch.einsum("...n,d->...nd", pos, omega) + out = torch.stack([torch.cos(out), -torch.sin(out), torch.sin(out), torch.cos(out)], dim=-1) + out = rearrange(out, "b n d (i j) -> b n d i j", i=2, j=2) + return out.float() + + +def apply_rope(xq: Tensor, xk: Tensor, freqs_cis: Tensor) -> tuple[Tensor, Tensor]: + xq_ = xq.float().reshape(*xq.shape[:-1], -1, 1, 2) + xk_ = xk.float().reshape(*xk.shape[:-1], -1, 1, 2) + xq_out = freqs_cis[..., 0] * xq_[..., 0] + freqs_cis[..., 1] * xq_[..., 1] + xk_out = freqs_cis[..., 0] * xk_[..., 0] + freqs_cis[..., 1] * xk_[..., 1] + return xq_out.reshape(*xq.shape).type_as(xq), xk_out.reshape(*xk.shape).type_as(xk) diff --git a/concept_attention/flux/src/flux/model.py b/concept_attention/flux/src/flux/model.py new file mode 100644 index 0000000000000000000000000000000000000000..37021a41c6e20ad649dd80a80f415538eb53d89e --- /dev/null +++ b/concept_attention/flux/src/flux/model.py @@ -0,0 +1,112 @@ +from dataclasses import dataclass + +import torch +from torch import Tensor, nn + +from concept_attention.flux.src.flux.modules.layers import (DoubleStreamBlock, EmbedND, LastLayer, + MLPEmbedder, SingleStreamBlock, + timestep_embedding) + + +@dataclass +class FluxParams: + in_channels: int + vec_in_dim: int + context_in_dim: int + hidden_size: int + mlp_ratio: float + num_heads: int + depth: int + depth_single_blocks: int + axes_dim: list[int] + theta: int + qkv_bias: bool + guidance_embed: bool + + +class Flux(nn.Module): + """ + Transformer model for flow matching on sequences. + """ + + def __init__(self, params: FluxParams): + super().__init__() + + self.params = params + self.in_channels = params.in_channels + self.out_channels = self.in_channels + if params.hidden_size % params.num_heads != 0: + raise ValueError( + f"Hidden size {params.hidden_size} must be divisible by num_heads {params.num_heads}" + ) + pe_dim = params.hidden_size // params.num_heads + if sum(params.axes_dim) != pe_dim: + raise ValueError(f"Got {params.axes_dim} but expected positional dim {pe_dim}") + self.hidden_size = params.hidden_size + self.num_heads = params.num_heads + self.pe_embedder = EmbedND(dim=pe_dim, theta=params.theta, axes_dim=params.axes_dim) + self.img_in = nn.Linear(self.in_channels, self.hidden_size, bias=True) + self.time_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size) + self.vector_in = MLPEmbedder(params.vec_in_dim, self.hidden_size) + self.guidance_in = ( + MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size) if params.guidance_embed else nn.Identity() + ) + self.txt_in = nn.Linear(params.context_in_dim, self.hidden_size) + + self.double_blocks = nn.ModuleList( + [ + DoubleStreamBlock( + self.hidden_size, + self.num_heads, + mlp_ratio=params.mlp_ratio, + qkv_bias=params.qkv_bias, + ) + for _ in range(params.depth) + ] + ) + + self.single_blocks = nn.ModuleList( + [ + SingleStreamBlock(self.hidden_size, self.num_heads, mlp_ratio=params.mlp_ratio) + for _ in range(params.depth_single_blocks) + ] + ) + + self.final_layer = LastLayer(self.hidden_size, 1, self.out_channels) + + def forward( + self, + img: Tensor, + img_ids: Tensor, + txt: Tensor, + txt_ids: Tensor, + timesteps: Tensor, + y: Tensor, + guidance: Tensor | None = None, + ) -> Tensor: + if img.ndim != 3 or txt.ndim != 3: + raise ValueError("Input img and txt tensors must have 3 dimensions.") + + # running on sequences img + img = self.img_in(img) + vec = self.time_in(timestep_embedding(timesteps, 256)) + if self.params.guidance_embed: + if guidance is None: + raise ValueError("Didn't get guidance strength for guidance distilled model.") + vec = vec + self.guidance_in(timestep_embedding(guidance, 256)) + vec = vec + self.vector_in(y) + txt = self.txt_in(txt) + + ids = torch.cat((txt_ids, img_ids), dim=1) + pe = self.pe_embedder(ids) + + for block in self.double_blocks: + img, txt = block(img=img, txt=txt, vec=vec, pe=pe) + + img = torch.cat((txt, img), 1) + for block in self.single_blocks: + img = block(img, vec=vec, pe=pe) + img = img[:, txt.shape[1] :, ...] + + img = self.final_layer(img, vec) # (N, T, patch_size ** 2 * out_channels) + return img diff --git a/concept_attention/flux/src/flux/modules/autoencoder.py b/concept_attention/flux/src/flux/modules/autoencoder.py new file mode 100644 index 0000000000000000000000000000000000000000..75159f711f65f064107a1a1b9be6f09fc9872028 --- /dev/null +++ b/concept_attention/flux/src/flux/modules/autoencoder.py @@ -0,0 +1,312 @@ +from dataclasses import dataclass + +import torch +from einops import rearrange +from torch import Tensor, nn + + +@dataclass +class AutoEncoderParams: + resolution: int + in_channels: int + ch: int + out_ch: int + ch_mult: list[int] + num_res_blocks: int + z_channels: int + scale_factor: float + shift_factor: float + + +def swish(x: Tensor) -> Tensor: + return x * torch.sigmoid(x) + + +class AttnBlock(nn.Module): + def __init__(self, in_channels: int): + super().__init__() + self.in_channels = in_channels + + self.norm = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1) + self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1) + self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1) + self.proj_out = nn.Conv2d(in_channels, in_channels, kernel_size=1) + + def attention(self, h_: Tensor) -> Tensor: + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + b, c, h, w = q.shape + q = rearrange(q, "b c h w -> b 1 (h w) c").contiguous() + k = rearrange(k, "b c h w -> b 1 (h w) c").contiguous() + v = rearrange(v, "b c h w -> b 1 (h w) c").contiguous() + h_ = nn.functional.scaled_dot_product_attention(q, k, v) + + return rearrange(h_, "b 1 (h w) c -> b c h w", h=h, w=w, c=c, b=b) + + def forward(self, x: Tensor) -> Tensor: + return x + self.proj_out(self.attention(x)) + + +class ResnetBlock(nn.Module): + def __init__(self, in_channels: int, out_channels: int): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + + self.norm1 = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1) + self.norm2 = nn.GroupNorm(num_groups=32, num_channels=out_channels, eps=1e-6, affine=True) + self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1) + if self.in_channels != self.out_channels: + self.nin_shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0) + + def forward(self, x): + h = x + h = self.norm1(h) + h = swish(h) + h = self.conv1(h) + + h = self.norm2(h) + h = swish(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + x = self.nin_shortcut(x) + + return x + h + + +class Downsample(nn.Module): + def __init__(self, in_channels: int): + super().__init__() + # no asymmetric padding in torch conv, must do it ourselves + self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0) + + def forward(self, x: Tensor): + pad = (0, 1, 0, 1) + x = nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + return x + + +class Upsample(nn.Module): + def __init__(self, in_channels: int): + super().__init__() + self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1) + + def forward(self, x: Tensor): + x = nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + x = self.conv(x) + return x + + +class Encoder(nn.Module): + def __init__( + self, + resolution: int, + in_channels: int, + ch: int, + ch_mult: list[int], + num_res_blocks: int, + z_channels: int, + ): + super().__init__() + self.ch = ch + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + # downsampling + self.conv_in = nn.Conv2d(in_channels, self.ch, kernel_size=3, stride=1, padding=1) + + curr_res = resolution + in_ch_mult = (1,) + tuple(ch_mult) + self.in_ch_mult = in_ch_mult + self.down = nn.ModuleList() + block_in = self.ch + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch * in_ch_mult[i_level] + block_out = ch * ch_mult[i_level] + for _ in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, out_channels=block_out)) + block_in = block_out + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions - 1: + down.downsample = Downsample(block_in) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in) + + # end + self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True) + self.conv_out = nn.Conv2d(block_in, 2 * z_channels, kernel_size=3, stride=1, padding=1) + + def forward(self, x: Tensor) -> Tensor: + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1]) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions - 1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h) + h = self.mid.attn_1(h) + h = self.mid.block_2(h) + # end + h = self.norm_out(h) + h = swish(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__( + self, + ch: int, + out_ch: int, + ch_mult: list[int], + num_res_blocks: int, + in_channels: int, + resolution: int, + z_channels: int, + ): + super().__init__() + self.ch = ch + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.ffactor = 2 ** (self.num_resolutions - 1) + + # compute in_ch_mult, block_in and curr_res at lowest res + block_in = ch * ch_mult[self.num_resolutions - 1] + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.z_shape = (1, z_channels, curr_res, curr_res) + + # z to block_in + self.conv_in = nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch * ch_mult[i_level] + for _ in range(self.num_res_blocks + 1): + block.append(ResnetBlock(in_channels=block_in, out_channels=block_out)) + block_in = block_out + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True) + self.conv_out = nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1) + + def forward(self, z: Tensor) -> Tensor: + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h) + h = self.mid.attn_1(h) + h = self.mid.block_2(h) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.up[i_level].block[i_block](h) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = swish(h) + h = self.conv_out(h) + return h + + +class DiagonalGaussian(nn.Module): + def __init__(self, sample: bool = True, chunk_dim: int = 1): + super().__init__() + self.sample = sample + self.chunk_dim = chunk_dim + + def forward(self, z: Tensor) -> Tensor: + mean, logvar = torch.chunk(z, 2, dim=self.chunk_dim) + if self.sample: + std = torch.exp(0.5 * logvar) + return mean + std * torch.randn_like(mean) + else: + return mean + + +class AutoEncoder(nn.Module): + def __init__(self, params: AutoEncoderParams): + super().__init__() + self.encoder = Encoder( + resolution=params.resolution, + in_channels=params.in_channels, + ch=params.ch, + ch_mult=params.ch_mult, + num_res_blocks=params.num_res_blocks, + z_channels=params.z_channels, + ) + self.decoder = Decoder( + resolution=params.resolution, + in_channels=params.in_channels, + ch=params.ch, + out_ch=params.out_ch, + ch_mult=params.ch_mult, + num_res_blocks=params.num_res_blocks, + z_channels=params.z_channels, + ) + self.reg = DiagonalGaussian() + + self.scale_factor = params.scale_factor + self.shift_factor = params.shift_factor + + def encode(self, x: Tensor) -> Tensor: + z = self.reg(self.encoder(x)) + z = self.scale_factor * (z - self.shift_factor) + return z + + def decode(self, z: Tensor) -> Tensor: + z = z / self.scale_factor + self.shift_factor + return self.decoder(z) + + def forward(self, x: Tensor) -> Tensor: + return self.decode(self.encode(x)) diff --git a/concept_attention/flux/src/flux/modules/conditioner.py b/concept_attention/flux/src/flux/modules/conditioner.py new file mode 100644 index 0000000000000000000000000000000000000000..7cdd881878ace848745da7d723c60f03392916ab --- /dev/null +++ b/concept_attention/flux/src/flux/modules/conditioner.py @@ -0,0 +1,38 @@ +from torch import Tensor, nn +from transformers import (CLIPTextModel, CLIPTokenizer, T5EncoderModel, + T5Tokenizer) + + +class HFEmbedder(nn.Module): + def __init__(self, version: str, max_length: int, **hf_kwargs): + super().__init__() + self.is_clip = version.startswith("openai") + self.max_length = max_length + self.output_key = "pooler_output" if self.is_clip else "last_hidden_state" + + if self.is_clip: + self.tokenizer: CLIPTokenizer = CLIPTokenizer.from_pretrained(version, max_length=max_length) + self.hf_module: CLIPTextModel = CLIPTextModel.from_pretrained(version, **hf_kwargs) + else: + self.tokenizer: T5Tokenizer = T5Tokenizer.from_pretrained(version, max_length=max_length) + self.hf_module: T5EncoderModel = T5EncoderModel.from_pretrained(version, **hf_kwargs) + + self.hf_module = self.hf_module.eval().requires_grad_(False) + + def forward(self, text: list[str]) -> Tensor: + batch_encoding = self.tokenizer( + text, + truncation=True, + max_length=self.max_length, + return_length=False, + return_overflowing_tokens=False, + padding="max_length", + return_tensors="pt", + ) + + outputs = self.hf_module( + input_ids=batch_encoding["input_ids"].to(self.hf_module.device), + attention_mask=None, + output_hidden_states=False, + ) + return outputs[self.output_key] diff --git a/concept_attention/flux/src/flux/modules/layers.py b/concept_attention/flux/src/flux/modules/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..1c197703d47d0d9bba13163f607cff3db56db127 --- /dev/null +++ b/concept_attention/flux/src/flux/modules/layers.py @@ -0,0 +1,253 @@ +import math +from dataclasses import dataclass + +import torch +from einops import rearrange +from torch import Tensor, nn + +from concept_attention.flux.src.flux.math import attention, rope + + +class EmbedND(nn.Module): + def __init__(self, dim: int, theta: int, axes_dim: list[int]): + super().__init__() + self.dim = dim + self.theta = theta + self.axes_dim = axes_dim + + def forward(self, ids: Tensor) -> Tensor: + n_axes = ids.shape[-1] + emb = torch.cat( + [rope(ids[..., i], self.axes_dim[i], self.theta) for i in range(n_axes)], + dim=-3, + ) + + return emb.unsqueeze(1) + + +def timestep_embedding(t: Tensor, dim, max_period=10000, time_factor: float = 1000.0): + """ + Create sinusoidal timestep embeddings. + :param t: a 1-D Tensor of N indices, one per batch element. + These may be fractional. + :param dim: the dimension of the output. + :param max_period: controls the minimum frequency of the embeddings. + :return: an (N, D) Tensor of positional embeddings. + """ + t = time_factor * t + half = dim // 2 + freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half).to( + t.device + ) + + args = t[:, None].float() * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) + if torch.is_floating_point(t): + embedding = embedding.to(t) + return embedding + + +class MLPEmbedder(nn.Module): + def __init__(self, in_dim: int, hidden_dim: int): + super().__init__() + self.in_layer = nn.Linear(in_dim, hidden_dim, bias=True) + self.silu = nn.SiLU() + self.out_layer = nn.Linear(hidden_dim, hidden_dim, bias=True) + + def forward(self, x: Tensor) -> Tensor: + return self.out_layer(self.silu(self.in_layer(x))) + + +class RMSNorm(torch.nn.Module): + def __init__(self, dim: int): + super().__init__() + self.scale = nn.Parameter(torch.ones(dim)) + + def forward(self, x: Tensor): + x_dtype = x.dtype + x = x.float() + rrms = torch.rsqrt(torch.mean(x**2, dim=-1, keepdim=True) + 1e-6) + return (x * rrms).to(dtype=x_dtype) * self.scale + + +class QKNorm(torch.nn.Module): + def __init__(self, dim: int): + super().__init__() + self.query_norm = RMSNorm(dim) + self.key_norm = RMSNorm(dim) + + def forward(self, q: Tensor, k: Tensor, v: Tensor) -> tuple[Tensor, Tensor]: + q = self.query_norm(q) + k = self.key_norm(k) + return q.to(v), k.to(v) + + +class SelfAttention(nn.Module): + def __init__(self, dim: int, num_heads: int = 8, qkv_bias: bool = False): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.norm = QKNorm(head_dim) + self.proj = nn.Linear(dim, dim) + + def forward(self, x: Tensor, pe: Tensor) -> Tensor: + qkv = self.qkv(x) + q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + q, k = self.norm(q, k, v) + x = attention(q, k, v, pe=pe) + x = self.proj(x) + return x + + +@dataclass +class ModulationOut: + shift: Tensor + scale: Tensor + gate: Tensor + + +class Modulation(nn.Module): + def __init__(self, dim: int, double: bool): + super().__init__() + self.is_double = double + self.multiplier = 6 if double else 3 + self.lin = nn.Linear(dim, self.multiplier * dim, bias=True) + + def forward(self, vec: Tensor) -> tuple[ModulationOut, ModulationOut | None]: + out = self.lin(nn.functional.silu(vec))[:, None, :].chunk(self.multiplier, dim=-1) + + return ( + ModulationOut(*out[:3]), + ModulationOut(*out[3:]) if self.is_double else None, + ) + + +class DoubleStreamBlock(nn.Module): + def __init__(self, hidden_size: int, num_heads: int, mlp_ratio: float, qkv_bias: bool = False): + super().__init__() + + mlp_hidden_dim = int(hidden_size * mlp_ratio) + self.num_heads = num_heads + self.hidden_size = hidden_size + self.img_mod = Modulation(hidden_size, double=True) + self.img_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.img_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias) + + self.img_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.img_mlp = nn.Sequential( + nn.Linear(hidden_size, mlp_hidden_dim, bias=True), + nn.GELU(approximate="tanh"), + nn.Linear(mlp_hidden_dim, hidden_size, bias=True), + ) + + self.txt_mod = Modulation(hidden_size, double=True) + self.txt_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.txt_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias) + + self.txt_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.txt_mlp = nn.Sequential( + nn.Linear(hidden_size, mlp_hidden_dim, bias=True), + nn.GELU(approximate="tanh"), + nn.Linear(mlp_hidden_dim, hidden_size, bias=True), + ) + + def forward(self, img: Tensor, txt: Tensor, vec: Tensor, pe: Tensor) -> tuple[Tensor, Tensor]: + img_mod1, img_mod2 = self.img_mod(vec) + txt_mod1, txt_mod2 = self.txt_mod(vec) + + # prepare image for attention + img_modulated = self.img_norm1(img) + img_modulated = (1 + img_mod1.scale) * img_modulated + img_mod1.shift + img_qkv = self.img_attn.qkv(img_modulated) + img_q, img_k, img_v = rearrange(img_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + img_q, img_k = self.img_attn.norm(img_q, img_k, img_v) + + # prepare txt for attention + txt_modulated = self.txt_norm1(txt) + txt_modulated = (1 + txt_mod1.scale) * txt_modulated + txt_mod1.shift + txt_qkv = self.txt_attn.qkv(txt_modulated) + txt_q, txt_k, txt_v = rearrange(txt_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + txt_q, txt_k = self.txt_attn.norm(txt_q, txt_k, txt_v) + + # run actual attention + q = torch.cat((txt_q, img_q), dim=2) + k = torch.cat((txt_k, img_k), dim=2) + v = torch.cat((txt_v, img_v), dim=2) + + attn = attention(q, k, v, pe=pe) + txt_attn, img_attn = attn[:, : txt.shape[1]], attn[:, txt.shape[1] :] + + # calculate the img bloks + img = img + img_mod1.gate * self.img_attn.proj(img_attn) + img = img + img_mod2.gate * self.img_mlp((1 + img_mod2.scale) * self.img_norm2(img) + img_mod2.shift) + + # calculate the txt bloks + txt = txt + txt_mod1.gate * self.txt_attn.proj(txt_attn) + txt = txt + txt_mod2.gate * self.txt_mlp((1 + txt_mod2.scale) * self.txt_norm2(txt) + txt_mod2.shift) + return img, txt + + +class SingleStreamBlock(nn.Module): + """ + A DiT block with parallel linear layers as described in + https://arxiv.org/abs/2302.05442 and adapted modulation interface. + """ + + def __init__( + self, + hidden_size: int, + num_heads: int, + mlp_ratio: float = 4.0, + qk_scale: float | None = None, + ): + super().__init__() + self.hidden_dim = hidden_size + self.num_heads = num_heads + head_dim = hidden_size // num_heads + self.scale = qk_scale or head_dim**-0.5 + + self.mlp_hidden_dim = int(hidden_size * mlp_ratio) + # qkv and mlp_in + self.linear1 = nn.Linear(hidden_size, hidden_size * 3 + self.mlp_hidden_dim) + # proj and mlp_out + self.linear2 = nn.Linear(hidden_size + self.mlp_hidden_dim, hidden_size) + + self.norm = QKNorm(head_dim) + + self.hidden_size = hidden_size + self.pre_norm = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + + self.mlp_act = nn.GELU(approximate="tanh") + self.modulation = Modulation(hidden_size, double=False) + + def forward(self, x: Tensor, vec: Tensor, pe: Tensor) -> Tensor: + mod, _ = self.modulation(vec) + x_mod = (1 + mod.scale) * self.pre_norm(x) + mod.shift + qkv, mlp = torch.split(self.linear1(x_mod), [3 * self.hidden_size, self.mlp_hidden_dim], dim=-1) + + q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + q, k = self.norm(q, k, v) + + # compute attention + attn = attention(q, k, v, pe=pe) + # compute activation in mlp stream, cat again and run second linear layer + output = self.linear2(torch.cat((attn, self.mlp_act(mlp)), 2)) + return x + mod.gate * output + + +class LastLayer(nn.Module): + def __init__(self, hidden_size: int, patch_size: int, out_channels: int): + super().__init__() + self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True) + self.adaLN_modulation = nn.Sequential(nn.SiLU(), nn.Linear(hidden_size, 2 * hidden_size, bias=True)) + + def forward(self, x: Tensor, vec: Tensor) -> Tensor: + shift, scale = self.adaLN_modulation(vec).chunk(2, dim=1) + x = (1 + scale[:, None, :]) * self.norm_final(x) + shift[:, None, :] + x = self.linear(x) + return x diff --git a/concept_attention/flux/src/flux/sampling.py b/concept_attention/flux/src/flux/sampling.py new file mode 100644 index 0000000000000000000000000000000000000000..aa1b04b9bcc06a06f3d84af81972136983d5a07c --- /dev/null +++ b/concept_attention/flux/src/flux/sampling.py @@ -0,0 +1,157 @@ +import math +from typing import Callable + +from tqdm import tqdm +import torch +from einops import rearrange, repeat +from torch import Tensor + +from .model import Flux +from .modules.conditioner import HFEmbedder + +def get_noise( + num_samples: int, + height: int, + width: int, + device: torch.device, + dtype: torch.dtype, + seed: int, +): + return torch.randn( + num_samples, + 16, + # allow for packing + 2 * math.ceil(height / 16), + 2 * math.ceil(width / 16), + device=device, + dtype=dtype, + generator=torch.Generator(device=device).manual_seed(seed), + ) + +def prepare(t5: HFEmbedder, clip: HFEmbedder, img: Tensor, prompt: str | list[str], restrict_clip_guidance=False) -> dict[str, Tensor]: + bs, c, h, w = img.shape + if bs == 1 and not isinstance(prompt, str): + bs = len(prompt) + + img = rearrange(img, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=2, pw=2) + if img.shape[0] == 1 and bs > 1: + img = repeat(img, "1 ... -> bs ...", bs=bs) + + img_ids = torch.zeros(h // 2, w // 2, 3) + img_ids[..., 1] = img_ids[..., 1] + torch.arange(h // 2)[:, None] + img_ids[..., 2] = img_ids[..., 2] + torch.arange(w // 2)[None, :] + img_ids = repeat(img_ids, "h w c -> b (h w) c", b=bs) + + if isinstance(prompt, str): + prompt = [prompt] + txt = t5(prompt) + if txt.shape[0] == 1 and bs > 1: + txt = repeat(txt, "1 ... -> bs ...", bs=bs) + txt_ids = torch.zeros(bs, txt.shape[1], 3) + + if restrict_clip_guidance: + vec = clip("") + else: + vec = clip(prompt) + if vec.shape[0] == 1 and bs > 1: + vec = repeat(vec, "1 ... -> bs ...", bs=bs) + + return { + "img": img, + "img_ids": img_ids.to(img.device), + "txt": txt.to(img.device), + "txt_ids": txt_ids.to(img.device), + "vec": vec.to(img.device), + } + +def time_shift(mu: float, sigma: float, t: Tensor): + return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma) + +def get_lin_function( + x1: float = 256, y1: float = 0.5, x2: float = 4096, y2: float = 1.15 +) -> Callable[[float], float]: + m = (y2 - y1) / (x2 - x1) + b = y1 - m * x1 + return lambda x: m * x + b + + +def get_schedule( + num_steps: int, + image_seq_len: int, + base_shift: float = 0.5, + max_shift: float = 1.15, + shift: bool = True, +) -> list[float]: + # extra step for zero + timesteps = torch.linspace(1, 0, num_steps + 1) + + # shifting the schedule to favor high timesteps for higher signal images + if shift: + # estimate mu based on linear estimation between two points + mu = get_lin_function(y1=base_shift, y2=max_shift)(image_seq_len) + timesteps = time_shift(mu, 1.0, timesteps) + + return timesteps.tolist() + +def denoise( + model: Flux, + # model input + img: Tensor, + img_ids: Tensor, + txt: Tensor, + txt_ids: Tensor, + vec: Tensor, + # sampling parameters + timesteps: list[float], + guidance: float = 4.0, + concepts: Tensor = None, + concept_ids: Tensor = None, + concept_vec: Tensor = None, + return_intermediate_images=True, + joint_attention_kwargs=None, +): + intermediate_images = [img] + all_cross_attention_maps = [] + all_concept_attention_maps = [] + # this is ignored for schnell + guidance_vec = torch.full((img.shape[0],), guidance, device=img.device, dtype=img.dtype) + iteration = 0 + for t_curr, t_prev in tqdm(zip(timesteps[:-1], timesteps[1:])): + t_vec = torch.full((img.shape[0],), t_curr, dtype=img.dtype, device=img.device) + pred, cross_attention_maps, concept_attention_maps = model( + img=img, + img_ids=img_ids, + txt=txt, + txt_ids=txt_ids, + concepts=concepts, + concept_ids=concept_ids, + concept_vec=concept_vec, + y=vec, + timesteps=t_vec, + guidance=guidance_vec, + iteration=iteration, + joint_attention_kwargs=joint_attention_kwargs + ) + + img = img + (t_prev - t_curr) * pred + intermediate_images.append(img) + # increment iteration + iteration += 1 + + all_cross_attention_maps.append(cross_attention_maps) + all_concept_attention_maps.append(concept_attention_maps) + + all_cross_attention_maps = torch.stack(all_cross_attention_maps, dim=0) + all_concept_attention_maps = torch.stack(all_concept_attention_maps, dim=0) + + return img, intermediate_images, all_cross_attention_maps, all_concept_attention_maps + +def unpack(x: Tensor, height: int, width: int) -> Tensor: + return rearrange( + x, + "b (h w) (c ph pw) -> b c (h ph) (w pw)", + h=math.ceil(height / 16), + w=math.ceil(width / 16), + ph=2, + pw=2, + ) diff --git a/concept_attention/flux/src/flux/util.py b/concept_attention/flux/src/flux/util.py new file mode 100644 index 0000000000000000000000000000000000000000..ef34db27c04ae19004daf4595b3a8369979a17df --- /dev/null +++ b/concept_attention/flux/src/flux/util.py @@ -0,0 +1,197 @@ +import os +from dataclasses import dataclass + +import torch +from einops import rearrange +from huggingface_hub import hf_hub_download +from imwatermark import WatermarkEncoder +from safetensors.torch import load_file as load_sft + +from concept_attention.flux.src.flux.model import Flux, FluxParams +from concept_attention.flux.src.flux.modules.autoencoder import AutoEncoder, AutoEncoderParams +from concept_attention.flux.src.flux.modules.conditioner import HFEmbedder + + +@dataclass +class ModelSpec: + params: FluxParams + ae_params: AutoEncoderParams + ckpt_path: str | None + ae_path: str | None + repo_id: str | None + repo_flow: str | None + repo_ae: str | None + + +configs = { + "flux-dev": ModelSpec( + repo_id="black-forest-labs/FLUX.1-dev", + repo_flow="flux1-dev.safetensors", + repo_ae="ae.safetensors", + ckpt_path=os.getenv("FLUX_DEV"), + params=FluxParams( + in_channels=64, + vec_in_dim=768, + context_in_dim=4096, + hidden_size=3072, + mlp_ratio=4.0, + num_heads=24, + depth=19, + depth_single_blocks=38, + axes_dim=[16, 56, 56], + theta=10_000, + qkv_bias=True, + guidance_embed=True, + ), + ae_path=os.getenv("AE"), + ae_params=AutoEncoderParams( + resolution=256, + in_channels=3, + ch=128, + out_ch=3, + ch_mult=[1, 2, 4, 4], + num_res_blocks=2, + z_channels=16, + scale_factor=0.3611, + shift_factor=0.1159, + ), + ), + "flux-schnell": ModelSpec( + repo_id="black-forest-labs/FLUX.1-schnell", + repo_flow="flux1-schnell.safetensors", + repo_ae="ae.safetensors", + ckpt_path=os.getenv("FLUX_SCHNELL"), + params=FluxParams( + in_channels=64, + vec_in_dim=768, + context_in_dim=4096, + hidden_size=3072, + mlp_ratio=4.0, + num_heads=24, + depth=19, + depth_single_blocks=38, + axes_dim=[16, 56, 56], + theta=10_000, + qkv_bias=True, + guidance_embed=False, + ), + ae_path=os.getenv("AE"), + ae_params=AutoEncoderParams( + resolution=256, + in_channels=3, + ch=128, + out_ch=3, + ch_mult=[1, 2, 4, 4], + num_res_blocks=2, + z_channels=16, + scale_factor=0.3611, + shift_factor=0.1159, + ), + ), +} + +def print_load_warning(missing: list[str], unexpected: list[str]) -> None: + if len(missing) > 0 and len(unexpected) > 0: + print(f"Got {len(missing)} missing keys:\n\t" + "\n\t".join(missing)) + print("\n" + "-" * 79 + "\n") + print(f"Got {len(unexpected)} unexpected keys:\n\t" + "\n\t".join(unexpected)) + elif len(missing) > 0: + print(f"Got {len(missing)} missing keys:\n\t" + "\n\t".join(missing)) + elif len(unexpected) > 0: + print(f"Got {len(unexpected)} unexpected keys:\n\t" + "\n\t".join(unexpected)) + +def load_flow_model(name: str, device: str | torch.device = "cuda", hf_download: bool = True): + # Loading Flux + print("Init model") + ckpt_path = configs[name].ckpt_path + if ( + ckpt_path is None + and configs[name].repo_id is not None + and configs[name].repo_flow is not None + and hf_download + ): + ckpt_path = hf_hub_download(configs[name].repo_id, configs[name].repo_flow) + + with torch.device("meta" if ckpt_path is not None else device): + model = Flux(configs[name].params).to(torch.bfloat16) + + if ckpt_path is not None: + print("Loading checkpoint") + # load_sft doesn't support torch.device + sd = load_sft(ckpt_path, device=str(device)) + missing, unexpected = model.load_state_dict(sd, strict=False, assign=True) + print_load_warning(missing, unexpected) + + return model + +def load_t5(device: str | torch.device = "cuda", max_length: int = 512) -> HFEmbedder: + # max length 64, 128, 256 and 512 should work (if your sequence is short enough) + return HFEmbedder("google/t5-v1_1-xxl", max_length=max_length, torch_dtype=torch.bfloat16).to(device) + +def load_clip(device: str | torch.device = "cuda") -> HFEmbedder: + return HFEmbedder("openai/clip-vit-large-patch14", max_length=77, torch_dtype=torch.bfloat16).to(device) + +def load_ae(name: str, device: str | torch.device = "cuda", hf_download: bool = True) -> AutoEncoder: + ckpt_path = configs[name].ae_path + if ( + ckpt_path is None + and configs[name].repo_id is not None + and configs[name].repo_ae is not None + and hf_download + ): + ckpt_path = hf_hub_download(configs[name].repo_id, configs[name].repo_ae) + + # Loading the autoencoder + print("Init AE") + with torch.device("meta" if ckpt_path is not None else device): + ae = AutoEncoder(configs[name].ae_params) + + if ckpt_path is not None: + sd = load_sft(ckpt_path, device=str(device)) + missing, unexpected = ae.load_state_dict(sd, strict=False, assign=True) + print_load_warning(missing, unexpected) + return ae + + +class WatermarkEmbedder: + def __init__(self, watermark): + self.watermark = watermark + self.num_bits = len(WATERMARK_BITS) + self.encoder = WatermarkEncoder() + self.encoder.set_watermark("bits", self.watermark) + + def __call__(self, image: torch.Tensor) -> torch.Tensor: + """ + Adds a predefined watermark to the input image + + Args: + image: ([N,] B, RGB, H, W) in range [-1, 1] + + Returns: + same as input but watermarked + """ + image = 0.5 * image + 0.5 + squeeze = len(image.shape) == 4 + if squeeze: + image = image[None, ...] + n = image.shape[0] + image_np = rearrange((255 * image).detach().cpu(), "n b c h w -> (n b) h w c").numpy()[:, :, :, ::-1] + # torch (b, c, h, w) in [0, 1] -> numpy (b, h, w, c) [0, 255] + # watermarking libary expects input as cv2 BGR format + for k in range(image_np.shape[0]): + image_np[k] = self.encoder.encode(image_np[k], "dwtDct") + image = torch.from_numpy(rearrange(image_np[:, :, :, ::-1], "(n b) h w c -> n b c h w", n=n)).to( + image.device + ) + image = torch.clamp(image / 255, min=0.0, max=1.0) + if squeeze: + image = image[0] + image = 2 * image - 1 + return image + + +# A fixed 48-bit message that was chosen at random +WATERMARK_MESSAGE = 0b001010101111111010000111100111001111010100101110 +# bin(x)[2:] gives bits of x as str, use int to convert them to 0/1 +WATERMARK_BITS = [int(bit) for bit in bin(WATERMARK_MESSAGE)[2:]] +embed_watermark = WatermarkEmbedder(WATERMARK_BITS) diff --git a/concept_attention/image_generator.py b/concept_attention/image_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..7be4ad6aef1df63fcea7c3843e7c44ff677251d0 --- /dev/null +++ b/concept_attention/image_generator.py @@ -0,0 +1,206 @@ +import torch +from PIL import Image +import time +import numpy as np +from einops import rearrange +from transformers import pipeline + +from concept_attention.flux.src.flux.cli import SamplingOptions +from concept_attention.flux.src.flux.sampling import denoise, get_noise, get_schedule, prepare, unpack +from concept_attention.flux.src.flux.util import configs, embed_watermark, load_ae, load_clip, load_t5 + +from huggingface_hub import hf_hub_download +from safetensors.torch import load_file as load_sft + +from concept_attention.modified_double_stream_block import ModifiedDoubleStreamBlock +from concept_attention.modified_flux_dit import ModifiedFluxDiT +from concept_attention.utils import embed_concepts + +def load_flow_model( + name: str, + device: str | torch.device = "cuda", + hf_download: bool = True, + attention_block_class=ModifiedDoubleStreamBlock, + dit_class=ModifiedFluxDiT +): + # Loading Flux + print("Init model") + ckpt_path = configs[name].ckpt_path + if ( + ckpt_path is None + and configs[name].repo_id is not None + and configs[name].repo_flow is not None + and hf_download + ): + ckpt_path = hf_hub_download(configs[name].repo_id, configs[name].repo_flow) + + with torch.device("meta" if ckpt_path is not None else device): + model = dit_class(configs[name].params, attention_block_class=attention_block_class).to(torch.bfloat16) + + if ckpt_path is not None: + print("Loading checkpoint") + # load_sft doesn't support torch.device + sd = load_sft(ckpt_path, device=str(device)) + missing, unexpected = model.load_state_dict(sd, strict=False, assign=True) + # print_load_warning(missing, unexpected) + + return model + +def get_models( + name: str, + device: torch.device, + offload: bool, + is_schnell: bool, + attention_block_class=ModifiedDoubleStreamBlock, + dit_class=ModifiedFluxDiT +): + t5 = load_t5(device, max_length=256 if is_schnell else 512) + clip = load_clip(device) + model = load_flow_model(name, device="cpu" if offload else device, attention_block_class=attention_block_class, dit_class=dit_class) + ae = load_ae(name, device="cpu" if offload else device) + # nsfw_classifier = pipeline("image-classification", model="Falconsai/nsfw_image_detection", device=device) + return model, ae, t5, clip, None + +class FluxGenerator(): + + def __init__( + self, + model_name: str, + device: str, + offload: bool, + attention_block_class=ModifiedDoubleStreamBlock, + dit_class=ModifiedFluxDiT + ): + self.device = torch.device(device) + self.offload = offload + self.model_name = model_name + self.is_schnell = model_name == "flux-schnell" + self.model, self.ae, self.t5, self.clip, self.nsfw_classifier = get_models( + model_name, + device=self.device, + offload=self.offload, + is_schnell=self.is_schnell, + attention_block_class=attention_block_class, + dit_class=dit_class + ) + + @torch.inference_mode() + def generate_image( + self, + width, + height, + num_steps, + guidance, + seed, + prompt, + concepts, + init_image=None, + image2image_strength=0.0, + add_sampling_metadata=True, + restrict_clip_guidance=False, + joint_attention_kwargs=None, + ): + seed = int(seed) + if seed == -1: + seed = None + + opts = SamplingOptions( + prompt=prompt, + width=width, + height=height, + num_steps=num_steps, + guidance=guidance, + seed=seed, + ) + + if opts.seed is None: + opts.seed = torch.Generator(device="cpu").seed() + print(f"Generating '{opts.prompt}' with seed {opts.seed}") + t0 = time.perf_counter() + + if init_image is not None: + if isinstance(init_image, np.ndarray): + init_image = torch.from_numpy(init_image).permute(2, 0, 1).float() / 255.0 + init_image = init_image.unsqueeze(0) + init_image = init_image.to(self.device) + init_image = torch.nn.functional.interpolate(init_image, (opts.height, opts.width)) + if self.offload: + self.ae.encoder.to(self.device) + init_image = self.ae.encode(init_image.to()) + if self.offload: + self.ae = self.ae.cpu() + torch.cuda.empty_cache() + + # prepare input + x = get_noise( + 1, + opts.height, + opts.width, + device=self.device, + dtype=torch.bfloat16, + seed=opts.seed, + ) + timesteps = get_schedule( + opts.num_steps, + x.shape[-1] * x.shape[-2] // 4, + shift=(not self.is_schnell), + ) + if init_image is not None: + t_idx = int((1 - image2image_strength) * num_steps) + t = timesteps[t_idx] + timesteps = timesteps[t_idx:] + x = t * x + (1.0 - t) * init_image.to(x.dtype) + + if self.offload: + self.t5, self.clip = self.t5.to(self.device), self.clip.to(self.device) + inp = prepare(t5=self.t5, clip=self.clip, img=x, prompt=opts.prompt, restrict_clip_guidance=restrict_clip_guidance) + + ############ Encode the concept ############ + concept_embeddings, concept_ids, concept_vec = embed_concepts( + self.clip, + self.t5, + concepts, + ) + inp["concepts"] = concept_embeddings.to(x.device) + inp["concept_ids"] = concept_ids.to(x.device) + inp["concept_vec"] = concept_vec.to(x.device) + ########################################### + # offload TEs to CPU, load model to gpu + if self.offload: + self.t5, self.clip = self.t5.cpu(), self.clip.cpu() + torch.cuda.empty_cache() + self.model = self.model.to(self.device) + # denoise initial noise + x, intermediate_images, cross_attention_maps, concept_attention_maps = denoise( + self.model, + **inp, + timesteps=timesteps, + guidance=opts.guidance, + joint_attention_kwargs=joint_attention_kwargs + ) + # offload model, load autoencoder to gpu + if self.offload: + self.model.cpu() + torch.cuda.empty_cache() + self.ae.decoder.to(x.device) + + # decode latents to pixel space + x = unpack(x.float(), opts.height, opts.width) + with torch.autocast(device_type=self.device.type, dtype=torch.bfloat16): + x = self.ae.decode(x) + + if self.offload: + self.ae.decoder.cpu() + torch.cuda.empty_cache() + + t1 = time.perf_counter() + + print(f"Done in {t1 - t0:.1f}s.") + # bring into PIL format + x = x.clamp(-1, 1) + x = embed_watermark(x.float()) + x = rearrange(x[0], "c h w -> h w c") + + img = Image.fromarray((127.5 * (x + 1.0)).cpu().byte().numpy()) + + return img, cross_attention_maps, concept_attention_maps \ No newline at end of file diff --git a/concept_attention/modified_double_stream_block.py b/concept_attention/modified_double_stream_block.py new file mode 100644 index 0000000000000000000000000000000000000000..bf897be305c75b9a2bcf7893e5bf1c9a9a38fa53 --- /dev/null +++ b/concept_attention/modified_double_stream_block.py @@ -0,0 +1,203 @@ +import torch +from torch import nn, Tensor +import einops +import math +import torch.nn.functional as F +import matplotlib.pyplot as plt + +from concept_attention.flux.src.flux.modules.layers import Modulation, SelfAttention +from concept_attention.flux.src.flux.math import apply_rope + + +def attention(q: Tensor, k: Tensor, v: Tensor, pe: Tensor) -> Tensor: + q, k = apply_rope(q, k, pe) + + x = scaled_dot_product_attention(q, k, v) + x = einops.rearrange(x, "B H L D -> B L (H D)") + + return x + +# Efficient implementation equivalent to the following: +def scaled_dot_product_attention( + query, + key, + value, + attn_mask=None +) -> torch.Tensor: + L, S = query.size(-2), key.size(-2) + scale_factor = 1 / math.sqrt(query.size(-1)) + attn_bias = torch.zeros(L, S, dtype=query.dtype).to(query.device) + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_bias.masked_fill_(attn_mask.logical_not(), float("-inf")) + else: + attn_bias += attn_mask + + attn_weight = query @ key.transpose(-2, -1) * scale_factor + attn_weight += attn_bias + attn_weight = torch.softmax(attn_weight, dim=-1) + + return attn_weight @ value + +class ModifiedDoubleStreamBlock(nn.Module): + + def __init__(self, hidden_size: int, num_heads: int, mlp_ratio: float, qkv_bias: bool = False): + super().__init__() + mlp_hidden_dim = int(hidden_size * mlp_ratio) + self.num_heads = num_heads + self.hidden_size = hidden_size + self.img_mod = Modulation(hidden_size, double=True) + self.img_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.img_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias) + self.img_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.img_mlp = nn.Sequential( + nn.Linear(hidden_size, mlp_hidden_dim, bias=True), + nn.GELU(approximate="tanh"), + nn.Linear(mlp_hidden_dim, hidden_size, bias=True), + ) + self.txt_mod = Modulation(hidden_size, double=True) + self.txt_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.txt_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias) + self.txt_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.txt_mlp = nn.Sequential( + nn.Linear(hidden_size, mlp_hidden_dim, bias=True), + nn.GELU(approximate="tanh"), + nn.Linear(mlp_hidden_dim, hidden_size, bias=True), + ) + + @torch.no_grad() + def forward( + self, + img: Tensor, + txt: Tensor, + vec: Tensor, + pe: Tensor, + concepts: Tensor, + concept_vec: Tensor, + concept_pe: Tensor, + joint_attention_kwargs=None, + **kwargs + ) -> tuple[Tensor, Tensor]: + assert concept_vec is not None, "Concept vectors must be provided for this implementation." + img_mod1, img_mod2 = self.img_mod(vec) + txt_mod1, txt_mod2 = self.txt_mod(vec) + concept_mod1, concept_mod2 = self.txt_mod(concept_vec) + # Prepare image for attention + img_modulated = self.img_norm1(img) + img_modulated = (1 + img_mod1.scale) * img_modulated + img_mod1.shift + img_qkv = self.img_attn.qkv(img_modulated) + img_q, img_k, img_v = einops.rearrange(img_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + img_q, img_k = self.img_attn.norm(img_q, img_k, img_v) + # Prepare txt for attention + txt_modulated = self.txt_norm1(txt) + txt_modulated = (1 + txt_mod1.scale) * txt_modulated + txt_mod1.shift + txt_qkv = self.txt_attn.qkv(txt_modulated) + txt_q, txt_k, txt_v = einops.rearrange(txt_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + txt_q, txt_k = self.txt_attn.norm(txt_q, txt_k, txt_v) + # Prepare concepts for attention + concept_modulated = self.txt_norm1(concepts) + concept_modulated = (1 + concept_mod1.scale) * concept_modulated + concept_mod1.shift + concept_qkv = self.txt_attn.qkv(concept_modulated) + concept_q, concept_k, concept_v = einops.rearrange(concept_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + concept_q, concept_k = self.txt_attn.norm(concept_q, concept_k, concept_v) + ########## Do the text-image joint attention ########## + text_image_q = torch.cat((txt_q, img_q), dim=2) + text_image_k = torch.cat((txt_k, img_k), dim=2) + text_image_v = torch.cat((txt_v, img_v), dim=2) + # Apply rope + text_image_q, text_image_k = apply_rope(text_image_q, text_image_k, pe) + # Do the attention operation + text_image_attn = F.scaled_dot_product_attention( + text_image_q, + text_image_k, + text_image_v + ) + # Separate the text and image attentions + txt_attn = text_image_attn[:, :, :txt.shape[1]] + img_attn = text_image_attn[:, :, txt.shape[1]:] + ########## Do the concept-image joint attention ########## + concept_image_q = torch.cat((concept_q, img_q), dim=2) + concept_image_k = torch.cat((concept_k, img_k), dim=2) + concept_image_v = torch.cat((concept_v, img_v), dim=2) + # Apply rope + concept_image_q, concept_image_k = apply_rope(concept_image_q, concept_image_k, concept_pe) + if joint_attention_kwargs is not None: + concept_cross_attention = joint_attention_kwargs.get("concept_cross_attention", True) + concept_self_attention = joint_attention_kwargs.get("concept_self_attention", True) + if concept_cross_attention and not concept_self_attention: + # Do cross attention only between concepts and image + concept_only_q = concept_image_q[:, :, :concepts.shape[1]] + image_only_k = concept_image_k[:, :, concepts.shape[1]:] + # Do the attention operation + concept_attn = scaled_dot_product_attention( + concept_only_q, + image_only_k, + img_v + ) + elif concept_self_attention and not concept_cross_attention: + concept_q = concept_image_q[:, :, :concepts.shape[1]] + concept_k = concept_image_k[:, :, :concepts.shape[1]] + # Do the attention operation + concept_attn = scaled_dot_product_attention( + concept_q, + concept_k, + concept_v + ) + elif concept_cross_attention and concept_self_attention: + # Do the attention operation + concept_image_attn = F.scaled_dot_product_attention( + concept_image_q, + concept_image_k, + concept_image_v, + ) + # Separate the concept and image attentions + concept_attn = concept_image_attn[:, :, :concepts.shape[1]] + else: + # Neither self or cross. + concept_attn = concept_v + else: + # Do both cross and self attention + concept_image_attn = F.scaled_dot_product_attention( + concept_image_q, + concept_image_k, + concept_image_v, + ) + # Separate the concept and image attentions + concept_attn = concept_image_attn[:, :, :concepts.shape[1]] + + # Rearrange the attention tensors + txt_attn = einops.rearrange(txt_attn, "B H L D -> B L (H D)") + if joint_attention_kwargs is not None and joint_attention_kwargs.get("keep_head_dim", False): + concept_attn = einops.rearrange(concept_attn, "B H L D -> B L (H D)") + img_attn = einops.rearrange(img_attn, "B H L D -> B L (H D)") + else: + concept_attn = einops.rearrange(concept_attn, "B H L D -> B L (H D)") + img_attn = einops.rearrange(img_attn, "B H L D -> B L (H D)") + + # Compute the cross attentions + cross_attention_maps = einops.einsum( + concept_q, + img_q, + "batch head concepts dim, batch had patches dim -> batch head concepts patches" + ) + cross_attention_maps = einops.reduce(cross_attention_maps, "batch head concepts patches -> batch concepts patches", reduction="mean") + # Compute the concept attentions + concept_attention_maps = einops.einsum( + concept_attn, + img_attn, + "batch concepts dim, batch patches dim -> batch concepts patches" + ) + # Do the block updates + # Calculate the img blocks + img = img + img_mod1.gate * self.img_attn.proj(img_attn) + # Can I do the decomposition here? Using a basis formed by (img_mod1.gate * self.img_attn.proj(concepts)) + img = img + img_mod2.gate * self.img_mlp((1 + img_mod2.scale) * self.img_norm2(img) + img_mod2.shift) + # Calculate the txt blocks + txt = txt + txt_mod1.gate * self.txt_attn.proj(txt_attn) + txt = txt + txt_mod2.gate * self.txt_mlp((1 + txt_mod2.scale) * self.txt_norm2(txt) + txt_mod2.shift) + # Calculate the concept blocks + concepts = concepts + concept_mod1.gate * self.txt_attn.proj(concept_attn) + concepts = concepts + concept_mod2.gate * self.txt_mlp((1 + concept_mod2.scale) * self.txt_norm2(concepts) + concept_mod2.shift) + + return img, txt, concepts, cross_attention_maps, concept_attention_maps \ No newline at end of file diff --git a/concept_attention/modified_flux_dit.py b/concept_attention/modified_flux_dit.py new file mode 100644 index 0000000000000000000000000000000000000000..ec0988dcb835f9085bdee76bbf761848ba27f26c --- /dev/null +++ b/concept_attention/modified_flux_dit.py @@ -0,0 +1,157 @@ +from dataclasses import dataclass + +import torch +from torch import Tensor, nn + +from concept_attention.flux.src.flux.modules.layers import (DoubleStreamBlock, EmbedND, LastLayer, + MLPEmbedder, SingleStreamBlock, + timestep_embedding) + +from concept_attention.modified_double_stream_block import ModifiedDoubleStreamBlock +from concept_attention.modified_single_stream_block import ModifiedSingleStreamBlock + +@dataclass +class FluxParams: + in_channels: int + vec_in_dim: int + context_in_dim: int + hidden_size: int + mlp_ratio: float + num_heads: int + depth: int + depth_single_blocks: int + axes_dim: list[int] + theta: int + qkv_bias: bool + guidance_embed: bool + + +class ModifiedFluxDiT(nn.Module): + """ + Transformer model for flow matching on sequences. + """ + + def __init__(self, params: FluxParams, attention_block_class=ModifiedDoubleStreamBlock): + super().__init__() + + self.params = params + self.in_channels = params.in_channels + self.out_channels = self.in_channels + if params.hidden_size % params.num_heads != 0: + raise ValueError( + f"Hidden size {params.hidden_size} must be divisible by num_heads {params.num_heads}" + ) + pe_dim = params.hidden_size // params.num_heads + if sum(params.axes_dim) != pe_dim: + raise ValueError(f"Got {params.axes_dim} but expected positional dim {pe_dim}") + self.hidden_size = params.hidden_size + self.num_heads = params.num_heads + self.pe_embedder = EmbedND(dim=pe_dim, theta=params.theta, axes_dim=params.axes_dim) + self.img_in = nn.Linear(self.in_channels, self.hidden_size, bias=True) + self.time_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size) + self.vector_in = MLPEmbedder(params.vec_in_dim, self.hidden_size) + self.guidance_in = ( + MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size) if params.guidance_embed else nn.Identity() + ) + self.txt_in = nn.Linear(params.context_in_dim, self.hidden_size) + + self.double_blocks = nn.ModuleList([ + attention_block_class( + self.hidden_size, + self.num_heads, + mlp_ratio=params.mlp_ratio, + qkv_bias=params.qkv_bias, + ) + for _ in range(params.depth) + ]) + + self.single_blocks = nn.ModuleList([ + ModifiedSingleStreamBlock(self.hidden_size, self.num_heads, mlp_ratio=params.mlp_ratio) + for _ in range(params.depth_single_blocks) + ]) + + self.final_layer = LastLayer(self.hidden_size, 1, self.out_channels) + + def forward( + self, + img: Tensor, + img_ids: Tensor, + txt: Tensor, + txt_ids: Tensor, + concepts: Tensor, + concept_ids: Tensor, + concept_vec: Tensor, + timesteps: Tensor, + y: Tensor, + guidance: Tensor | None = None, + stop_after_multimodal_attentions: bool = False, + edit_metadata=None, + iteration=None, + joint_attention_kwargs=None, + **kwargs + ) -> Tensor: + assert concept_vec is not None, "Concept vectors must be provided for this implementation." + if img.ndim != 3 or txt.ndim != 3: + raise ValueError("Input img and txt tensors must have 3 dimensions.") + + # running on sequences img + img = self.img_in(img) + vec = self.time_in(timestep_embedding(timesteps, 256)) + if self.params.guidance_embed: + if guidance is None: + raise ValueError("Didn't get guidance strength for guidance distilled model.") + vec = vec + self.guidance_in(timestep_embedding(guidance, 256)) + vec = vec + self.vector_in(y) + txt = self.txt_in(txt) + + ids = torch.cat((txt_ids, img_ids), dim=1) + pe = self.pe_embedder(ids) + # Compute positional encodings + ids_with_concepts = torch.cat((concept_ids, img_ids), dim=1) + pe_with_concepts = self.pe_embedder(ids_with_concepts) + ################ Process concept vectors ################ + original_concept_vec = concept_vec + concept_vec = self.time_in(timestep_embedding(timesteps, 256)) + if self.params.guidance_embed: + if guidance is None: + raise ValueError("Didn't get guidance strength for guidance distilled model.") + concept_vec = concept_vec + self.guidance_in(timestep_embedding(guidance, 256)) + concept_vec = concept_vec + self.vector_in(original_concept_vec) + concepts = self.txt_in(concepts) + ############## Modify the double blocks to also return concept vectors ############## + all_cross_attention_maps = [] + all_concept_attention_maps = [] + for block in self.double_blocks: + img, txt, concepts, cross_attention_maps, concept_attention_maps = block( + img=img, + txt=txt, + vec=vec, + pe=pe, + concepts=concepts, + concept_vec=concept_vec, + concept_pe=pe_with_concepts, + edit_metadata=edit_metadata, + iteration=iteration, + joint_attention_kwargs=joint_attention_kwargs + ) + all_cross_attention_maps.append(cross_attention_maps) + all_concept_attention_maps.append(concept_attention_maps) + + all_concept_attention_maps = torch.stack(all_concept_attention_maps, dim=0) + all_cross_attention_maps = torch.stack(all_cross_attention_maps, dim=0) + ##################################################################################### + + img = torch.cat((txt, img), 1) + + # Speed up segmentation by not generating the full image + if stop_after_multimodal_attentions: + return None, all_cross_attention_maps, all_concept_attention_maps + + # Do the single blocks now + for block in self.single_blocks: + img = block(img, vec=vec, pe=pe) + + img = img[:, txt.shape[1] :, ...] + + img = self.final_layer(img, vec) # (N, T, patch_size ** 2 * out_channels) + return img, all_cross_attention_maps, all_concept_attention_maps diff --git a/concept_attention/modified_single_stream_block.py b/concept_attention/modified_single_stream_block.py new file mode 100644 index 0000000000000000000000000000000000000000..9de1f2100c67b9a35710c0eb62d4cf62c33a30fd --- /dev/null +++ b/concept_attention/modified_single_stream_block.py @@ -0,0 +1,56 @@ +import torch +from torch import nn, Tensor +from einops import rearrange + +from concept_attention.flux.src.flux.modules.layers import Modulation, QKNorm +from concept_attention.flux.src.flux.math import attention + +NUM_IMAGE_PATCHES = 4096 + +class ModifiedSingleStreamBlock(nn.Module): + """ + A DiT block with parallel linear layers as described in + https://arxiv.org/abs/2302.05442 and adapted modulation interface. + """ + + def __init__( + self, + hidden_size: int, + num_heads: int, + mlp_ratio: float = 4.0, + qk_scale: float | None = None + ): + super().__init__() + self.hidden_dim = hidden_size + self.num_heads = num_heads + head_dim = hidden_size // num_heads + self.scale = qk_scale or head_dim**-0.5 + + self.mlp_hidden_dim = int(hidden_size * mlp_ratio) + # qkv and mlp_in + self.linear1 = nn.Linear(hidden_size, hidden_size * 3 + self.mlp_hidden_dim) + # proj and mlp_out + self.linear2 = nn.Linear(hidden_size + self.mlp_hidden_dim, hidden_size) + + self.norm = QKNorm(head_dim) + + self.hidden_size = hidden_size + self.pre_norm = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + + self.mlp_act = nn.GELU(approximate="tanh") + self.modulation = Modulation(hidden_size, double=False) + + def forward(self, x: Tensor, vec: Tensor, pe: Tensor) -> Tensor: + mod, _ = self.modulation(vec) + + # Perform img-text self attention + x_mod = (1 + mod.scale) * self.pre_norm(x) + mod.shift + qkv, mlp = torch.split(self.linear1(x_mod), [3 * self.hidden_size, self.mlp_hidden_dim], dim=-1) + q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads) + q, k = self.norm(q, k, v) + # compute attention + attn = attention(q, k, v, pe=pe) + # compute activation in mlp stream, cat again and run second linear layer + output = self.linear2(torch.cat((attn, self.mlp_act(mlp)), 2)) + + return x + mod.gate * output diff --git a/concept_attention/plotting.py b/concept_attention/plotting.py new file mode 100644 index 0000000000000000000000000000000000000000..5abb5ef740d6c949f4f0ab89ee55391e0a74f55a --- /dev/null +++ b/concept_attention/plotting.py @@ -0,0 +1,178 @@ + +import torch +import torch.nn.functional as F +import einops +import matplotlib.pyplot as plt +import numpy as np + +def overlay_heatmap_on_image( + image, + heatmap: torch.Tensor, + save_path="results/heatmap_overlay.pdf", +): + """ + Overlay the given heatmap on the image + """ + if isinstance(heatmap, torch.Tensor): + heatmap = heatmap.to(torch.float32).detach().cpu().numpy() + assert len(heatmap.shape) == 2, "Heatmap should be 2D" + plt.figure() + plt.imshow(image) + # Upscale heatmap to image + heatmap = F.interpolate( + heatmap.unsqueeze(0).unsqueeze(0), + size=image.shape[:2], + mode="bilinear", + align_corners=False + ) + heatmap = heatmap.squeeze(0).squeeze(0).numpy() + plt.imshow(heatmap, cmap="jet", alpha=0.5) + plt.axis("off") + plt.savefig(save_path, dpi=300) + +def plot_concept_heatmaps( + image, + concept_basis: torch.Tensor, + concept_list: list[str], + image_patch_vectors: torch.Tensor, + softmax=True, + normalize_maps=True +): + """ + Plot the concept heatmaps to ensure that the concept basis is + reasonable for the given image. + """ + assert len(image_patch_vectors.shape) in [4, 5], "Image patch vectors should be 4D or 5D, make sure you include layers and timesteps." + fig, axs = plt.subplots(1, len(concept_list) + 1, figsize=(4 * len(concept_list) + 4, 4)) + # Normalize the concept basis + # concept_basis = concept_basis / concept_basis.norm(dim=-1, keepdim=True) + + if len(image_patch_vectors.shape) == 5: + image_patch_projections = einops.einsum( + image_patch_vectors, + concept_basis, + "layers time heads patches d, layers time heads concepts d -> layers time heads concepts patches", + ) + if softmax: + image_patch_projections = torch.softmax(image_patch_projections, dim=-2) + image_patch_projections = einops.reduce( + image_patch_projections, + "layers time heads concepts patches -> concepts patches", + reduction="mean" + ) + image_patch_projections = einops.rearrange( + image_patch_projections, + "concepts (h w) -> concepts h w", + h=64, + w=64 + ) + else: + image_patch_projections = einops.einsum( + image_patch_vectors, + concept_basis, + "layers time patches d, layers time concepts d -> layers time concepts patches", + ) + if softmax: + image_patch_projections = torch.softmax(image_patch_projections, dim=-2) + + image_patch_projections = einops.reduce( + image_patch_projections, + "layers time concepts patches -> concepts patches", + reduction="mean" + ) + image_patch_projections = einops.rearrange( + image_patch_projections, + "concepts (w h) -> concepts w h", + h=64, + w=64 + ) + image_patch_projections = image_patch_projections.to(torch.float32).detach().cpu().numpy() + # Get min and max values + min_val = image_patch_projections.min() + max_val = image_patch_projections.max() + + if len(concept_list) > 30: + for concept in concept_list: + plt.figure() + if normalize_maps: + plt.imshow( + image_patch_projections[concept_list.index(concept)], + cmap="plasma", + vmin=min_val, + vmax=max_val + ) + else: + plt.imshow( + image_patch_projections[concept_list.index(concept)], + cmap="plasma" + ) + plt.title(concept) + plt.savefig(f"results/concept_heatmaps/{concept}.png") + plt.close() + else: + # Plot the image + axs[0].imshow(image) + axs[0].set_title("Image") + axs[0].axis("off") + # Plot the concept heatmaps + for i, concept in enumerate(concept_list): + if normalize_maps: + axs[i + 1].imshow( + image_patch_projections[i], + cmap="plasma", + vmin=min_val, + vmax=max_val + ) + else: + axs[i + 1].imshow( + image_patch_projections[i], + cmap="plasma" + ) + axs[i + 1].set_title(concept) + axs[i + 1].axis("off") + # Save the figure + plt.savefig("results/concept_heatmaps.png") + plt.close() + +def plot_coefficients_heatmap( + coefficients: torch.Tensor, + concepts: list[str], + save_path="results/group_coding_heatmaps.png" +): + # Convert the coefficients to a dictionary + coefficients = coefficients.detach().cpu().numpy() + coefficients = coefficients.T + dictionaries = [] + for i in range(coefficients.shape[0]): + dictionary = {} + for j, concept in enumerate(concepts): + dictionary[concept] = coefficients[i, j] + dictionaries.append(dictionary) + # Convert dictionaries to numpy arrays + dictionaries = [np.array([dictionary[concept] for concept in concepts]) for dictionary in dictionaries] + dictionaries = np.stack(dictionaries, axis=0) + dictionaries = einops.rearrange( + dictionaries, + "(w h) concepts -> concepts w h", + w=64, + h=64 + ) + # Get min and max + min_val = dictionaries.min() + max_val = dictionaries.max() + # Plot the coeffients of each dictioanry for each patch + fig, axs = plt.subplots(1, len(concepts), figsize=(4 * len(concepts), 4)) + for concept_index, concept in enumerate(concepts): + axs[concept_index].imshow( + dictionaries[concept_index], + cmap="plasma", + # vmin=min_val, + # vmax=max_val + ) + axs[concept_index].set_title(concept) + axs[concept_index].set_xticks([]) + axs[concept_index].set_yticks([]) + axs[concept_index].axis("off") + + plt.savefig(save_path) + plt.close() \ No newline at end of file diff --git a/concept_attention/segmentation.py b/concept_attention/segmentation.py new file mode 100644 index 0000000000000000000000000000000000000000..2249132557242b4d0bbe10205a527e775d78c024 --- /dev/null +++ b/concept_attention/segmentation.py @@ -0,0 +1,340 @@ +""" + A wrapper around a flux model that generates segmentation masks for particular + concepts. +""" +from abc import ABC, abstractmethod +import PIL +import torch +import numpy as np +import einops +import PIL +from torchvision import transforms +import torchvision.transforms.functional as F + +from concept_attention.flux.src.flux.sampling import get_noise, get_schedule, prepare, unpack + +from concept_attention.image_generator import FluxGenerator +from concept_attention.utils import embed_concepts, linear_normalization + +class SegmentationAbstractClass(ABC): + + def segment_individual_image( + self, + image: PIL.Image.Image, + concepts: list[str], + caption: str, + **kwargs + ): + """ + Segments an individual image + """ + pass + + def __call__( + self, + images: PIL.Image.Image | list[PIL.Image.Image], + target_concepts: list[str], + concepts: list[str], + captions: list[str], + mean_value_threshold: bool = True, + joint_attention_kwargs=None, + apply_blur=False, + **kwargs + ): + if not isinstance(images, list): + images = [images] + # Encode each image using the flux model + all_coefficients, reconstructed_images, all_masks = [], [], [] + for index, image in enumerate(images): + coefficients, reconstructed_image = self.segment_individual_image( + image, + concepts, + captions[index], + joint_attention_kwargs=joint_attention_kwargs, + **kwargs + ) + # Apply a blur to the coefficients + if apply_blur: + coefficients = F.gaussian_blur(coefficients.unsqueeze(0), kernel_size=3, sigma=1.0).squeeze() + # Threshold each coefficient to make a set of masks + mean_values = torch.mean(coefficients, dim=(1, 2), keepdim=True) + masks = coefficients > mean_values + # Check if there is a particular a target concept or not + if target_concepts is None: + # Return all masks + all_masks.append(masks) + all_coefficients.append(coefficients) + reconstructed_images.append(reconstructed_image) + else: + # Binarize the coefficients to generate a segmentation mask + target_concept_index = concepts.index(target_concepts[index]) + if mean_value_threshold: + mean_value = coefficients[target_concept_index].mean() + mask = coefficients[target_concept_index] > mean_value + else: + mask = coefficients[target_concept_index] > 0.0 + target_concept_coefficients = coefficients[target_concept_index] + mask = mask.cpu().numpy() + target_concept_coefficients = target_concept_coefficients.detach().cpu().numpy() + all_masks.append(mask) + all_coefficients.append(target_concept_coefficients) + reconstructed_images.append(reconstructed_image) + + return all_masks, all_coefficients, reconstructed_images + +def add_noise_to_image( + encoded_image, + num_steps=50, + noise_timestep=49, + seed=63, + width=1024, + height=1024, + device="cuda", + is_schnell=True, +): + # prepare input + x = get_noise( + 1, + height, + width, + device=device, + dtype=torch.bfloat16, + seed=seed, + ) + timesteps = get_schedule( + num_steps, + x.shape[-1] * x.shape[-2] // 4, + shift=(not is_schnell), + ) + t = timesteps[noise_timestep] + timesteps = timesteps[noise_timestep:] + x = t * x + (1.0 - t) * encoded_image.to(x.dtype) + + return x, timesteps + +@torch.no_grad() +def encode_image( + image: PIL.Image.Image, + autoencoder: torch.nn.Module, + offload=True, + device="cuda", + height=1024, + width=1024, +): + """ + Encodes a PIL image to the VAE latent space and adds noise to it + """ + if isinstance(image, PIL.Image.Image): + transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Lambda(lambda x: 2.0 * x - 1.0), + ]) + image = transform(image) + else: + transform = transforms.Compose([ + transforms.Lambda(lambda x: 2.0 * x - 1.0), + ]) + image = transform(image) + # init_image = image.convert("RGB") + # init_image = np.array(image) + init_image = image + if isinstance(init_image, np.ndarray): + init_image = torch.from_numpy(init_image).permute(2, 0, 1).float() / 255.0 + init_image = init_image.unsqueeze(0) + init_image = init_image.to(device) + init_image = torch.nn.functional.interpolate(init_image, (height, width)) + if offload: + autoencoder.encoder.to(device) + init_image = autoencoder.encode(init_image.to()) + if offload: + autoencoder = autoencoder.cpu() + torch.cuda.empty_cache() + + return init_image + + +@torch.no_grad() +def generate_concept_basis_and_image_representation( + image: PIL.Image.Image, + caption: str, + concepts: list[str], + noise_timestep: int | list[int] =49, + layers=list(range(19)), + normalize_concepts=True, + num_steps=50, + seed=63, + model_name="flux-schnell", + offload=True, + device="cuda", + target_space="output", + height=1024, + width=1024, + generator=None, + stop_after_multimodal_attentions=False, + num_samples=1, + joint_attention_kwargs=None, + reduce_dims=True, + **kwargs +): + """ + Takes a real image and generates a set of concept and image vectors. + """ + if generator is None: + # Load up the model + generator = FluxGenerator( + model_name, + device, + offload=offload + ) + else: + model_name = generator.model_name + # Encode the image into the VAE latent space + encoded_image_without_noise = encode_image( + image, + generator.ae, + offload=offload, + device=device, + ) + + # Do N trials + for i in range(num_samples): + # Add noise to image + encoded_image, timesteps = add_noise_to_image( + encoded_image_without_noise, + num_steps=num_steps, + noise_timestep=noise_timestep, + seed=seed + i, + width=width, + height=height, + device=device, + is_schnell=False, + ) + # Now run the diffusion model once on the noisy image + # Encode the concept vectors + + if offload: + generator.t5, generator.clip = generator.t5.to(device), generator.clip.to(device) + inp = prepare(t5=generator.t5, clip=generator.clip, img=encoded_image, prompt=caption) + + concept_embeddings, concept_ids, concept_vec = embed_concepts( + generator.clip, + generator.t5, + concepts, + ) + + inp["concepts"] = concept_embeddings.to(encoded_image.device) + inp["concept_ids"] = concept_ids.to(encoded_image.device) + inp["concept_vec"] = concept_vec.to(encoded_image.device) + # offload TEs to CPU, load model to gpu + if offload: + generator.t5, generator.clip = generator.t5.cpu(), generator.clip.cpu() + torch.cuda.empty_cache() + generator.model = generator.model.to(device) + # Denoise the intermediate images + guidance_vec = torch.full((encoded_image.shape[0],), 0.0, device=encoded_image.device, dtype=encoded_image.dtype) + t_curr = timesteps[0] + t_prev = timesteps[1] + t_vec = torch.full((encoded_image.shape[0],), t_curr, dtype=encoded_image.dtype, device=encoded_image.device) + pred = generator.model( + img=inp["img"], + img_ids=inp["img_ids"], + txt=inp["txt"], + txt_ids=inp["txt_ids"], + concepts=inp["concepts"], + concept_ids=inp["concept_ids"], + concept_vec=inp["concept_vec"], + null_txt=inp["null_txt"], + null_txt_vec=inp["null_txt_vec"], + null_txt_ids=inp["null_txt_ids"], + y=inp["concept_vec"], + timesteps=t_vec, + guidance=guidance_vec, + stop_after_multimodal_attentions=stop_after_multimodal_attentions, + joint_attention_kwargs=joint_attention_kwargs + ) + + if not stop_after_multimodal_attentions: + if offload: + generator.model.cpu() + torch.cuda.empty_cache() + generator.ae.decoder.to(pred.device) + + img = inp["img"] + (t_prev - t_curr) * pred + # decode latents to pixel space + img = unpack(img.float(), height, width) + with torch.autocast(device_type=generator.device.type, dtype=torch.bfloat16): + img = generator.ae.decode(img) + + if generator.offload: + generator.ae.decoder.cpu() + torch.cuda.empty_cache() + img = img.clamp(-1, 1) + img = einops.rearrange(img[0], "c h w -> h w c") + # reconstructed_image = PIL.Image.fromarray(img.cpu().byte().numpy()) + reconstructed_image = PIL.Image.fromarray((127.5 * (img + 1.0)).cpu().byte().numpy()) + else: + img = None + reconstructed_image = None + # Decode the image + if offload: + generator.model.cpu() + torch.cuda.empty_cache() + generator.ae.decoder.to(device) + + # Pull out the concept basis and image queries + concept_vectors = [] + image_vectors = [] + for double_block in generator.model.double_blocks: + if target_space == "output": + image_vecs = torch.stack( + double_block.image_output_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_output_vectors + ).squeeze(1) + elif target_space == "cross_attention": + image_vecs = torch.stack( + double_block.image_query_vectors + ).squeeze(1) + concept_vecs = torch.stack( + double_block.concept_key_vectors + ).squeeze(1) + # Clear out the layer (always same) + double_block.clear_cached_vectors() + # Add to list + concept_vectors.append(concept_vecs) + image_vectors.append(image_vecs) + # Stack layers + concept_vectors = torch.stack(concept_vectors).to(torch.float32) + image_vectors = torch.stack(image_vectors).to(torch.float32) + + if layers is not None: + # Pull out the layer index + concept_vectors = concept_vectors[layers] + image_vectors = image_vectors[layers] + + # Apply linear normalization to concepts + if normalize_concepts: + concept_vectors = linear_normalization(concept_vectors, dim=-2) + + if reduce_dims: + if len(image_vectors.shape) == 4: + image_vectors = einops.rearrange( + image_vectors, + "layers time patches d -> patches (layers time d)", + ) + concept_vectors = einops.rearrange( + concept_vectors, + "layers time concepts d -> concepts (layers time d)" + ) + else: + image_vectors = einops.rearrange( + image_vectors, + "layers time heads patches d -> patches (layers time heads d)", + ) + concept_vectors = einops.rearrange( + concept_vectors, + "layers time heads concepts d -> concepts (layers time heads d)" + ) + + return image_vectors, concept_vectors, reconstructed_image diff --git a/concept_attention/utils.py b/concept_attention/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..67ec8e60b96ca31e33ce7c46e12aa94e0e0b3693 --- /dev/null +++ b/concept_attention/utils.py @@ -0,0 +1,108 @@ +import torch +import numpy as np +from sklearn.metrics import average_precision_score + +# Utils for concept encoding +def embed_concepts( + clip, + t5, + concepts: list[str], + batch_size=1 +): + """ + Here the goal is to embed a bunch of concept vectors + into our text embedding space. + """ + # Code pulled from concept_attention.flux/sampling.py: prepare() + # Embed each concept separately + concept_embeddings = [] + for concept in concepts: + concept_embedding = t5(concept) + # Pull out the first token + token_embedding = concept_embedding[0, 0, :] # First token of first prompt + concept_embeddings.append(token_embedding) + concept_embeddings = torch.stack(concept_embeddings).unsqueeze(0) + # Add filler tokens of zeros + concept_ids = torch.zeros(batch_size, concept_embeddings.shape[1], 3) + + # Embed the concepts to a clip vector + prompt = " ".join(concepts) + vec = clip(prompt) + vec = torch.zeros_like(vec).to(vec.device) + + return concept_embeddings, concept_ids, vec + +def linear_normalization(x, dim): + # Subtract the minimum to shift all values to non-negative range + x_min = torch.min(x, dim=dim, keepdim=True)[0] + x_shifted = x - x_min + # Sum the values along the specified dimension + x_sum = torch.sum(x_shifted, dim=dim, keepdim=True) + # Avoid division by zero by setting sums of zero to one + x_sum = torch.where(x_sum == 0, torch.ones_like(x_sum), x_sum) + # Normalize by dividing by the sum + return x_shifted / x_sum + +################################## Metrics ################################## + +def get_ap_scores(predict, target, ignore_index=-1): + total = [] + for pred, tgt in zip(predict, target): + target_expand = tgt.unsqueeze(0).expand_as(pred) + target_expand_numpy = target_expand.data.cpu().numpy().reshape(-1) + # Tensor process + x = torch.zeros_like(target_expand) + t = tgt.unsqueeze(0).clamp(min=0).long() + target_1hot = x.scatter_(0, t, 1) + predict_flat = pred.data.cpu().numpy().reshape(-1) + predict_flat = np.nan_to_num(predict_flat) + target_flat = target_1hot.data.cpu().numpy().reshape(-1) + + p = predict_flat[target_expand_numpy != ignore_index] + t = target_flat[target_expand_numpy != ignore_index] + + total.append(np.nan_to_num(average_precision_score(t, p))) + + return total + +def batch_pix_accuracy(predict, target): + """Batch Pixel Accuracy + Args: + predict: input 3D tensor + target: label 3D tensor + """ + # _, predict = torch.max(predict, 0) + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + pixel_labeled = np.sum(target > 0) + pixel_correct = np.sum((predict == target) * (target > 0)) + assert pixel_correct <= pixel_labeled, \ + "Correct area should be smaller than Labeled" + + return pixel_correct, pixel_labeled + + +def batch_intersection_union(predict, target, nclass): + """Batch Intersection of Union + Args: + predict: input 3D tensor + target: label 3D tensor + nclass: number of categories (int) + """ + # _, predict = torch.max(predict, 0) + mini = 1 + maxi = nclass + nbins = nclass + predict = predict.cpu().numpy() + 1 + target = target.cpu().numpy() + 1 + + predict = predict * (target > 0).astype(predict.dtype) + intersection = predict * (predict == target) + # areas of intersection and union + area_inter, _ = np.histogram(intersection, bins=nbins, range=(mini, maxi)) + area_pred, _ = np.histogram(predict, bins=nbins, range=(mini, maxi)) + area_lab, _ = np.histogram(target, bins=nbins, range=(mini, maxi)) + area_union = area_pred + area_lab - area_inter + assert (area_inter <= area_union).all(), \ + "Intersection area should be smaller than Union area" + return area_inter, area_union diff --git a/experiments/test_diffusers_flux/test_diffusers_flux.py b/experiments/test_diffusers_flux/test_diffusers_flux.py new file mode 100644 index 0000000000000000000000000000000000000000..a7b1885434830a963843fadccef76c5544adc83c --- /dev/null +++ b/experiments/test_diffusers_flux/test_diffusers_flux.py @@ -0,0 +1,49 @@ +""" + +concept_attention_kwargs cases: +- case 1: concept_attention_kwargs is None + - Don't do concept attention +- case 2: concept_attention_kwargs is not None + - Mandate that concept_attention_layers, timesteps, and concepts are in concept_attention_kwargs and are not None + +""" +import torch +from matplotlib import cm +from diffusers import FluxPipeline + +from concept_attention.diffusers.flux import FluxWithConceptAttentionPipeline, FluxTransformer2DModelWithConceptAttention + +if __name__ == "__main__": + transformer = FluxTransformer2DModelWithConceptAttention.from_pretrained( + "black-forest-labs/FLUX.1-schnell", + torch_dtype=torch.bfloat16, + subfolder="transformer" + ) + pipe = FluxWithConceptAttentionPipeline.from_pretrained( + "black-forest-labs/FLUX.1-schnell", + transformer=transformer, + torch_dtype=torch.bfloat16 + ) + pipe.enable_model_cpu_offload() + + prompt = "A cat on the grass" + out = pipe( + prompt=prompt, + guidance_scale=0., + height=1024, + width=1024, + num_inference_steps=4, + max_sequence_length=256, + concept_attention_kwargs={ + "layers": list(range(18)), + "timesteps": list(range(3, 4)), + "concepts": ["cat", "grass", "sky", "background", "dog"] + }, + # output_type="latent" + ) + image = out.images[0] + concept_attention_maps = out.concept_attention_maps[0] + image.save("image.png") + # Pull out and save the concept attention maps + for i, attention_map in enumerate(concept_attention_maps): + attention_map.save(f"images/attention_map_{i}.png") diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..a8ea07dcf98173f8ce223b72bfd08b367a3fe1a4 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,160 @@ +# -e . +absl-py==2.1.0 +accelerate==0.23.0 +aiofiles==23.2.1 +aiohappyeyeballs==2.4.0 +aiohttp==3.10.5 +aiosignal==1.3.1 +annotated-types==0.7.0 +antlr4-python3-runtime==4.9.3 +anyio==4.6.0 +astunparse==1.6.3 +async-timeout==4.0.3 +attrs==24.2.0 +blis==1.1.0 +catalogue==2.0.10 +click==8.1.7 +cloudpathlib==0.20.0 +compel==2.0.3 +-e git+https://github.com/helblazer811/ConceptAttention.git#egg=concept_attention +#@4d8b00ebdfda3534818fd7a42fd725f39fc95b72#egg=concept_attention +confection==0.1.5 +contourpy==1.3.0 +cvxopt==1.3.2 +cycler==0.12.1 +cymem==2.0.10 +daam==0.2.0 +datasets==3.0.0 +diffusers==0.21.2 +dill==0.3.8 +distro==1.9.0 +docker-pycreds==0.4.0 +einops==0.8.0 +fastapi==0.115.7 +ffmpy==0.5.0 +fire==0.7.0 +flatbuffers==24.12.23 +flux==0.0.1 +fonttools==4.53.1 +frozenlist==1.4.1 +fsspec==2024.6.1 +ftfy==6.3.1 +gast==0.6.0 +gitdb==4.0.11 +GitPython==3.1.43 +google-pasta==0.2.0 +gradio==5.13.0 +gradio_client==1.6.0 +grpcio==1.69.0 +h11==0.14.0 +h5py==3.12.1 +httpcore==1.0.5 +httpx==0.27.2 +huggingface-hub==0.27.1 +hydra-core==1.3.2 +imageio==2.36.1 +inflect==7.5.0 +invisible-watermark==0.2.0 +jiter==0.5.0 +joblib==1.4.2 +keras==3.8.0 +kiwisolver==1.4.7 +langcodes==3.5.0 +language_data==1.3.0 +lazy_loader==0.4 +libclang==18.1.1 +lightning-utilities==0.11.9 +llvmlite==0.43.0 +marisa-trie==1.2.1 +Markdown==3.7 +markdown-it-py==3.0.0 +matplotlib==3.9.2 +mdurl==0.1.2 +mkl-service==2.4.0 +ml-dtypes==0.4.1 +more-itertools==10.6.0 +multidict==6.1.0 +multiprocess==0.70.16 +murmurhash==1.0.11 +namex==0.0.8 +nltk==3.9.1 +numba==0.60.0 +nvidia-ml-py==12.570.86 +nvitop==1.4.2 +omegaconf==2.3.0 +openai==1.47.0 +openai-clip==1.0.1 +opencv-python==4.10.0.84 +opt_einsum==3.4.0 +optree==0.13.1 +orjson==3.10.15 +packaging==24.1 +pandas==2.2.2 +preshed==3.0.9 +protobuf==5.28.2 +psutil==6.0.0 +pyaml==25.1.0 +pyarrow==17.0.0 +pydantic==2.9.2 +pydantic_core==2.23.4 +pydub==0.25.1 +pynndescent==0.5.13 +pyparsing==3.1.4 +python-multipart==0.0.20 +pytz==2024.2 +PyWavelets==1.7.0 +regex==2024.9.11 +rich==13.9.4 +ruff==0.9.2 +safehttpx==0.1.6 +safetensors==0.4.5 +scikit-image==0.24.0 +scikit-learn==1.5.2 +scikit-opt==0.6.6 +scikit-optimize==0.10.2 +scipy==1.14.1 +seaborn==0.13.2 +semantic-version==2.10.0 +sentencepiece==0.2.0 +sentry-sdk==2.14.0 +setproctitle==1.3.3 +shellingham==1.5.4 +smart-open==7.1.0 +smmap==5.0.1 +sniffio==1.3.1 +spacy==3.8.3 +spacy-legacy==3.0.12 +spacy-loggers==1.0.5 +srsly==2.5.0 +starlette==0.45.2 +tensorboard==2.18.0 +tensorboard-data-server==0.7.2 +tensorflow==2.18.0 +tensorflow-io-gcs-filesystem==0.37.1 +termcolor==2.5.0 +tf_keras==2.18.0 +thinc==8.3.3 +threadpoolctl==3.5.0 +tifffile==2024.9.20 +tokenizers==0.13.3 +tomlkit==0.13.2 +torch==2.4.0 +torchvision==0.19.0 +tqdm==4.66.5 +transformers==4.30.2 +triton==3.0.0 +typeguard==4.4.1 +typer==0.15.1 +tzdata==2024.1 +umap==0.1.1 +umap-learn==0.5.7 +uvicorn==0.34.0 +wandb==0.18.1 +wasabi==1.1.3 +weasel==0.4.1 +websockets==14.2 +Werkzeug==3.1.3 +wrapt==1.17.0 +xxhash==3.5.0 +yarl==1.11.1 +zipp==3.20.2 \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..a079c0855153121ecd2c90bdbc5c5b3ed16b2eb2 --- /dev/null +++ b/setup.py @@ -0,0 +1,12 @@ + +from setuptools import setup, find_packages + +# with open("requirements.txt") as f: +# requirements = f.read().splitlines() + +setup( + name='concept_attention', + version='0.1', + packages=find_packages(), + # install_requires=requirements +) \ No newline at end of file