Come creare un modello di analisi del sentiment da zero

L'analisi del sentiment è una tecnica di elaborazione del linguaggio naturale (NLP) che identifica l'atteggiamento dietro un testo. È anche noto come estrazione di opinioni. L'obiettivo dell'analisi del sentimento è identificare se un determinato testo ha un sentimento positivo, negativo o neutro. È ampiamente utilizzato dalle aziende per classificare automaticamente il sentimento nelle recensioni dei clienti. L'analisi di grandi volumi di recensioni aiuta a ottenere informazioni preziose sulle preferenze dei clienti.

Configurazione dell'ambiente

Devi avere familiarità con Nozioni di base su Python da seguire. Navigare verso Google Colab o apri Jupyter Notebook. Quindi crea un nuovo taccuino. Esegui il seguente comando per installare le librerie richieste nel tuo ambiente.

Il codice sorgente completo di questo progetto è disponibile in questo Deposito GitHub.

! pip install tensorflow scikit-learn pandas numpy pickle5

Utilizzerai NumPy e libreria pandas per manipolare il set di dati. TensorFlow per la creazione e l'addestramento del modello di machine learning. Scikit-learn per suddividere il set di dati in set di addestramento e test. Infine, userai pickle5 per serializzare e salvare l'oggetto tokenizer.

Importazione delle librerie richieste

Importa le librerie necessarie che utilizzerai per preelaborare i dati e creare il modello.

importare intorpidito COME np
importare panda COME pd
importare tensorflow COME tf
da sklearn.model_selection importare train_test_split
da sklearn.metrics importare punteggio_accuratezza
da tensorflow.keras.preprocessing.text importare Gettoniera
da tensorflow.keras.preprocessing.sequence importare pad_sequenze
da tensorflow.keras.models importare Sequenziale
da tensorflow.keras.layers importare Incorporamento, Conv1D, GlobalMaxPooling1D, Dense, Dropout
importare sottaceto5 COME salamoia

Utilizzerai le classi importate dai moduli più avanti nel codice.

Caricamento del set di dati

Qui utilizzerai il set di dati Trip Advisor Hotel Reviews di Kaggle per costruire il modello di analisi del sentiment.

df = pd.read_csv('/content/tripadvisor_hotel_reviews.csv')
stampa (df.head())

Carica il set di dati e stampa le prime cinque righe. La stampa delle prime cinque righe ti aiuterà a controllare i nomi delle colonne del tuo set di dati. Questo sarà fondamentale durante la pre-elaborazione del set di dati.

Il set di dati Trip Advisor Hotel Reviews ha una colonna indice, una colonna Recensione e una colonna Valutazione.

Preelaborazione dei dati

Seleziona il Revisione E Valutazione colonne del set di dati. Crea una nuova colonna basata sulla colonna Valutazione e assegnale un nome sentimento. Se la valutazione è maggiore di 3, etichetta il sentimento come positivo. Se la valutazione è inferiore a 3, etichettala come negativo. Se il punteggio è esattamente 3, etichettalo come neutro.

Seleziona solo le colonne Revisione e Sentiment dal set di dati. Mescola le righe in modo casuale e reimposta l'indice del frame di dati. Lo shuffling e il ripristino assicurano che i dati vengano distribuiti in modo casuale, il che è necessario per il training e il test corretti del modello.

