Zephyrnet-logo

Emoties classificeren in zinstekst met behulp van neurale netwerken

Datum:

Introductie

Het classificeren van emoties in zintekst met behulp van neurale netwerken omvat het toekennen van gevoelens aan een stuk tekst. Het kan worden bereikt door middel van technieken zoals neurale netwerken of op lexicon gebaseerde methoden. Neurale netwerken omvatten het trainen van een model op gelabelde tekstgegevens om emoties in nieuwe tekst te voorspellen. Op lexicon gebaseerde methoden gebruiken emotie-geassocieerde woordwoordenboeken. Hoewel het een uitdaging is, heeft de classificatie van tekstemoties tal van potentiële toepassingen.

Zintekst met behulp van neurale netwerken

Het hoofddoel van het classificeren van tekstemoties is:

  • Om de emotionele toestand van de auteur te begrijpen. Dit kan nuttig zijn in verschillende contexten, zoals klantenservice, gezondheidszorg en onderwijs.
  • Om de nauwkeurigheid van automatische vertaalsystemen te verbeteren. Machinevertalingssystemen hebben vaak moeite met het correct vertalen van tekst die emotioneel geladen is.
  • Nieuwe toepassingen ontwikkelen voor sociale media en andere online platformen. De classificatie van tekstemoties kan bijvoorbeeld worden gebruikt om inhoud aan gebruikers aan te bevelen op basis van hun emotionele toestand.

Op basis van deze doelen zullen we de emoties in zinstekst classificeren met behulp van het Neural Network-algoritme om een ​​model te ontwikkelen dat de emotionele toestand op tekst nauwkeurig kan classificeren. Dit artikel begeleidt u stap voor stap bij het classificeren van tekstgebruikersinvoer met specifieke emoties.

Inhoudsopgave

Stap 1: Bibliotheek importeren

import pandas as pd
import numpy as np
import keras
import tensorflow
from keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Embedding, Flatten, Dense

We importeren 'Tokenizer' om de tekst om te zetten in een reeks tokens. De 'pad_sequences' wordt gebruikt om sequenties op te vullen tot een vaste lengte. Het is noodzakelijk omdat neurale netwerken invoer van een vaste grootte verwachten. De 'LabelEncoder' wordt gebruikt om categorische gegevens om te zetten in numerieke gegevens. De Sequential wordt gebruikt om een ​​lineaire stapel lagen te creëren. Vervolgens wordt de 'Inbedding' gebruikt om woorden om te zetten in vectoren om de betekenis van woorden weer te geven. De 'Flatten' wordt gebruikt om een ​​multidimensionale tensor af te vlakken tot een 1D-tensor. Ten slotte wordt de 'Dense' gebruikt om een ​​niet-lineaire transformatie toe te passen op een invoertensor.

Stap 2: lees de gegevens

De dataset waarop Praveen heeft geüpload Kaggle is geschikt voor het classificeren van emoties in tekst, wat in dit geval zeer geschikt is. Ik heb het echter op mijn GitHub gezet om verdere analyse te vergemakkelijken.

url = "https://raw.githubusercontent.com/ataislucky/Data-Science/main/dataset/emotion_train.txt"
data = pd.read_csv(url, sep=';')
data.columns = ["Text", "Emotions"]
print(data.head())
Gegevensoverzicht | Zintekst met behulp van neurale netwerken
Gegevensoverzicht

De code beschrijft hoe je een tekstbestand van een URL leest en opslaat in een Pandas DataFrame. Het tekstbestand bevat een lijst met zinnen en de emotielabels. De dataset die we gebruiken bestaat dus maar uit twee kolommen.

Stap 3: Voorverwerking van gegevens

De voorbewerking van gegevens is een belangrijke stap in de classificatie van tekst emoties. Dit omvat het proces van het opschonen en voorbereiden van de gegevens voor gebruik door machine learning-modellen. Enkele gebruikelijke stappen voor het voorbewerken van gegevens voor de classificatie van tekstemoties zijn onder meer tokenisatie, het verwijderen van stopwoorden, lemmatisering, enz. Over het algemeen zijn de uitdagingen bij het uitvoeren van het initiële verwerkingsproces het opschonen van gegevens, gegevensselectie en gegevensindelingen.

De tokenizer is een functie die een tekstreeks opsplitst in afzonderlijke woorden of tokens. Om tekenreeksen te markeren, moet daarom eerst het gegevenstype van de tekenreeks worden gewijzigd in een lijst. Dit komt omdat een lijst een verzameling objecten is en elk object in een lijst een woord of een token kan zijn.

texts = data["Text"].tolist()
labels = data["Emotions"].tolist()

Het tokenizer-object wordt vervolgens uitgelijnd met de tekstlijst. Het is bedoeld om unieke tokens in tekstgegevens te leren. Door tekstgegevens te tokeniseren, kunnen tokenizer-objecten tekstgegevens converteren naar een indeling die bruikbaar is voor machine learning-modellen.

