Duplicate from darkproger/propaganda

Co-authored-by: Volodymyr Ky <darkproger@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,27 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,38 @@
+---
+title: Propaganda
+emoji: 📊
+colorFrom: green
+colorTo: red
+sdk: streamlit
+app_file: app.py
+pinned: false
+duplicated_from: darkproger/propaganda
+---
+
+# Configuration
+
+`title`: _string_  
+Display title for the Space
+
+`emoji`: _string_  
+Space emoji (emoji-only character allowed)
+
+`colorFrom`: _string_  
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`colorTo`: _string_  
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`sdk`: _string_  
+Can be either `gradio` or `streamlit`
+
+`sdk_version` : _string_  
+Only applicable for `streamlit` SDK.  
+See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
+
+`app_file`: _string_  
+Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
+Path is relative to the root of the repository.
+
+`pinned`: _boolean_  
+Whether the Space stays on top of your list.

app.py

@@ -0,0 +1,72 @@
+import pandas as pd
+from spacy import displacy
+from spacy.tokens import Doc
+from spacy.vocab import Vocab
+from spacy_streamlit.util import get_html
+import streamlit as st
+import torch
+from transformers import BertTokenizerFast
+
+from model import BertForTokenAndSequenceJointClassification
+
+
+@st.cache(allow_output_mutation=True)
+def load_model():
+    tokenizer = BertTokenizerFast.from_pretrained('bert-base-cased')
+    model = BertForTokenAndSequenceJointClassification.from_pretrained(
+            "QCRI/PropagandaTechniquesAnalysis-en-BERT",
+             revision="v0.1.0")
+    return tokenizer, model
+
+with torch.inference_mode(True):
+    tokenizer, model = load_model()
+
+    st.write("[Propaganda Techniques Analysis BERT](https://huggingface.co/QCRI/PropagandaTechniquesAnalysis-en-BERT) Tagger")
+
+    input = st.text_area('Input', """\
+    In some instances, it can be highly dangerous to use a medicine for the prevention or treatment of COVID-19 that has not been approved by or has not received emergency use authorization from the FDA.
+    """)
+
+    inputs = tokenizer.encode_plus(input, return_tensors="pt")
+    outputs = model(**inputs)
+    sequence_class_index = torch.argmax(outputs.sequence_logits, dim=-1)
+    sequence_class = model.sequence_tags[sequence_class_index[0]]
+    token_class_index = torch.argmax(outputs.token_logits, dim=-1)
+    tokens = tokenizer.convert_ids_to_tokens(inputs.input_ids[0][1:-1])
+    tags = [model.token_tags[i] for i in token_class_index[0].tolist()[1:-1]]
+
+columns = st.columns(len(outputs.sequence_logits.flatten()))
+for col, sequence_tag, logit in zip(columns, model.sequence_tags, outputs.sequence_logits.flatten()):
+    col.metric(sequence_tag, '%.2f' % logit.item())
+
+
+spaces = [not tok.startswith('##') for tok in tokens][1:] + [False]
+
+doc = Doc(Vocab(strings=set(tokens)),
+          words=tokens,
+          spaces=spaces,
+          ents=[tag if tag == "O" else f"B-{tag}" for tag in tags])
+
+labels = model.token_tags[2:]
+
+label_select = st.multiselect(
+    "Tags",
+    options=labels,
+    default=labels,
+    key=f"tags_ner_label_select",
+)
+html = displacy.render(
+    doc, style="ent", options={"ents": label_select, "colors": {}}
+)
+style = "<style>mark.entity { display: inline-block }</style>"
+st.write(f"{style}{get_html(html)}", unsafe_allow_html=True)
+
+attrs = ["text", "label_", "start", "end", "start_char", "end_char"]
+data = [
+    [str(getattr(ent, attr)) for attr in attrs]
+    for ent in doc.ents
+    if ent.label_ in label_select
+]
+if data:
+    df = pd.DataFrame(data, columns=attrs)
+    st.dataframe(df)

