posts/model_exploration.py

import json
import random
import sys

import numpy as np
import pandas as pd
import streamlit as st
# from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import pipeline

title = "Model Exploration"
description = "Comparison of hate speech detection models"
date = "2022-01-26"
thumbnail = "images/robot.png"

__HATE_DETECTION = """
Once the data has been collected using the definitions identified for the
task, you can start training your model. At training, the model takes in
the data with labels and learns the associated context in the input data
for each label. Depending on the task design, the labels may be binary like
'hateful' and 'non-hateful' or multiclass like 'neutral', 'offensive', and
'attack'.

When presented with a new input string, the model then predicts the
likelihood that the input is classified as each of the available labels and
returns the label with the highest likelihood as well as how confident the
model is in its selection using a score from 0 to 1.

Neural models such as transformers are frequently trained as general
language models and then fine-tuned on specific classification tasks.
These models can vary in their architecture and the optimization
algorithms, sometimes resulting in very different output for the same
input text.

The models used below include:
- [RoBERTa trained on FRENK dataset](https://huggingface.co/classla/roberta-base-frenk-hate)
- [RoBERTa trained on Twitter Hate Speech](https://huggingface.co/cardiffnlp/twitter-roberta-base-hate)
- [DeHateBERT model (trained on Twitter and StormFront)](https://huggingface.co/Hate-speech-CNERG/dehatebert-mono-english)
- [RoBERTa trained on 11 English hate speech datasets](https://huggingface.co/facebook/roberta-hate-speech-dynabench-r1-target)
- [RoBERTa trained on 11 English hate speech datasets and Round 1 of the Dynamically Generated Hate Speech Dataset](https://huggingface.co/facebook/roberta-hate-speech-dynabench-r2-target)
- [RoBERTa trained on 11 English hate speech datasets and Rounds 1 and 2 of the Dynamically Generated Hate Speech Dataset](https://huggingface.co/facebook/roberta-hate-speech-dynabench-r3-target)
- [RoBERTa trained on 11 English hate speech datasets and Rounds 1, 2, and 3 of the Dynamically Generated Hate Speech Dataset](https://huggingface.co/facebook/roberta-hate-speech-dynabench-r4-target)
"""

__HATECHECK = """
[Röttinger et al. (2021)](https://aclanthology.org/2021.acl-long.4.pdf) 
developed a list of 3,901 test cases for hate speech detection models called 
HateCheck. HateCheck provides a number of templates long with placeholders for 
identity categories and hateful terms along with labels indicating whether a 
model should or should not categorize the instance as hate speech. For each 
case, they created several examples with different
identity attributes to test models' abilities to detect hate speech towards
a range of groups of people. Additionally, they used more difficult
linguistic contexts such as adding negation or more nuanced words to try to fool the
model. See some of there examples using the button or try to make
your own examples to test the models in the tools below.

*** Warning: these examples may include hateful and violent content as
well as slurs and other offensive languages ***
"""

__RANKING = """
When models process a given input, they calculate the probability of
that input being labeled with each of the possible labels (in binary
cases for example, either 'hateful' or 'not hateful'). The label with
the highest probably is returned. If we test multiple input sentences
for a given model, we can see which input sentences have the
highest probabilities, indicating which examples the model is most
confident in classifying.

Try comparing different input sentences for a given model
using the tool below.
"""

__COMPARISON = """
Depending on their training data and parameters, models can return very
different outputs for the same input. Knowing how models differ in
their behavior can help with choosing an appropriate model for your
given use case.

Additionally, models trained on one kind of data can perform very 
differently when tested on novel data. To show the models' performance
in a variety of settings, we also show the results of each model on 
four datasets: the entirety of the [HateCheck Dataset](https://github.com/paul-rottger/hatecheck-data), 
the [Dynamically Generated Hate Speech Dataset](https://github.com/bvidgen/Dynamically-Generated-Hate-Speech-Dataset), 
the [Hateful Memes Dataset](https://huggingface.co/datasets/limjiayi/hateful_memes_expanded) 
(without the images), and a 2000-instance subsection of the 
[Open Subtitles](https://opus.nlpl.eu/OpenSubtitles-v2018.php) 
(English) Dataset. While the first three are hate speech datasets and have 
labels for whether or not each instance is hateful, the Open Subtitles dataset
contains movie subtitles and is not labeled for instances of hate.

Try comparing two different models' output for the same comparison
sentence using the tool below.
"""