# Tokenize the text data
tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)

Nu hoeven we alleen maar de sequenties van gelijke lengte op elkaar te leggen en ze in het neurale netwerk te voeren. Zo kunnen we een reeks teksten in lagen plaatsen zodat ze dezelfde lengte hebben:

sequences = tokenizer.texts_to_sequences(texts)
max_length = max([len(seq) for seq in sequences])
padded_sequences = pad_sequences(sequences, maxlen=max_length)

Vervolgens gebruiken we de label-encodermethode om het gegevenstype om te zetten van tekenreeks naar numerieke gegevens.

# Encode the string labels to integers
label_encoder = LabelEncoder()
labels = label_encoder.fit_transform(labels)

Vervolgens voeren we one-hot codering uit om categorische gegevens weer te geven in een machine learning-model. Dit komt omdat veel machine learning-modellen, zoals neurale netwerken, verwachten dat invoergegevens een numerieke indeling hebben. Laten we het doen.

# One-hot encode the labels
one_hot_labels = keras.utils.to_categorical(labels)

Stap 4: Model bouwen en voorspellingen doen

Na het doorlopen van de voorbewerking gaan we aan de slag machine learning-modellen.
We kunnen een techniek implementeren, namelijk het splitsen van de dataset in een trainingsset en een testset, om het eenvoudiger te maken om modelprestaties te beoordelen op gegevens die nog nooit eerder zijn gezien. De mogelijkheid om te verifiëren dat het model niet te veel past in de trainingsset met gegevens, maakt dit cruciaal.

# Split the data into training and testing sets
xtrain, xtest, ytrain, ytest = train_test_split(padded_sequences, one_hot_labels, test_size=0.2)

Laten we nu de neurale netwerkarchitectuur definiëren om het model te trainen en emoties te classificeren.

# Define the model
model = Sequential()
model.add(Embedding(input_dim=len(tokenizer.word_index) + 1, output_dim=128, input_length=max_length))
model.add(Flatten())
model.add(Dense(units=128, activation="relu"))
model.add(Dense(units=len(one_hot_labels[0]), activation="softmax")) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(xtrain, ytrain, epochs=10, batch_size=32, validation_data=(xtest, ytest))
Modeltraining | Zintekst met behulp van neurale netwerken
Model opleiding

Het model wordt gedurende tien tijdvakken getraind, waarbij elk tijdvak bestaat uit het trainen van het model op trainingsgegevens en het vervolgens beoordelen op validatiegegevens. Gegevensvalidatie wordt gebruikt om de prestaties van het model te beoordelen aan de hand van voorheen ongeziene gegevens. Dit is belangrijk omdat het ervoor zorgt dat het model niet te veel past bij de trainingsgegevens.

Nadat het model is getraind, is het klaar om te worden gebruikt om voorspellingen te doen over nieuwe gegevens.

#input_text from user
input_text = input("Please input sentence here : ") # Preprocess the input text
input_sequence = tokenizer.texts_to_sequences([input_text])
padded_input_sequence = pad_sequences(input_sequence, maxlen=max_length)
prediction = model.predict(padded_input_sequence)
predicted_label = label_encoder.inverse_transform([np.argmax(prediction[0])])
print(predicted_label)
Model testen
Model testen

In de resulterende uitvoer voert de gebruiker de zin in: "Ze is vandaag niet gekomen omdat haar moeder gisteren is overleden". Het model voorspelt dat het sentiment van de zin verdriet is.

Het is getraind op een dataset van zinnen die zijn gelabeld met hun gevoelens. Dit model leert bepaalde woorden en zinnen te associëren met bepaalde gevoelens. De term 'dood' wordt vaak in verband gebracht met verdriet. Wanneer het algoritme het woord 'dood' in een zin detecteert, voorspelt het hoogstwaarschijnlijk verdriet.

Conclusie

Dit artikel begint met voorverwerking, waaronder het wijzigen van het dataframe-formaat in een lijst, het tokenisatieproces, encoderlabels, enz. Overigens hebben we in dit bericht het volgende besproken:

  • Emoties classificeren in zinstekst met behulp van neurale netwerken emoties kunnen categoriseren die worden uitgedrukt in tekstuele gegevens.
  • Feature engineering speelt een belangrijke rol bij de classificatie van tekstemoties, omdat het extraheren van relevante kenmerken uit tekst de modelprestaties kan verbeteren.
  • Train een neuraal netwerkmodel op gelabelde tekstgegevens om archetypen en associaties tussen tekst en bijbehorende emoties te leren.
  • Neurale netwerken bieden het voordeel dat ze complexe patronen en relaties in tekstgegevens vastleggen, waardoor een nauwkeurige classificatie van emoties mogelijk wordt.

Over het algemeen biedt dit artikel een uitgebreide gids voor het classificeren van tekstemoties met een neuraal netwerk met behulp van Python. Stel gerust waardevolle vragen in de opmerkingen hieronder. De volledige code is hier..

spot_img

Laatste intelligentie

spot_img