DF = DF[['Revisione', 'Valutazione']]
df['sentimento'] = DF['Valutazione'].fare domanda a(lambda X: 'positivo'Se x > 3
altro'negativo'Se x < 3
altro'neutro')
DF = DF[['Revisione', 'sentimento']]
df = df.campione (frac=1.reset_index (drop=VERO)

Converti il Revisione text in una sequenza di numeri interi utilizzando il tokenizer. Questo crea un dizionario delle parole univoche presenti nel testo di revisione e mappa ciascuna parola su un valore intero univoco. Usa il pad_sequenze funzione di Keras per garantire che tutte le sequenze di revisione abbiano la stessa lunghezza.

tokenizer = Tokenizer (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Revisione'])
word_index = tokenizer.word_index
sequenze = tokenizer.texts_to_sequences (df['Revisione'])
imbottito_sequenze = pad_sequenze (sequenze, maxlen=100, troncando='inviare')

Converti le etichette dei sentimenti nella codifica One-hot.

etichette_sentimenti = pd.get_dummies (df['sentimento']).valori

La codifica one-hot rappresenta i dati categorici in un formato con cui è più facile lavorare con i tuoi modelli.

Suddivisione del set di dati in set di addestramento e test

Usa scikit-learn per suddividere in modo casuale il set di dati in set di addestramento e test. Utilizzerai il set di addestramento per addestrare il modello a classificare i sentimenti delle recensioni. E utilizzerai il set di test per verificare quanto è bravo il modello a classificare nuove recensioni invisibili.

x_train, x_test, y_train, y_test = train_test_split (padded_sequences, sentiment_labels, test_size=0.2)

La dimensione della suddivisione del set di dati è 0,2. Ciò significa che l'80% dei dati addestrerà il modello. E il restante 20% testerà le prestazioni del modello.

Creazione della rete neurale

Creare un rete neurale con sei strati.

modello = Sequenziale()
model.add (Incorporamento(5000, 100, lunghezza_input=100))
modello.add (Conv1D(64, 5, attivazione='rilu'))
model.add (GlobalMaxPooling1D())
model.add (Dense(32, attivazione='rilu'))
model.add (Eliminazione(0.5))
model.add (Dense(3, attivazione='softmax'))
model.compile (ottimizzatore='Adamo', perdita='categorical_crossentropy', metriche=['precisione'])
modello.summary()

Il primo livello della rete neurale è un livello di incorporamento. Questo livello apprende una rappresentazione densa delle parole nel vocabolario. Il secondo livello è un livello Conv1D con 64 filtri e una dimensione del kernel di 5. Questo livello esegue operazioni di convoluzione sulle sequenze di input, utilizzando una piccola finestra scorrevole di dimensione 5.

Il terzo strato riduce la sequenza delle mappe caratteristiche a un singolo vettore. Prende il valore massimo su ciascuna mappa delle caratteristiche. Il quarto strato esegue una trasformazione lineare sul vettore di input. Il quinto livello imposta in modo casuale una frazione delle unità di input su 0 durante l'addestramento. Questo aiuta a prevenire l'overfitting. Il livello finale converte l'output in una distribuzione di probabilità nelle tre classi possibili: positiva, neutra e negativa.

Allenare la rete neurale

Adattare i set di addestramento e test al modello. Addestra il modello per dieci epoche. Puoi modificare il numero di epoche a tuo piacimento.

model.fit (x_treno, y_treno, epoche=10, batch_size=32, validation_data=(x_test, y_test))

Dopo ogni epoca, vengono valutate le prestazioni del modello sul set di test.

Valutazione delle prestazioni del modello addestrato

Usa il modello.predict() metodo per prevedere le etichette di sentiment per il set di test. Calcolare il punteggio di precisione utilizzando il punteggio_accuratezza() funzione da scikit-learn.

y_pred = np.argmax (model.predict (x_test), axis=-1)
stampa("Precisione:", precision_score (np.argmax (y_test, axis=-1), y_pred))

La precisione di questo modello è di circa l'84%.

Salvataggio del modello

Salvare il modello utilizzando il file modello.save() metodo. Utilizzare pickle per serializzare e salvare l'oggetto tokenizer.

modello.save('sentiment_analysis_model.h5')
con aprire('tokenizer.pickle', 'wb') COME maniglia:
 pickle.dump (tokenizer, handle, protocol=pickle. HIGHEST_PROTOCOL)

L'oggetto tokenizer tokenizzerà il tuo testo di input e lo preparerà per l'alimentazione al modello addestrato.

Utilizzo del modello per classificare il sentimento del proprio testo

Dopo aver creato e salvato il modello, puoi usarlo per classificare il sentimento del tuo testo. Innanzitutto, carica il modello e il tokenizer salvati.

# Carica il modello e il tokenizer salvati
importare keras
modello = keras.models.load_model('sentiment_analysis_model.h5')
con aprire('tokenizer.pickle', 'rb') COME maniglia:
 tokenizer = pickle.load (maniglia)

Definire una funzione per prevedere il sentimento del testo di input.

defpredict_sentiment(testo):
# Tokenize e riempi il testo di input
 text_sequence = tokenizer.texts_to_sequences([testo])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Fai una previsione utilizzando il modello addestrato
 predicted_rating = model.predict (text_sequence)[0]
Se np.argmax (predicted_rating) == 0:
ritorno'Negativo'
elif np.argmax (predicted_rating) == 1:
ritorno'Neutro'
altro:
ritorno'Positivo'

Infine, prevedi il tuo testo.

text_input = "Ho adorato il mio soggiorno in quell'hotel. Il personale è stato fantastico e la camera era fantastica!"
predict_sentiment = predict_sentiment (text_input)
stampa (predicted_sentiment)

Il sentimento previsto della recensione di cui sopra è il seguente:

Il modello è in grado di classificare correttamente i sentimenti di tutte e tre le recensioni.

Previsione dei sentimenti utilizzando modelli pre-addestrati

A volte nell'apprendimento automatico, potresti avere la sfida di trovare il set di dati giusto. Potresti anche non avere le risorse per creare il tuo set di dati. È qui che entrano in gioco i modelli pre-addestrati. Devi sapere come utilizzare la loro API e lasciarli a gestire il resto.