model.py

@@ -0,0 +1,128 @@
+__author__ = "Yifan Zhang (yzhang@hbku.edu.qa)"
+__copyright__ = "Copyright (C) 2021, Qatar Computing Research Institute, HBKU, Doha"
+
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import torch
+from torch import nn
+from torch.nn.functional import sigmoid
+from transformers import BertPreTrainedModel, BertModel
+from transformers.file_utils import ModelOutput
+
+
+TOKEN_TAGS = (
+    "<PAD>", "O", 
+    "Name_Calling,Labeling", "Repetition", "Slogans", "Appeal_to_fear-prejudice", "Doubt",
+    "Exaggeration,Minimisation", "Flag-Waving", "Loaded_Language",
+    "Reductio_ad_hitlerum", "Bandwagon",
+    "Causal_Oversimplification", "Obfuscation,Intentional_Vagueness,Confusion", "Appeal_to_Authority", "Black-and-White_Fallacy",
+    "Thought-terminating_Cliches", "Red_Herring", "Straw_Men", "Whataboutism"
+)
+
+
+SEQUENCE_TAGS = ("Non-prop", "Prop")
+
+
+@dataclass
+class TokenAndSequenceJointClassifierOutput(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    token_logits: torch.FloatTensor = None
+    sequence_logits: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+
+
+class BertForTokenAndSequenceJointClassification(BertPreTrainedModel):
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_token_labels = 20
+        self.num_sequence_labels = 2
+
+        self.token_tags = TOKEN_TAGS
+        self.sequence_tags = SEQUENCE_TAGS 
+
+        self.alpha = 0.9
+
+        self.bert = BertModel(config)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = nn.ModuleList([
+            nn.Linear(config.hidden_size, self.num_token_labels),
+            nn.Linear(config.hidden_size, self.num_sequence_labels),
+        ])
+        self.masking_gate = nn.Linear(2, 1)
+
+        self.init_weights()
+        self.merge_classifier_1 = nn.Linear(self.num_token_labels + self.num_sequence_labels, self.num_token_labels)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=True,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+        )
+
+        sequence_output = outputs[0]
+        pooler_output = outputs[1]
+
+        sequence_output = self.dropout(sequence_output)
+        token_logits = self.classifier[0](sequence_output)
+
+        pooler_output = self.dropout(pooler_output)
+        sequence_logits = self.classifier[1](pooler_output)
+
+        gate = torch.sigmoid(self.masking_gate(sequence_logits))
+
+        gates = gate.unsqueeze(1).repeat(1, token_logits.size()[1], token_logits.size()[2])
+
+        weighted_token_logits = torch.mul(gates, token_logits)
+
+        logits = [weighted_token_logits, sequence_logits]
+
+        loss = None
+        if labels is not None:
+            criterion = nn.CrossEntropyLoss(ignore_index=0)
+            binary_criterion = nn.BCEWithLogitsLoss(pos_weight=torch.Tensor([3932/14263]).cuda())
+            loss_fct = CrossEntropyLoss()
+            weighted_token_logits = weighted_token_logits.view(-1, weighted_token_logits.shape[-1])
+            sequence_logits = sequence_logits.view(-1, sequence_logits.shape[-1])
+
+            token_loss = criterion(weighted_token_logits, labels)
+            sequence_label = torch.LongTensor([1] if any([label > 0 for label in labels]) else [0])
+            sequence_loss = binary_criterion(sequence_logits, sequence_label)
+
+            loss = self.alpha*loss[0] + (1-self.alpha)*loss[1]
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return TokenAndSequenceJointClassifierOutput(
+            loss=loss,
+            token_logits=weighted_token_logits,
+            sequence_logits=sequence_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+

requirements.txt

@@ -0,0 +1,6 @@
+pandas
+spacy
+spacy_streamlit
+streamlit
+transformers
+torch