Red Hot Cyber
La cybersecurity è condivisione. Riconosci il rischio, combattilo, condividi le tue esperienze ed incentiva gli altri a fare meglio di te.
Cerca
Banner Ransomfeed 970x120 1
TM RedHotCyber 320x100 042514
Come Sviluppare un’App per il Riconoscimento delle Emozioni con BERT e ONNX

Come Sviluppare un’App per il Riconoscimento delle Emozioni con BERT e ONNX

Marcello Politi : 14 Giugno 2024 07:38

In questo articolo vederemo come sviluppare un’applicazione web che riconosca una particolare emozione partendo da una frase. Per farlo, però, vedremo come addestrare un modello basato su transformer, convertirlo in formato ONNX, quantizzarlo ed eseguirlo dal front-end usando Streamlit.

Ottimizzare un modello con tecniche come la quantizzazione può essere una buona idea se riusciamo a mantenere buone prestazioni, in quanto migliorerà la velocità di risposta e potremo creare un prodotto con poca latenza e garantire una maggiore user satisfaction.

Per il rilevamento delle emozioni voglio utilizzare un modello basato su BERT in grado di riconoscere: rabbia, paura, gioia, amore, tristezza e sorpresa.


Banner 600x900 Betti Rha Cybersecurity Awareness

Cybersecurity Awareness per la tua azienda? Scopri BETTI RHC!

Sei un'azienda innovativa, che crede nella diffusione di concetti attraverso metodi "non convenzionali"? 
Red hot cyber ha sviluppato da diversi anni una Graphic Novel, l'unica nel suo genere nel mondo, che consente di formare i dipendenti sulla sicurezza informatica attraverso la lettura di un fumetto.
Scopri di più sul corso a fumetti di Red Hot Cyber. Contattaci tramite WhatsApp al numero 375 593 1011 per richiedere ulteriori informazioni oppure alla casella di posta [email protected]


Supporta Red Hot Cyber attraverso: 

  1. L'acquisto del fumetto sul Cybersecurity Awareness
  2. Ascoltando i nostri Podcast
  3. Seguendo RHC su WhatsApp
  4. Seguendo RHC su Telegram
  5. Scarica gratuitamente “Byte The Silence”, il fumetto sul Cyberbullismo di Red Hot Cyber

Se ti piacciono le novità e gli articoli riportati su di Red Hot Cyber, iscriviti immediatamente alla newsletter settimanale per non perdere nessun articolo. La newsletter generalmente viene inviata ai nostri lettori ad inizio settimana, indicativamente di lunedì.

Si tratta di un modello rilasciato da Microsoft, che è una versione distillata del BERT originale.

Per addestrare il modello su questo set di dati, utilizzeremo in modo intensivo le API di Hugging Face.

Training del modello

Iniziamo installando le librerie necessarie, in particolare per ONNX e i transformer.

!pip install transformers[torch]
!pip install datasets  onnx onnxruntime 
!pip install accelerate -U

Gli import di cui avremo bisogno:

from datasets import load_dataset
from transformers import AutoTokenizer
import torch
from transformers import AutoModelForSequenceClassification
import numpy as np
from datasets import load_metric
from transformers import TrainingArguments
from transformers import Trainer
import transformers
import transformers.convert_graph_to_onnx as onnx_convert
from pathlib import Path
import onnxruntime as ort
from onnxruntime.quantization import quantize_dynamic, QuantType
import numpy as np
from google.colab import files

Ho scelto un modello basato su BERT distillato di Microsoft perché è più leggero della versione originale.

model_name = 'microsoft/xtremedistil-l6-h256-uncased'

Ovviamente abbiamo bisogno di dati per mettere a punto il nostro modello. Possiamo utilizzare il set di dati sulle emozioni che si trova anch’esso sulla piattaforma di HuggingFace.

Questo set di dati ha un totale di 20.000 esempi suddivisi in training, validazione.

Come al solito, dobbiamo caricare il dataset e tokenizzare il testo per poterlo dare in pasto al modello. Ogni modello ha il suo tokenizer associato, che possiamo recuperare utilizzando la classe AutoTokenizer.

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)

dataset = load_dataset("emotion")
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenized_datasets = dataset.map(tokenize_function, batched=True)

Il passo successivo consiste nel dividere i dati di addestramento da quelli di test.

full_train_dataset = tokenized_datasets["train"]
full_eval_dataset = tokenized_datasets["test"]

Se disponiamo di una GPU, sarebbe opportuno impostarla come dispositivo di training predefinito. Altrimenti, usiamo solo la CPU.

device = "cuda:0" if torch.cuda.is_available() else "cpu"
print(device)

Ora possiamo scaricare il modello e specificare che verrà utilizzato per un task di classificazione con 6 classi ( 6 emozioni). Quindi, spostiamo il modello sul dispositivo (GPU). Per capire meglio come funziona il modello, potrebbe essere interessante leggere il paper su BERT.

model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=6)
model = model.to(device)

