app.py

## LIBRARIES ###
## Data
import numpy as np
import pandas as pd
import torch
import math
from tqdm import tqdm
from math import floor
from collections import defaultdict
from transformers import AutoTokenizer
pd.options.display.float_format = '${:,.2f}'.format

# Analysis
# from gensim.models.doc2vec import Doc2Vec
# from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
import nltk
from nltk.cluster import KMeansClusterer
import scipy.spatial.distance as sdist
from scipy.spatial import distance_matrix
# nltk.download('punkt') #make sure that punkt is downloaded

# App & Visualization
import streamlit as st
import altair as alt
import plotly.graph_objects as go
from streamlit_vega_lite import altair_component



# utils
from random import sample
from error_analysis import utils as ut


def down_samp(embedding):
    """Down sample a data frame for altiar visualization """
    # total number of positive and negative sentiments in the class
    #embedding = embedding.groupby('slice').apply(lambda x: x.sample(frac=0.3))
    total_size = embedding.groupby(['slice','label'], as_index=False).count()

    user_data = 0
    # if 'Your Sentences' in str(total_size['slice']):
    #     tmp = embedding.groupby(['slice'], as_index=False).count()
    #     val = int(tmp[tmp['slice'] == "Your Sentences"]['source'])
    #     user_data = val

    max_sample = total_size.groupby('slice').max()['content']

    # # down sample to meeting altair's max values
    # # but keep the proportional representation of groups
    down_samp = 1/(sum(max_sample.astype(float))/(1000-user_data))

    max_samp = max_sample.apply(lambda x: floor(x*down_samp)).astype(int).to_dict()
    max_samp['Your Sentences'] = user_data

    # # sample down for each group in the data frame
    embedding = embedding.groupby('slice').apply(lambda x: x.sample(n=max_samp.get(x.name))).reset_index(drop=True)

    # # order the embedding
    return(embedding)


def data_comparison(df):
    selection = alt.selection_multi(fields=['cluster','label'])
    color = alt.condition(alt.datum.slice == 'high-loss', alt.Color('cluster:N', scale = alt.Scale(domain=df.cluster.unique().tolist())), alt.value("lightgray"))
    opacity = alt.condition(selection, alt.value(0.7), alt.value(0.25))

    # basic chart
    scatter = alt.Chart(df).mark_point(size=100, filled=True).encode(
        x=alt.X('x:Q', axis=None),
        y=alt.Y('y:Q', axis=None),
        color=color,
        shape=alt.Shape('label:N', scale=alt.Scale(range=['circle', 'diamond'])),
        tooltip=['cluster:N','slice:N','content:N','label:N','pred:O'],
        opacity=opacity
    ).properties(
        width=1000,
        height=800
    ).interactive()

    legend = alt.Chart(df).mark_point(size=100, filled=True).encode(
        x=alt.X("label:N"),
        y=alt.Y('cluster:N', axis=alt.Axis(orient='right'), sort='descending', title=''),
        shape=alt.Shape('label:N', scale=alt.Scale(
        range=['circle', 'diamond']), legend=None),
        color=color,
    ).add_selection(
        selection
    )
    layered = scatter | legend
    layered = layered.configure_axis(
        grid=False
    ).configure_view(
        strokeOpacity=0
    )
    return layered

def quant_panel(embedding_df):
    """ Quantitative Panel Layout"""
    all_metrics = {}
    st.warning("**Error slice visualization**")
    with st.expander("How to read this chart:"):
        st.markdown("* Each **point** is an input example.")
        st.markdown("* Gray points have low-loss and the colored have high-loss. High-loss instances are clustered using **kmeans** and each color represents a cluster.")
        st.markdown("* The **shape** of each point reflects the label category --  positive (diamond) or negative sentiment (circle).")
    #st.altair_chart(data_comparison(down_samp(embedding_df)), use_container_width=True)
    st.altair_chart(data_comparison(embedding_df), use_container_width=True)


