Hoe u vanuit het niets een sentimentanalysemodel maakt

Sentimentanalyse is een natuurlijke taalverwerkingstechniek (NLP) die de houding achter een tekst identificeert. Het wordt ook wel opiniemining genoemd. Het doel van sentimentanalyse is om vast te stellen of een bepaalde tekst een positief, negatief of neutraal sentiment heeft. Het wordt veel gebruikt door bedrijven om het sentiment in klantbeoordelingen automatisch te classificeren. Het analyseren van grote hoeveelheden beoordelingen helpt waardevolle inzichten te krijgen in de voorkeuren van klanten.

Uw omgeving instellen

Je moet bekend zijn met Python-basisprincipes door te zetten. Navigeren naar Google Colab of open Jupyter Notebook. Maak vervolgens een nieuw notitieblok aan. Voer de volgende opdracht uit om de vereiste bibliotheken in uw omgeving te installeren.

De volledige broncode van dit project is hierin beschikbaar GitHub-opslagplaats.

! pip install tensorflow scikit-leer panda's numpy pickle5

U gebruikt NumPy en pandas-bibliotheek voor het manipuleren van de dataset. TensorFlow voor het maken en trainen van het machine learning-model. Scikit-learn voor het splitsen van de dataset in trainings- en testsets. Ten slotte gebruikt u pickle5 om het tokenizer-object te serialiseren en op te slaan.

De vereiste bibliotheken importeren

Importeer de benodigde bibliotheken die u gaat gebruiken om de gegevens voor te verwerken en het model te maken.

importeren onnozel als np
importeren panda's als pd
importeren tensorstroom als tf
van sklearn.model_selection importeren train_test_split
van sleren.metrics importeren nauwkeurigheid_score
van tensorflow.keras.preprocessing.text importeren Tokenizer
van tensorflow.keras.preprocessing.sequence importeren pad_sequenties
van tensorflow.keras.models importeren Opeenvolgend
van tensorflow.keras.lagen importeren Inbedding, Conv1D, GlobalMaxPooling1D, Dense, Dropout
importeren augurk5 als augurk

U gebruikt de klassen die u importeert uit de modules later in de code.

Laden van de dataset

Hier gebruikt u de dataset Trip Advisor Hotelbeoordelingen van Kaggle om het sentimentanalysemodel te bouwen.

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

Laad de dataset en druk de eerste vijf rijen af. Door de eerste vijf rijen af ​​te drukken, kunt u de kolomnamen van uw dataset controleren. Dit is cruciaal bij het voorbewerken van de dataset.

De dataset Trip Advisor Hotelbeoordelingen heeft een indexkolom, een beoordelingskolom en een beoordelingskolom.

Voorbewerking van gegevens

Selecteer de Beoordeling En Beoordeling kolommen uit de dataset. Maak een nieuwe kolom op basis van de kolom Waardering en geef deze een naam sentiment. Als de beoordeling groter is dan 3, label dan het sentiment als positief. Als de beoordeling lager is dan 3, label deze dan als negatief. Als de beoordeling precies 3 is, label het dan als neutrale.

Selecteer alleen de kolommen Review en Sentiment uit de dataset. Schud de rijen willekeurig en reset de index van het dataframe. Schudden en opnieuw instellen zorgen ervoor dat de gegevens willekeurig worden verdeeld, wat nodig is voor een goede training en het testen van het model.

df = df[['Beoordeling', 'Beoordeling']]
df['sentiment'] = df['Beoordeling'].toepassen(lambda X: 'positief'als x > 3
anders'negatief'als x < 3
anders'neutrale')
df = df[['Beoordeling', 'sentiment']]
df = df.sample (frac=1).reset_index (drop=WAAR)

Zet de Beoordeling tekst in een reeks gehele getallen met behulp van de tokenizer. Hierdoor wordt een woordenboek gemaakt van de unieke woorden die aanwezig zijn in de Review-tekst en wordt elk woord toegewezen aan een uniek geheel getal. Gebruik de pad_sequenties functie van Keras om ervoor te zorgen dat alle beoordelingsreeksen dezelfde lengte hebben.