Dovremmo essere in grado di capire come si comporta il nostro modello in questo task, il che significa che abbiamo bisogno di un modo per valutarlo. Trattandosi di un task di classificazione, il metodo di valutazione è abbastanza semplice. Possiamo affidarci alla metrica accuracy per verificare la differenza tra le etichette previste e quelle reali.

metric = load_metric("accuracy")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

La libreria Transformer ci permette di creare un oggetto TrainingArguments in cui specificare gli iperparametri di addestramento, come batch_size e learning_rate.

Quindi, si passano questi argomenti al trainer insieme al modello e ai dati e si è pronti a partire.

training_args = TrainingArguments("test_trainer",
                                  per_device_train_batch_size=128, 
                                  num_train_epochs=24,
                                  learning_rate=3e-05,
                                  evaluation_strategy="epoch")
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=full_train_dataset,
    eval_dataset=full_eval_dataset,
    compute_metrics=compute_metrics,
)

Il training potrebbe richiedere un po’ di tempo, soprattutto se non si utilizza una GPU…

trainer.train()

Ottimo! Il nostro modello è ora addestrato sui dati emotivi. Ma quanto è buono? Valutiamolo!

trainer.evaluate()

La accuracy è superiore al 90%. Ora possiamo inserire sia il tokenizer che il modello in una pipeline, in modo da essere in grado di classificare nuove frasi.

pipeline = transformers.pipeline("text-classification",model=model,tokenizer=tokenizer)
pipeline("I am very mad!")

Conversione in ONNX e quantizzazione

ONNX è un framework di apprendimento automatico intermedio, utilizzato per convertire modelli tra diversi framework di machine learning.

Spostiamo il modello sulla CPU.

model = model.to("cpu")

Con una sola funzione, possiamo convertire la nostra pipeline PyTorch sviluppata in un modello ONNX.

Il parametro opset specifica la versione del set di operatori ONNX da utilizzare durante la conversione da PyTorch a ONNX. L’insieme di operatori ONNX definisce l’insieme di operazioni e la loro semantica che il modello ONNX può utilizzare.

onnx_convert.convert_pytorch(pipeline, opset=11, output=Path("classifier.onnx"), use_external_format=False)

Non abbiamo ancora finito. Dobbiamo ancora quantizzare il nostro modello. Ciò significa una minore precisione nella rappresentazione dei pesi, il che lo rende molto più piccolo. In questo caso, utilizzo la quantizzazione INT8.

quantize_dynamic("classifier.onnx", "classifier_int8.onnx", 
                 weight_type=QuantType.QUInt8)

Per utilizzare i modelli ONNX in inerence , è necessario creare una sessione. Pertanto, inizializzo ora una sessione sia per i modelli non quantizzati che per quelli quantizzati.

session = ort.InferenceSession("classifier.onnx")
session_int8 = ort.InferenceSession("classifier_int8.onnx")

Definiamo una funzione per eseguire la predizione su una singola frase, tokenizzando la frase di input ed eseguendo l’inferenza con la sessione ONNX.

def predict_sentece(sentence:str):

  # Tokenize and preprocess the input sentence
  tokens = tokenizer(sentence, return_tensors='np', padding=True, truncation=True)

  # Create the input_data dictionary
  input_data = {
      'input_ids': tokens['input_ids'],
      'attention_mask': tokens['attention_mask'],
      'token_type_ids': tokens['token_type_ids'],
  }

  # Run inference
  output = session.run(None, input_data)

  return np.argmax(output[0], axis=-1)


predict_sentece("I Love Python")

Un feed di input per il modello ha sempre l’aspetto seguente. (Per saperne di più, si può leggere qui: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt)

Abbiamo questa struttura di dati già pronta perché il dataset scaricato aveva questo particolare formato. Possiamo quindi sfruttarla per la valutazione.

input_feed = {
    "input_ids": np.array(full_eval_dataset['input_ids']),
    "attention_mask": np.array(full_eval_dataset['attention_mask']),
    "token_type_ids": np.array(full_eval_dataset['token_type_ids'])
}

Eseguiamo i modelli e otteniamo l’output con l’aiuto della funzione numpy argmax.

out = session.run(input_feed=input_feed,output_names=['output_0'])[0]
out_int8 = session_int8.run(input_feed=input_feed,output_names=['output_0'])[0]
predictions = np.argmax(out, axis=-1)
predictions_int8 = np.argmax(out_int8, axis=-1)

Verifichiamo che l’accuratezza degli output del modello ONNX dopo la conversione sia ancora elevata.

metric.compute(predictions=predictions, references=full_eval_dataset['label'])

Lo stesso vale per il modello quantizzato. Noterete che il nostro modello quantizzato è sicuramente più leggero, ma la sua precisione diminuisce di 10 punti.

metric.compute(predictions=predictions_int8, references=full_eval_dataset['label'])

Se si utilizza Colab, è possibile scaricare i due modelli ONNX utilizzando questa funzione.

files.download('classifier_int8.onnx') 
files.download('classifier.onnx')

Deploy del modello con Streamlit

Ora che abbiamo scaricato i modelli, possimo usarne uno per sviluppare la nostra applicazione di classificazione del sentimento.