def frequent_tokens(data, tokenizer, loss_quantile=0.95, top_k=200, smoothing=0.005):
    unique_tokens = []
    tokens = []
    for row in tqdm(data['content']):
        tokenized = tokenizer(row,padding=True, return_tensors='pt')
        tokens.append(tokenized['input_ids'].flatten())
        unique_tokens.append(torch.unique(tokenized['input_ids']))
    losses = data['loss'].astype(float)
    high_loss = losses.quantile(loss_quantile)
    loss_weights = (losses > high_loss)
    loss_weights = loss_weights / loss_weights.sum()
    token_frequencies = defaultdict(float)
    token_frequencies_error = defaultdict(float)

    weights_uniform = np.full_like(loss_weights, 1 / len(loss_weights))

    num_examples = len(data)
    for i in tqdm(range(num_examples)):
        for token in unique_tokens[i]:
            token_frequencies[token.item()] += weights_uniform[i]
            token_frequencies_error[token.item()] += loss_weights[i]

    token_lrs = {k: (smoothing+token_frequencies_error[k]) / (smoothing+token_frequencies[k]) for k in token_frequencies}
    tokens_sorted = list(map(lambda x: x[0], sorted(token_lrs.items(), key=lambda x: x[1])[::-1]))

    top_tokens = []
    for i, (token) in enumerate(tokens_sorted[:top_k]):
        top_tokens.append(['%10s' % (tokenizer.decode(token)), '%.4f' % (token_frequencies[token]), '%.4f' % (
            token_frequencies_error[token]), '%4.2f' % (token_lrs[token])])
    return pd.DataFrame(top_tokens, columns=['Token', 'Freq', 'Freq error slice', 'Ratio w/ smoothing'])


@st.cache(ttl=600)
def get_data(inference, emb):
    preds = inference.outputs.numpy()
    losses = inference.losses.numpy()
    embeddings = pd.DataFrame(emb, columns=['x', 'y'])
    num_examples = len(losses)
    # dataset_labels = [dataset[i]['label'] for i in range(num_examples)]
    return pd.concat([pd.DataFrame(np.transpose(np.vstack([dataset[:num_examples]['content'], 
                    dataset[:num_examples]['label'], preds, losses])), columns=['content', 'label', 'pred', 'loss']), embeddings], axis=1)

def clustering(data,num_clusters):
    X = np.array(data['embedding'].tolist())
    kclusterer = KMeansClusterer(
        num_clusters, distance=nltk.cluster.util.cosine_distance,
        repeats=25,avoid_empty_clusters=True)
    assigned_clusters = kclusterer.cluster(X, assign_clusters=True)
    data['cluster'] = pd.Series(assigned_clusters, index=data.index).astype('int')
    data['centroid'] = data['cluster'].apply(lambda x: kclusterer.means()[x])
    return data, assigned_clusters

def kmeans(df, num_clusters=3):
    #data_hl = df.loc[df['slice'] == 'high-loss']
    data_kmeans,clusters = clustering(df,num_clusters)
    #merged = pd.merge(df, data_kmeans, left_index=True, right_index=True, how='outer', suffixes=('', '_y'))
    #merged.drop(merged.filter(regex='_y$').columns.tolist(),axis=1,inplace=True)
    #merged['cluster'] = merged['cluster'].fillna(num_clusters).astype('int')
    return data_kmeans

def distance_from_centroid(row):
    return sdist.norm(row['embedding'] - row['centroid'].tolist())

@st.cache(ttl=600)
def topic_distribution(weights, smoothing=0.01):
    topic_frequencies = defaultdict(float)
    topic_frequencies_error= defaultdict(float)
    weights_uniform = np.full_like(weights, 1 / len(weights))
    num_examples = len(weights)
    for i in range(num_examples):
        example = dataset[i]
        category = example['title']
        topic_frequencies[category] += weights_uniform[i]
        topic_frequencies_error[category] += weights[i]

    topic_ratios = {c: (smoothing + topic_frequencies_error[c]) / (
        smoothing + topic_frequencies[c]) for c in topic_frequencies}

    categories_sorted = map(lambda x: x[0], sorted(
        topic_ratios.items(), key=lambda x: x[1], reverse=True))

    topic_distr = []
    for category in categories_sorted:
        topic_distr.append(['%.3f' % topic_frequencies[category], '%.3f' %
                           topic_frequencies_error[category], '%.2f' % topic_ratios[category], '%s' % category])

    return pd.DataFrame(topic_distr, columns=['Overall frequency', 'Error frequency', 'Ratio', 'Category'])

def populate_session(dataset,model):
    data_df = read_file_to_df('./assets/data/'+dataset+ '_'+ model+'.parquet')
    if model == 'albert-base-v2-yelp-polarity':
        tokenizer = AutoTokenizer.from_pretrained('textattack/'+model)
    else:
        tokenizer = AutoTokenizer.from_pretrained(model)
    if "user_data" not in st.session_state:
        st.session_state["user_data"] = data_df
    if "selected_slice" not in st.session_state:
        st.session_state["selected_slice"] = None
 