__MODELS = [
    "classla/roberta-base-frenk-hate",
    "cardiffnlp/twitter-roberta-base-hate",
    "Hate-speech-CNERG/dehatebert-mono-english",
    "facebook/roberta-hate-speech-dynabench-r1-target",
    "facebook/roberta-hate-speech-dynabench-r2-target",
    "facebook/roberta-hate-speech-dynabench-r3-target",
    "facebook/roberta-hate-speech-dynabench-r4-target",
]

autopop_ranking = [
    [
        "I don't hate black people.",
        "Black people should die.",
        "My friend likes pancakes.",
    ],
    [
        "Those dirty redskins are all drunks.",
        "I can't stand Chinese food. It's too spicy.",
        "I lived near many Chinese people and I hated every single one of them.",
    ],
    [
        "Stop saying that Mexicans don't belong in our country!",
        "We walked along the dyke down the road.",
        "Ah shit, I fucked up.",
    ],
]

# Creates the forms for receiving multiple inputs to compare for a single
# model or one input to compare for two models
def run_article():
    st.markdown("# Making a Hate Speech Detection Model")
    with st.expander("Hate Speech Detection Models", expanded=False):
        st.markdown(__HATE_DETECTION)
    hc_path = "posts/resources/"
    hc_pholders = json.load(
        open(hc_path + "template_placeholders.json", encoding="utf-8")
    )
    hc_templates = json.load(
        open(hc_path + "hatecheck_category_templates.json", encoding="utf-8")
    )
    hc_info = json.load(
        open(hc_path + "hatecheck_category_info.json", encoding="utf-8")
    )
    hc_cats = [""] + list(hc_info.keys())

    st.markdown("## Testing Models' Behavior")
    with st.expander("HateCheck Examples", expanded=False):
        st.markdown(__HATECHECK)
        category = st.selectbox(
            "Select a category of examples from HateCheck", hc_cats, key="hc_cat_select"
        )
        if category:
            with st.form(key="hate_check"):
                hc_cat = hc_info[category]
                templates = []
                names = []
                for hc_temp in hc_cat:
                    templates.append(hc_temp)
                    names.append(hc_cat[hc_temp]["name"])
                selected_names = st.multiselect(
                    "Select one or more HateCheck templates to generate examples for",
                    names,
                    key="hc_temp_multiselect",
                )
                num_exs = st.number_input(
                    "Select a number of examples to generate for each selected template",
                    min_value=1,
                    max_value=5,
                    value=3,
                )
                if st.form_submit_button(label="Generate Examples"):
                    for name in selected_names:
                        index = names.index(name)
                        template = templates[index]
                        examples = generate_hc_ex(
                            hc_templates[template], hc_pholders, num_exs
                        )
                        st.header(name)
                        st.subheader("Label: " + hc_cat[template]["value"])
                        st.caption(hc_cat[template]["desc"])
                        for num in range(num_exs):
                            ex = examples[num]
                            st.write("Example #" + str(num + 1) + ": " + ex)

    st.markdown("## Model Output Ranking")
    with st.expander("Model Output Ranking Tool", expanded=False):
        st.markdown(__RANKING)
        with st.form(key="ranking"):
            model_name = st.selectbox(
                "Select a model to test",
                __MODELS,
            )
            # the placeholder key functionality was added in v1.2 of streamlit
            # and versions on Spaces currently goes up to v1.0
            input_1 = st.text_input(
                "Input 1",
                help="Try a phrase like 'We shouldn't let [IDENTITY] suffer.'",
                # placeholder="We shouldn't let [IDENTITY] suffer."
            )
            input_2 = st.text_input(
                "Input 2",
                help="Try a phrase like 'I'd rather die than date [IDENTITY].'",
                # placeholder="I'd rather die than date [IDENTITY]."
            )
            input_3 = st.text_input(
                "Input 3",
                help="Try a phrase like 'Good morning'",
                # placeholder="Good morning."
            )
            autopop = st.checkbox(
                "Choose examples for me",
                key="rank_autopop_ckbx",
                help="Check this box to run the model with 3 preselected sentences.",
            )
            if st.form_submit_button(label="Rank inputs"):
                if autopop:
                    rank_inputs = random.choice(autopop_ranking)
                else:
                    rank_inputs = [input_1, input_2, input_3]
                sys.stderr.write("\n" + str(rank_inputs) + "\n")
                results = run_ranked(model_name, rank_inputs)
                st.dataframe(results)

    st.markdown("## Model Comparison")
    with st.expander("Model Comparison Tool", expanded=False):
        st.markdown(__COMPARISON)
        with st.form(key="comparison"):
            model_name_1 = st.selectbox(
                "Select a model to compare",
                __MODELS,
                key="compare_model_1",
            )
            model_name_2 = st.selectbox(
                "Select another model to compare",
                __MODELS,
                key="compare_model_2",
            )
            autopop = st.checkbox(
                "Choose an example for me",
                key="comp_autopop_ckbx",
                help="Check this box to compare the models with a preselected sentence.",
            )
            input_text = st.text_input("Comparison input")
            if st.form_submit_button(label="Compare models"):
                if autopop:
                    input_text = random.choice(random.choice(autopop_ranking))
                results = run_compare(model_name_1, model_name_2, input_text)
                st.write("### Showing results for: " + input_text)
                st.dataframe(results)
                outside_ds = ["hatecheck", "dynabench", "hatefulmemes", "opensubtitles"]
                name_1_short = model_name_1.split("/")[1]
                name_2_short = model_name_2.split("/")[1]
                for calib_ds in outside_ds:
                    ds_loc = "posts/resources/charts/" + calib_ds + "/"
                    images, captions = [], []
                    for model in [name_1_short, name_2_short]:
                        images.append(ds_loc + model + "_" + calib_ds + ".png")
                        captions.append("Counts of dataset instances by hate score.")
                    st.write("#### Model performance comparison on " + calib_ds)
                    st.image(images, captions)