tokenizer = Tokenizer (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Beoordeling'])
word_index = tokenizer.word_index
sequenties = tokenizer.texts_to_sequences (df['Beoordeling'])
opgevulde_reeksen = pad_reeksen (reeksen, maxlen=100, afkappen='na')

Converteer de sentimentlabels naar One-hot-codering.

sentiment_labels = pd.get_dummies (df['sentiment']).waarden

One-hot-codering vertegenwoordigt categorische gegevens in een indeling waarmee uw modellen gemakkelijker kunnen werken.

De dataset splitsen in trainings- en testsets

Gebruik scikit-learn om de dataset willekeurig te splitsen in trainings- en testsets. Met de trainingsset train je het model om de sentimenten van de reviews te classificeren. En u zult de testset gebruiken om erachter te komen hoe goed het model is in het classificeren van nieuwe ongeziene beoordelingen.

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

De splitsingsgrootte van de dataset is 0,2. Dit betekent dat 80% van de data het model gaat trainen. En de overige 20% test de prestaties van het model.

Het neurale netwerk creëren

Maak een neuraal netwerk met zes lagen.

model = Opeenvolgend()
model.add (Insluiten(5000, 100, invoer_lengte=100))
model.add (Conv1D(64, 5, activering='relu'))
model.add (GlobalMaxPooling1D())
model.add (Dense(32, activering='relu'))
model.add (Dropout(0.5))
model.add (Dense(3, activering='softmax'))
model.compile (optimizer='Adam', verlies='categorische_crossentropie', statistieken=['nauwkeurigheid'])
Model Samenvatting()

De eerste laag van het neurale netwerk is een inbeddingslaag. Deze laag leert een dichte weergave van woorden in het vocabulaire. De tweede laag is een Conv1D-laag met 64 filters en een kernelgrootte van 5. Deze laag voert convolutiebewerkingen uit op de invoerreeksen, met behulp van een klein schuifvenster van grootte 5.

De derde laag reduceert de opeenvolging van feature maps tot een enkele vector. Het neemt de maximale waarde over elke functiekaart. De vierde laag voert een lineaire transformatie uit op de invoervector. De vijfde laag stelt willekeurig een fractie van de invoereenheden in op 0 tijdens de training. Dit helpt overfitting te voorkomen. De laatste laag zet de uitvoer om in een kansverdeling over de drie mogelijke klassen: positief, neutraal en negatief.

Trainen van het neurale netwerk

Monteer de trainings- en testsets op het model. Train het model gedurende tien tijdperken. U kunt het aantal tijdperken naar wens wijzigen.

model.fit (x_train, y_train, epochs=10, batchgrootte=32, validation_data=(x_test, y_test))

Na elke periode worden de prestaties van het model op de testset geëvalueerd.

Evalueren van de prestaties van het getrainde model

Gebruik de model.predict() methode om de sentimentlabels voor de testset te voorspellen. Bereken de nauwkeurigheidsscore met behulp van de nauwkeurigheid_score() functie van scikit-learn.

y_pred = np.argmax (model.predict (x_test), as=-1)
afdrukken("Nauwkeurigheid:", nauwkeurigheid_score (np.argmax (y_test, as=-1), y_pred))

De nauwkeurigheid van dit model is ongeveer 84%.

Het model opslaan

Sla het model op met behulp van de model.save() methode. Gebruik augurk om het tokenizer-object te serialiseren en op te slaan.

model.opslaan('sentiment_analysis_model.h5')
met open('tokenizer.augurk', 'wb') als hendel:
 pickle.dump (tokenizer, handle, protocol=pickle. HIGHEST_PROTOCOL)

Het tokenizer-object tokeniseert uw eigen invoertekst en bereidt deze voor op invoer naar het getrainde model.

Het model gebruiken om het sentiment van uw eigen tekst te classificeren

Nadat u het model hebt gemaakt en opgeslagen, kunt u het gebruiken om het sentiment van uw eigen tekst te classificeren. Laad eerst het opgeslagen model en de tokenizer.

# Laad het opgeslagen model en de tokenizer
importeren kera's
model = keras.models.load_model('sentiment_analysis_model.h5')
met open('tokenizer.augurk', 'rb') als hendel:
 tokenizer = pickle.load (handvat)

Definieer een functie om het sentiment van invoertekst te voorspellen.

defpredict_sentiment(tekst):
# Tokenize en pad de invoertekst
 text_sequence = tokenizer.texts_to_sequences([tekst])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Maak een voorspelling met behulp van het getrainde model
 predicted_rating = model.predict (text_sequence)[0]
als np.argmax (predicted_rating) == 0:
opbrengst'Negatief'
elif np.argmax (predicted_rating) == 1:
opbrengst'Neutrale'
anders:
opbrengst'Positief'

Voorspel tot slot je eigen tekst.

tekst_invoer = "Ik hield absoluut van mijn verblijf in dat hotel. Het personeel was geweldig en de kamer was fantastisch!"
predicted_sentiment = predict_sentiment (text_input)
afdrukken (predicted_sentiment)

Het voorspelde sentiment van de bovenstaande recensie is als volgt:

Het model is in staat om de sentimenten van alle drie de beoordelingen correct te classificeren.

Gevoelens voorspellen met vooraf getrainde modellen

Soms heb je bij machine learning de uitdaging om de juiste dataset te vinden. Mogelijk ontbreekt het u ook aan de middelen om uw eigen dataset te maken. Dit is waar vooraf getrainde modellen om de hoek komen kijken. Je moet weten hoe je hun API moet gebruiken en de rest aan hen overlaten.