@st.cache(allow_output_mutation=True)
def read_file_to_df(file):
   return pd.read_parquet(file)

if __name__ == "__main__":
    ### STREAMLIT APP CONGFIG ###
    st.set_page_config(layout="wide", page_title="Interactive Error Analysis")

    ut.init_style()

    lcol, rcol = st.columns([2, 2])
    # ******* loading the mode and the data
    #st.sidebar.mardown("<h4>Interactive Error Analysis</h4>", unsafe_allow_html=True)

    dataset = st.sidebar.selectbox(
        "Dataset",
        ["amazon_polarity", "yelp_polarity"],
        index = 1
    )

    model = st.sidebar.selectbox(
        "Model",
        ["distilbert-base-uncased-finetuned-sst-2-english",
            "albert-base-v2-yelp-polarity"],
    )

    ### LOAD DATA AND SESSION VARIABLES ###
    ##uncomment the next next line to run dynamically and not from file
    #populate_session(dataset, model)
    data_df = read_file_to_df('./assets/data/'+dataset+ '_'+ model+'.parquet')
    loss_quantile = st.sidebar.slider(
        "Loss Quantile", min_value=0.5, max_value=1.0,step=0.01,value=0.99
    )
    data_df = data_df.drop(data_df[data_df.pred == data_df.label].index) #drop rows that are not errors
    data_df['loss'] = data_df['loss'].astype(float)
    losses = data_df['loss']
    high_loss = losses.quantile(loss_quantile)
    data_df['slice'] = 'high-loss'
    data_df['slice'] = data_df['slice'].where(data_df['loss'] > high_loss, 'low-loss') 
    data_hl = data_df.drop(data_df[data_df['slice'] == 'low-loss'].index) #drop rows that are not hl
    data_ll = data_df.drop(data_df[data_df['slice'] == 'high-loss'].index) 
    df_list = [d for _, d in data_hl.groupby(['label'])] # this is to allow clustering over each error type. fp, fn for binary classification

    with lcol:
        st.markdown('<h3>Error Slices</h3>',unsafe_allow_html=True)
        with st.expander("How to read the table:"):
            st.markdown("* *Error slice* refers to the subset of evaluation dataset the model performs poorly on.")
            st.markdown("* The table displays model error slices on the evaluation dataset, sorted by loss.")
            st.markdown("* Each row is an input example that includes the label, model pred, loss, and error cluster.")
        with st.spinner(text='loading error slice...'):
            dataframe=read_file_to_df('./assets/data/'+dataset+ '_'+ model+'_error-slices.parquet')
        #uncomment the next next line to run dynamically and not from file
        # dataframe = merged[['content', 'label', 'pred', 'loss', 'cluster']].sort_values(
        #     by=['loss'], ascending=False)
        # table_html = dataframe.to_html(
        #     columns=['content', 'label', 'pred', 'loss', 'cluster'], max_rows=50)
        # table_html = table_html.replace("<th>", '<th align="left">')  # left-align the headers
            st.write(dataframe,width=900, height=300)

    with rcol:
        with st.spinner(text='loading...'):
            st.markdown('<h3>Word Distribution in Error Slice</h3>', unsafe_allow_html=True)
            #uncomment the next two lines to run dynamically and not from file
            #commontokens = frequent_tokens(data_df, tokenizer, loss_quantile=loss_quantile)
            commontokens = read_file_to_df('./assets/data/'+dataset+ '_'+ model+'_commontokens.parquet')
            with st.expander("How to read the table:"):
                st.markdown("* The table displays the most frequent tokens in error slices, relative to their frequencies in the val set.")
            st.write(commontokens)

    run_kmeans = st.sidebar.radio("Cluster error slice?", ('True', 'False'), index=0)

    num_clusters = st.sidebar.slider("# clusters", min_value=1, max_value=20, step=1, value=3)

    if run_kmeans == 'True':
        with st.spinner(text='running kmeans...'):
            merged = pd.DataFrame()
            ind=0
            for df in df_list:
                #num_clusters= int(math.sqrt(len(df)/2))
                kmeans_df = kmeans(df,num_clusters=num_clusters)
                #print(kmeans_df.loc[kmeans_df['cluster'].idxmax()])
                kmeans_df['cluster'] = kmeans_df['cluster'] + ind*num_clusters
                ind = ind+1
                merged = pd.concat([merged, kmeans_df])
            merged = pd.concat([merged, data_ll])

    with st.spinner(text='loading visualization...'):
        quant_panel(merged)