diffusion_bias_utils.py

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