#                if model_name_1 == "Hate-speech-CNERG/dehatebert-mono-english":
#                    st.image("posts/resources/dehatebert-mono-english_calibration.png")
#                elif model_name_1 == "cardiffnlp/twitter-roberta-base-hate":
#                    st.image("posts/resources/twitter-roberta-base-hate_calibration.png")
#                st.write("Calibration of Model 2")
#                if model_name_2 == "Hate-speech-CNERG/dehatebert-mono-english":
#                    st.image("posts/resources/dehatebert-mono-english_calibration.png")
#                elif model_name_2 == "cardiffnlp/twitter-roberta-base-hate":
#                    st.image("posts/resources/twitter-roberta-base-hate_calibration.png")


# Takes in a Hate Check template and placeholders and generates the given
# number of random examples from the template, inserting a random instance of
# an identity category if there is a placeholder in the template
def generate_hc_ex(template, placeholders, gen_num):
    sampled = random.sample(template, gen_num)
    ph_cats = list(placeholders.keys())
    for index in range(len(sampled)):
        sample = sampled[index]
        for ph_cat in ph_cats:
            if ph_cat in sample:
                insert = random.choice(placeholders[ph_cat])
                sampled[index] = sample.replace(ph_cat, insert).capitalize()
    return sampled


# Runs the received input strings through the given model and returns the
# all scores for all possible labels as a DataFrame
def run_ranked(model, input_list):
    classifier = pipeline("text-classification", model=model, return_all_scores=True)
    output = {}
    results = classifier(input_list)
    for result in results:
        for index in range(len(result)):
            label = result[index]["label"]
            score = result[index]["score"]
            if label in output:
                output[label].append(score)
            else:
                new_out = [score]
                output[label] = new_out
    return pd.DataFrame(output, index=input_list)


# Takes in two model names and returns the output of both models for that
# given input string
def run_compare(name_1, name_2, text):
    classifier_1 = pipeline("text-classification", model=name_1)
    result_1 = classifier_1(text)
    out_1 = {}
    out_1["Model"] = name_1
    out_1["Label"] = result_1[0]["label"]
    out_1["Score"] = result_1[0]["score"]
    classifier_2 = pipeline("text-classification", model=name_2)
    result_2 = classifier_2(text)
    out_2 = {}
    out_2["Model"] = name_2
    out_2["Label"] = result_2[0]["label"]
    out_2["Score"] = result_2[0]["score"]
    return [out_1, out_2]