supporting code

diffusion_bias_utils.py

@@ -0,0 +1,338 @@
+from glob import glob
+from os.path import join as pjoin
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import torch
+import umap.umap_ as umap
+from PIL import Image
+from scipy.cluster.hierarchy import dendrogram, linkage
+from scipy.spatial.distance import squareform
+from sklearn.preprocessing import normalize
+from tqdm import tqdm
+
+
+###
+# Get text embeddings from sentence-transformers model
+###
+def sentence_mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[
+        0
+    ]  # First element of model_output contains all token embeddings
+    input_mask_expanded = (
+        attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    )
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(
+        input_mask_expanded.sum(1), min=1e-9
+    )
+
+
+def compute_text_embeddings(sentences, text_tokenizer, text_model):
+    batch = text_tokenizer(
+        sentences, padding=True, truncation=True, return_tensors="pt"
+    )
+    with torch.no_grad():
+        model_output = text_model(**batch)
+        sentence_embeds = sentence_mean_pooling(model_output, batch["attention_mask"])
+        sentence_embeds /= sentence_embeds.norm(dim=-1, keepdim=True)
+        return sentence_embeds
+
+
+###
+# Get image embeddings from BLIP VQA models
+###
+# returns the average pixel embedding from the last layer of the image encoder
+def get_compute_image_embedding_blip_vqa_pixels(
+    img, blip_processor, blip_model, device="cpu"
+):
+    pixel_values = blip_processor(img, "", return_tensors="pt")["pixel_values"].to(
+        device
+    )
+    with torch.no_grad():
+        vision_outputs = blip_model.vision_model(
+            pixel_values=pixel_values,
+            output_hidden_states=True,
+        )
+        image_embeds = vision_outputs[0].sum(dim=1).squeeze()
+        image_embeds /= image_embeds.norm()
+        return image_embeds.detach().cpu().numpy()
+
+
+# returns the average token embedding from the question encoder (conditioned on the image) along with the generated answer
+# adapted from:
+# https://github.com/huggingface/transformers/blob/2411f0e465e761790879e605a4256f3d4afb7f82/src/transformers/models/blip/modeling_blip.py#L1225
+def get_compute_image_embedding_blip_vqa_question(
+    img, blip_processor, blip_model, question=None, device="cpu"
+):
+    question = "what word best describes this person?" if question is None else question
+    inputs = blip_processor(img, question, return_tensors="pt")
+    with torch.no_grad():
+        # make question embeddings
+        vision_outputs = blip_model.vision_model(
+            pixel_values=inputs["pixel_values"].to(device),
+            output_hidden_states=True,
+        )
+        image_embeds = vision_outputs[0]
+        image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long)
+        question_embeds = blip_model.text_encoder(
+            input_ids=inputs["input_ids"].to(device),
+            attention_mask=inputs["attention_mask"].to(device),
+            encoder_hidden_states=image_embeds,
+            encoder_attention_mask=image_attention_mask,
+            return_dict=False,
+        )
+        question_embeds = question_embeds[0]
+        # generate outputs
+        question_attention_mask = torch.ones(
+            question_embeds.size()[:-1], dtype=torch.long
+        ).to(question_embeds.device)
+        bos_ids = torch.full(
+            (question_embeds.size(0), 1),
+            fill_value=blip_model.decoder_bos_token_id,
+            device=question_embeds.device,
+        )
+        outputs = blip_model.text_decoder.generate(
+            input_ids=bos_ids,
+            eos_token_id=blip_model.config.text_config.sep_token_id,
+            pad_token_id=blip_model.config.text_config.pad_token_id,
+            encoder_hidden_states=question_embeds,
+            encoder_attention_mask=question_attention_mask,
+            # **generate_kwargs,
+        )
+        answer = blip_processor.decode(outputs[0], skip_special_tokens=True)
+        # average and normalize question embeddings
+        res_question_embeds = question_embeds.sum(dim=1).squeeze()
+        res_question_embeds /= res_question_embeds.norm()
+        res_question_embeds = res_question_embeds.detach().cpu().numpy()
+        return (res_question_embeds, answer)
+
+
+###
+# Plotting utilities: 2D and 3D projection + scatter plots
+###
+def make_2d_plot(embeds, text_list, color_list=None, shape_list=None, umap_spread=10):
+    # default color and shape
+    color_list = [0 for _ in text_list] if color_list is None else color_list
+    shape_list = ["circle" for _ in text_list] if shape_list is None else shape_list
+    # project to 2D
+    fit = umap.UMAP(
+        metric="cosine",
+        n_neighbors=len(embeds) - 1,
+        min_dist=1,
+        n_components=2,
+        spread=umap_spread,
+    )
+    u = fit.fit_transform(embeds)
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=u[:, 0].tolist(),
+            y=u[:, 1].tolist(),
+            mode="markers",
+            name="nodes",
+            marker=dict(
+                symbol=shape_list,
+                color=color_list,
+            ),
+            text=text_list,
+            hoverinfo="text",
+            marker_line_color="midnightblue",
+            marker_line_width=2,
+            marker_size=10,
+            opacity=0.8,
+        )
+    )
+    fig.update_yaxes(
+        scaleanchor="x",
+        scaleratio=1,
+    )
+    fig.update_layout(
+        autosize=False,
+        width=800,
+        height=800,
+    )
+    fig.layout.showlegend = False
+    return fig
+
+
+def make_3d_plot(embeds, text_list, color_list=None, shape_list=None, umap_spread=10):
+    # default color and shape
+    color_list = [0 for _ in text_list] if color_list is None else color_list
+    shape_list = ["circle" for _ in text_list] if shape_list is None else shape_list
+    # project to 3D
+    fit = umap.UMAP(
+        metric="cosine",
+        n_neighbors=len(embeds) - 1,
+        min_dist=1,
+        n_components=3,
+        spread=umap_spread,
+    )
+    u = fit.fit_transform(embeds)
+    # make nodes
+    df = pd.DataFrame(
+        {
+            "x": u[:, 0].tolist(),
+            "y": u[:, 1].tolist(),
+            "z": u[:, 2].tolist(),
+            "color": color_list,
+            "hover": text_list,
+            "symbol": shape_list,
+            "size": [5 for _ in text_list],
+        }
+    )
+    fig = px.scatter_3d(
+        df,
+        x="x",
+        y="y",
+        z="z",
+        color="color",
+        symbol="symbol",
+        size="size",
+        hover_data={
+            "hover": True,
+            "x": False,
+            "y": False,
+            "z": False,
+            "color": False,
+            "symbol": False,
+            "size": False,
+        },
+    )
+    fig.layout.showlegend = False
+    return fig
+
+
+###
+# Plotting utilities: cluster re-ordering and heatmaps
+###
+### Some utility functions to get the similarities between two lists of arrays
+# average pairwise similarity
+def sim_pairwise_avg(vecs_1, vecs_2):
+    res = np.matmul(np.array(vecs_1), np.array(vecs_2).transpose()).mean()
+    return res
+
+
+# distance between (normalized) centroids
+def sim_centroids(vecs_1, vecs_2):
+    res = np.dot(
+        normalize(np.array(vecs_1).mean(axis=0, keepdims=True), norm="l2")[0],
+        normalize(np.array(vecs_2).mean(axis=0, keepdims=True), norm="l2")[0],
+    )
+    return res
+
+
+# distance to nearest neighbot/examplar
+def sim_pairwise_examplar(vecs_1, vecs_2):
+    res = np.matmul(np.array(vecs_1), np.array(vecs_2).transpose()).max()
+    return res
+
+
+# To make pretty heatmaps, similar rows need to be close to each other
+# we achieve that by computing a hierarchical clustering of the points
+# then ordering the items as the leaves of a dendrogram
+def get_cluster_order(similarity_matrix, label_names=None):
+    label_names = (
+        ["" for _ in range(similarity_matrix.shape[0])]
+        if label_names is None
+        else label_names
+    )
+    dissimilarity = 1 - similarity_matrix
+    np.fill_diagonal(dissimilarity, 0.0)
+    # checks = False because similarity checks can fail for torch to numpy conversion
+    Z = linkage(squareform(dissimilarity, checks=False), "average")
+    # no_plot when inside a function call required because of jupyter/matplotlib issue
+    ddgr = dendrogram(
+        Z, labels=label_names, orientation="top", leaf_rotation=90, no_plot=True
+    )
+    cluster_order = ddgr["leaves"]
+    return cluster_order
+
+
+# then make heat map from similarity matrix
+def make_heat_map(sim_matrix, labels_x, labels_y, scale=25):
+    fig = go.Figure(
+        data=go.Heatmap(z=sim_matrix, x=labels_x, y=labels_y, hoverongaps=False)
+    )
+    fig.update_yaxes(
+        scaleanchor="x",
+        scaleratio=1,
+    )
+    fig.update_layout(
+        autosize=False,
+        width=scale * len(labels_x),
+        height=scale * len(labels_y),
+    )
+    fig.layout.showlegend = False
+    return fig
+
+
+# bring things together for a square heatmap
+def build_heat_map_square(
+    img_list, embed_field, sim_fun, label_list, row_order=None, hm_scale=20
+):
+    sim_mat = np.zeros((len(img_list), len(img_list)))
+    for i, dct_i in enumerate(img_list):
+        for j, dct_j in enumerate(img_list):
+            sim_mat[i, j] = sim_fun(dct_i[embed_field], dct_j[embed_field])
+    # optionally reorder labels and similarity matrix to be prettier
+    if row_order is None:
+        row_order = get_cluster_order(sim_mat)
+    labels_sorted = [label_list[i] for i in row_order]
+    sim_mat_sorted = sim_mat[np.ix_(row_order, row_order)]
+    # make heatmap from similarity matrix
+    heatmap_fig = make_heat_map(
+        sim_mat_sorted, labels_sorted, labels_sorted, scale=hm_scale
+    )
+    return heatmap_fig
+
+
+# bring things together for a rectangle heatmap: across lists
+def build_heat_map_rect(
+    img_list_rows,
+    img_list_cols,
+    label_list_rows,
+    label_list_cols,
+    embed_field,
+    sim_fun,
+    center=False,
+    temperature=5,
+    hm_scale=20,
+):
+    sim_mat = np.zeros((len(img_list_rows), len(img_list_cols)))
+    for i, dct_i in enumerate(img_list_rows):
+        for j, dct_j in enumerate(img_list_cols):
+            sim_mat[i, j] = sim_fun(dct_i[embed_field], dct_j[embed_field])
+    # normalize and substract mean
+    sim_mat_exp = np.exp(temperature * sim_mat)
+    sim_mat_exp /= sim_mat_exp.sum(axis=1, keepdims=1)
+    if center:
+        sim_mat_exp_avg = sim_mat_exp.mean(axis=0, keepdims=1)
+        sim_mat_exp -= sim_mat_exp_avg
+        sim_mat_exp_avg = sim_mat_exp_avg * sim_mat_exp.max() / sim_mat_exp_avg.max()
+    # rows are reordered by decreasing norm,
+    sim_mat_norm = np.sum(sim_mat_exp * sim_mat_exp, axis=1)
+    row_order = np.argsort(sim_mat_norm, axis=-1)
+    row_labels_sorted = [label_list_rows[i] for i in row_order]
+    if center:
+        # columns are ordered by bias
+        col_order = np.argsort(sim_mat_exp_avg.sum(axis=0), axis=-1)
+    else:
+        # columns sre reordered by similarity
+        sim_mat_exp_norm = normalize(sim_mat_exp, axis=0, norm="l2")
+        cluster_cols_sim_mat = np.matmul(sim_mat_exp_norm.transpose(), sim_mat_exp_norm)
+        col_order = get_cluster_order(cluster_cols_sim_mat)
+    col_labels_sorted = [label_list_cols[i] for i in col_order]
+    # make heatmap from similarity matrix
+    if center:
+        row_order = list(row_order) + [len(row_order), len(row_order) + 1]
+        row_labels_sorted = row_labels_sorted + ["_", "AVERAGE"]
+        sim_mat_exp = np.concatenate(
+            [sim_mat_exp, np.zeros_like(sim_mat_exp_avg), sim_mat_exp_avg], axis=0
+        )
+    sim_mat_exp_sorted = sim_mat_exp[np.ix_(row_order, col_order)]
+    heatmap_fig = make_heat_map(
+        sim_mat_exp_sorted, col_labels_sorted, row_labels_sorted, scale=hm_scale
+    )
+    return heatmap_fig