Non sono un bravo sviluppatore front-end, quindi quando ho bisogno di creare prototipi veloci, mi piace usare strumenti come Streamlit o Gradio.

Con poche righe di codice Python, possiamo configurare facilmente questa applicazione.

Nel codice seguente

  • impostiamo il runtime di sessione ONNX
  • settiamo il tokenizer
  • creiamo un dizionario per mappare le classi previste alle emozioni reali
  • riutilizziamo la funzione di predizione sviluppata in precedenza
  • creiamo una semplice interfaccia utente in cui l’utente possa inserire un prompt ed eseguire il modello con un pulsante.
import streamlit as st
from transformers import pipeline
import onnxruntime as ort
import numpy as np
from transformers import AutoTokenizer

session = ort.InferenceSession("classifier.onnx")
model_name = "microsoft/xtremedistil-l6-h256-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)


decode_sentiment = {
    0: "sadness",
    1: "joy",
    2: "love",
    3: "anger",
    4: "fear",
    5: "surprise",
}


def predict_sentece(sentence: str):
    # Tokenize and preprocess the input sentence
    tokens = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)

    # Create the input_data dictionary
    input_data = {
        "input_ids": tokens["input_ids"],
        "attention_mask": tokens["attention_mask"],
        "token_type_ids": tokens["token_type_ids"],
    }

    # Run inference
    output = session.run(None, input_data)

    return np.argmax(output[0], axis=-1)




# Streamlit app
def main():
    st.title("Sentiment Classification App with BERT")

    # User input
    user_input = st.text_area("Enter your text here:")

    # Make prediction when the user clicks the button
    if st.button("Predict Sentiment"):
        if user_input:
            # Perform sentiment prediction
            sentiment = predict_sentece(user_input)[0]

            # Display the result
            st.success(f"Sentiment: {decode_sentiment[sentiment]}")
        else:
            st.warning("Please enter a text for sentiment prediction.")


if __name__ == "__main__":
    main()

Il risultato dovrebbe essere simile al seguente.

Conclusioni

In questo articolo, in cui abbiamo implementato una piccola applicazione full-stack, abbiamo visto come addestrare un modello, come ottimizzarlo usando la quantizzazione e come creare un semplice prototipo di frontend usando Streamlit.
Una cosa interessante da sapere su ONNX è che è un formato che può essere convertito in molti altri framework. Quindi, se si desidera, ad esempio, riconvertirlo con Tensorflow, è molto semplice.

💼 Linkedin ️| 🐦 Twitter | 💻 Website

Immagine del sitoMarcello Politi
Esperto di intelligenza artificiale con una grande passione per l'esplorazione spaziale. Ho avuto la fortuna di lavorare presso l'Agenzia Spaziale Europea, contribuendo a progetti di ottimizzazione del flusso di dati e di architettura del software. Attualmente, sono AI Scientist & Coach presso la PiSchool, dove mi dedico alla prototipazione rapida di prodotti basati sull'intelligenza artificiale. Mi piace scrivere articoli riguardo la data science e recentemente sono stato riconosciuto come uno dei blogger più prolifici su Towards Data Science.

Lista degli articoli

Articoli in evidenza

Immagine del sito
Internet Explorer è “morto”, ma continua a infettare con i suoi bug i PC tramite Edge
Di Luca Galuppi - 14/10/2025

Nonostante Internet Explorer sia ufficialmente fuori supporto dal giugno 2022, Microsoft ha recentemente dovuto affrontare una minaccia che sfrutta la modalità Internet Explorer (IE Mode) in Edge, pr...

Immagine del sito
Jeff Bezos all’Italian Tech Week: “Milioni di persone vivranno nello spazio”
Di Carlo Denza - 14/10/2025

Datacenter nello spazio, lander lunari, missioni marziane: il futuro disegnato da Bezos a Torino. Ma la vera rivelazione è l’aneddoto del nonno che ne svela il profilo umano Anche quest’anno Tori...

Immagine del sito
WhatsApp Web nel mirino! Come funziona il worm che distribuisce il Trojan Bancario
Di Redazione RHC - 14/10/2025

E’ stata individuata dagli analisti di Sophos, una complessa operazione di malware da parte di esperti in sicurezza, che utilizza il noto servizio di messaggistica WhatsApp come mezzo per diffondere...

Immagine del sito
RMPocalypse: Un bug critico in AMD SEV-SNP minaccia la sicurezza del cloud
Di Redazione RHC - 13/10/2025

È stata identificata una vulnerabilità critica nell’architettura di sicurezza hardware AMD SEV-SNP, che impatta i principali provider cloud (AWS, Microsoft Azure e Google Cloud). Tale bug consente...

Immagine del sito
Un Cyber Meme Vale Più di Mille Slide! E ora Vi spieghiamo il perché
Di Redazione RHC - 13/10/2025

Nel mondo della sicurezza informatica, dove ogni parola pesa e ogni concetto può diventare complesso, a volte basta un’immagine per dire tutto. Un meme, con la sua ironia tagliente e goliardica e l...