Spaces:
Sleeping
Sleeping
import gradio as gr | |
from app.utils import ( | |
create_input_instruction, | |
format_prediction_ouptut, | |
display_sentiment_score_table, | |
sentiment_flow_plot, | |
sentiment_intensity_analysis, | |
EXAMPLE_CONVERSATIONS, | |
label_analysis, | |
) | |
import sys | |
sys.path.insert(0, "../") # neccesary to load modules outside of app | |
from app import deberta_model, tokenizer | |
from preprocessing import preprocess | |
from Model.DeBERTa.deberta import predict, decode_deberta_label | |
def deberta_preprocess(input): | |
result = preprocess.process_user_input(input) | |
if not result["success"]: | |
raise gr.Error(result["message"]) | |
data = result["data"] | |
speakers = [item[1] for item in data] | |
messages = [item[2] for item in data] | |
return speakers, messages | |
def deberta_classifier(input): | |
speakers, messages = deberta_preprocess(input) | |
predictions = predict(deberta_model, tokenizer, messages) | |
# Assuming that there's only one conversation | |
labels = [decode_deberta_label(pred) for pred in predictions] | |
output = format_prediction_ouptut(speakers, messages, labels) | |
return output | |
def deberta_ui(): | |
with gr.Blocks() as deberta_model: | |
gr.Markdown( | |
""" | |
# DeBERTa | |
Building upon the DeBERTa architecture, the model was customized and | |
retrained on Epik data to classify messages between Visitors and Agents into | |
corresponding sentiment labels. At the time of training by the team prior to | |
the Fall 2023 semester, the model was trained on 15 labels, including | |
Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, | |
Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, | |
Curiosity, or Acceptance. | |
The primary difference between DeBERTa and COSMIC is that while DeBERTa's | |
prediction is solely based on its own context, COSMIC uses the context of | |
the entire conversation (i.e., all messages from the chat history of the | |
conversation). | |
""" | |
) | |
create_input_instruction() | |
with gr.Row(): | |
with gr.Column(): | |
example_dropdown = gr.Dropdown( | |
choices=["-- Not Selected --"] + list(EXAMPLE_CONVERSATIONS.keys()), | |
value="-- Not Selected --", | |
label="Select an example", | |
) | |
gr.Markdown('<p style="text-align: center;color: gray;">--- OR ---</p>') | |
conversation_input = gr.TextArea( | |
value="", | |
label="Input you conversation", | |
placeholder="Plese input your conversation here", | |
lines=15, | |
max_lines=15, | |
) | |
def on_example_change(input): | |
if input in EXAMPLE_CONVERSATIONS: | |
return EXAMPLE_CONVERSATIONS[input] | |
return "" | |
example_dropdown.input( | |
on_example_change, | |
inputs=example_dropdown, | |
outputs=conversation_input, | |
) | |
with gr.Column(): | |
output = gr.Textbox( | |
value="", | |
label="Predicted Sentiment Labels", | |
lines=22, | |
max_lines=22, | |
interactive=False, | |
) | |
submit_btn = gr.Button(value="Submit") | |
submit_btn.click(deberta_classifier, conversation_input, output) | |
# reset the output whenever a change in the input is detected | |
conversation_input.change(lambda x: "", conversation_input, output) | |
gr.Markdown("# Analysis of Labels") | |
with gr.Row(): | |
with gr.Column(scale=1): | |
gr.Markdown( | |
""" | |
<b>Frequency Analysis of Labels</b> | |
One key aspect of our analysis involves examining the | |
frequency distribution of labels assigned to different | |
parts of the conversation. This includes tracking the | |
occurrence of labels such as "Interest," "Curiosity," | |
"Confused," "Openness," and "Acceptance." The resulting | |
distribution provides insights into the prevalence of | |
various sentiments during the interaction. | |
<b>Word Cloud Visualization</b> | |
In addition to label frequency, we employ word cloud | |
visualization to depict the prominent terms in the input | |
conversations. This visual representation highlights the | |
most frequently used words, shedding light on the key | |
themes and topics discussed. | |
""" | |
) | |
with gr.Column(scale=3): | |
labels_plot = gr.Plot(label="Analysis of Labels Plot") | |
with gr.Column(scale=3): | |
wordcloud_plot = gr.Plot(label="Analysis of Labels Plot") | |
labels_btn = gr.Button(value="Plot Label Analysis") | |
labels_btn.click(label_analysis, inputs=[output], outputs=[labels_plot,wordcloud_plot]) | |
gr.Markdown("# Sentiment Flow Plot") | |
with gr.Row(): | |
with gr.Column(scale=1): | |
display_sentiment_score_table() | |
with gr.Column(scale=2): | |
plot_box = gr.Plot(label="Analysis Plot") | |
plot_btn = gr.Button(value="Plot Sentiment Flow") | |
plot_btn.click(sentiment_flow_plot, inputs=[output], outputs=[plot_box]) | |
gr.Markdown("# Sentiment Intensity Analysis") | |
with gr.Row(): | |
with gr.Column(scale=1): | |
gr.Markdown( | |
""" | |
How accurate is the model? How good are the labels? These are | |
some questions that we may have at this point, and we need to | |
look at different metrics to assess the performance of our | |
models. One of them is sentiment intensity which measures how | |
strong a sentiment is expressed in the text. | |
This can be done by using NLTK's `SentimentIntensityAnalyzer` | |
which analyzes the connotation of the words in the text and | |
suggests whether a text is positive (with score > 0) or negative | |
(score < 0) and at what degree the text is positive or negative. | |
The graph to the right illustrates the change in sentiment | |
intensity of the agent and visitor across the course of the | |
conversation. | |
<b><u>Note:</u></b> While NLTK's SentimentIntensityAnalyzer | |
offers valuable insights, it is primarily trained on social media | |
data like Twitter. Its performance might falter for lengthy or | |
intricate messages. However, it remains a useful tool for | |
gaining perspective on sentiment in conversations. | |
""" | |
) | |
with gr.Column(scale=2): | |
intensity_plot = gr.LinePlot() | |
intensity_plot_btn = gr.Button(value="Plot Sentiment Intensity") | |
intensity_plot_btn.click( | |
sentiment_intensity_analysis, | |
inputs=[conversation_input], | |
outputs=[intensity_plot], | |
) | |
# reset all outputs whenever a change in the input is detected | |
conversation_input.change( | |
lambda x: ("", None, None, None, None), | |
conversation_input, | |
outputs=[output, labels_plot, wordcloud_plot, plot_box, intensity_plot], | |
) | |
return deberta_model |