Construirea propriului model de analiză a sentimentelor poate părea descurajantă. Acest ghid vă prezintă pașii pentru a începe.
Analiza sentimentelor este o tehnică de procesare a limbajului natural (NLP) care identifică atitudinea din spatele unui text. Este, de asemenea, cunoscut sub numele de minerit de opinie. Scopul analizei sentimentelor este de a identifica dacă un anumit text are sentimente pozitive, negative sau neutre. Este utilizat pe scară largă de companii pentru a clasifica automat sentimentele în recenziile clienților. Analizarea unor volume mari de recenzii ajută la obținerea unor informații valoroase asupra preferințelor clienților.
Configurarea mediului
Trebuie să fii familiarizat cu Bazele Python a urma. Navigheaza catre Google Colab sau deschide Jupyter Notebook. Apoi creați un nou blocnotes. Executați următoarea comandă pentru a instala bibliotecile necesare în mediul dumneavoastră.
Codul sursă complet al acestui proiect este disponibil în acesta Depozitul GitHub.
! pip install tensorflow scikit-learn panda numpy pickle5
Veți folosi NumPy și biblioteca panda pentru manipularea setului de date. TensorFlow pentru crearea și antrenamentul modelului de învățare automată. Scikit-learn pentru împărțirea setului de date în seturi de instruire și testare. În cele din urmă, veți folosi pickle5 pentru a serializa și a salva obiectul tokenizer.
Importarea bibliotecilor necesare
Importați bibliotecile necesare pe care le veți folosi pentru a preprocesa datele și a crea modelul.
import numpy la fel de np
import panda la fel de pd
import tensorflow la fel de tf
din sklearn.model_selection import train_test_split
din sklearn.metrics import acucy_score
din tensorflow.keras.preprocesare.text import Tokenizer
din tensorflow.keras.preprocesare.secvență import pad_sequences
din tensorflow.keras.modele import Secvenţial
din tensorflow.keras.straturi import Încorporare, Conv1D, GlobalMaxPooling1D, Dens, Dropout
import murat5 la fel de murăturăVeți folosi clasele pe care le importați din module mai târziu în cod.
Se încarcă setul de date
Aici, veți folosi setul de date Trip Advisor Hotel Reviews de la Kaggle pentru a construi modelul de analiză a sentimentelor.
df = pd.read_csv(„/content/tripadvisor_hotel_reviews.csv”)
imprimare (df.head())Încărcați setul de date și imprimați primele cinci rânduri. Imprimarea primelor cinci rânduri vă va ajuta să verificați numele coloanelor setului de date. Acest lucru va fi crucial la preprocesarea setului de date.
Setul de date Trip Advisor Hotel Reviews are o coloană index, o coloană Review și o coloană Evaluare.
Preprocesarea datelor
Selectează Revizuire și Evaluare coloane din setul de date. Creați o nouă coloană bazată pe coloana Evaluare și denumiți-o sentiment. Dacă evaluarea este mai mare de 3, etichetați sentimentul ca pozitiv. Dacă ratingul este mai mic de 3, etichetați-l ca negativ. Dacă ratingul este exact 3, etichetați-l ca neutru.
Selectați numai coloanele Review și sentiment din setul de date. Amestecați rândurile aleatoriu și resetați indexul cadrului de date. Schimbarea și resetarea asigură distribuirea aleatorie a datelor, ceea ce este necesar pentru formarea și testarea adecvată a modelului.
df = df[['Revizuire', „Evaluare”]]
df['sentiment'] = df[„Evaluare”].aplica(lambda X: 'pozitiv'dacă x > 3
altfel'negativ'dacă x < 3
altfel'neutru')
df = df[['Revizuire', 'sentiment']]
df = df.probă (frac=1).reset_index (drop=Adevărat)Convertiți Revizuire text într-o secvență de numere întregi folosind tokenizer. Aceasta creează un dicționar al cuvintelor unice prezente în textul Review și mapează fiecare cuvânt la o valoare întreagă unică. Folosește pad_sequences funcția de la Keras pentru a se asigura că toate secvențele de revizuire au aceeași lungime.
tokenizer = Tokenizer (num_words=5000, oov_token='' )
tokenizer.fit_on_texts (df['Revizuire'])
word_index = tokenizer.word_index
secvențe = tokenizer.texts_to_sequences (df['Revizuire'])
padded_sequences = pad_sequences (secvențe, maxlen=100, trunchiind='post')Convertiți etichetele de sentiment în codificare One-hot.
sentiment_labels = pd.get_dummies (df['sentiment']).valori
Codificarea one-hot reprezintă date categorice într-un format cu care este mai ușor de lucrat pentru modelele dvs.
Împărțirea setului de date în seturi de instruire și testare
Utilizați scikit-learn pentru a împărți aleatoriu setul de date în seturi de instruire și testare. Veți folosi setul de antrenament pentru a instrui modelul pentru a clasifica sentimentele recenziilor. Și veți folosi setul de testare pentru a accesa cât de bun este modelul la clasificarea noilor recenzii nevăzute.
x_train, x_test, y_train, y_test = tren_test_split (secvențe_căptușite, etichete_sentiment, dimensiune_test=0.2)
Mărimea împărțirii setului de date este 0,2. Aceasta înseamnă că 80% din date vor antrena modelul. Iar restul de 20% vor testa performanța modelului.
Crearea rețelei neuronale
Creeaza o Retea neurala cu șase straturi.
model = Sequential()
model.add (Incorporare(5000, 100, lungime_intrare=100))
model.add (Conv1D(64, 5, activare='relu'))
model.add (GlobalMaxPooling1D())
model.add (Dens(32, activare='relu'))
model.add (Renunțare(0.5))
model.add (Dens(3, activare="softmax"))
model.compile (optimizator='adam', pierdere='categoric_crossentropie', metrics=['precizie'])
model.summary()
Primul strat al rețelei neuronale este un strat de încorporare. Acest strat învață o reprezentare densă a cuvintelor din vocabular. Al doilea strat este un strat Conv1D cu 64 de filtre și o dimensiune a nucleului de 5. Acest strat efectuează operații de convoluție pe secvențele de intrare, folosind o fereastră glisantă mică de dimensiunea 5.
Al treilea strat reduce secvența hărților de caracteristici la un singur vector. Acesta ia valoarea maximă pentru fiecare hartă caracteristică. Al patrulea strat efectuează o transformare liniară pe vectorul de intrare. Al cincilea strat setează aleatoriu o parte din unitățile de intrare la 0 în timpul antrenamentului. Acest lucru ajută la prevenirea supraajustării. Stratul final convertește rezultatul într-o distribuție de probabilitate pe cele trei clase posibile: pozitiv, neutru și negativ.
Antrenarea rețelei neuronale
Potriviți seturile de antrenament și testare la model. Antrenează modelul timp de zece epoci. Puteți modifica numărul de epoci după bunul plac.
model.fit (x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))
După fiecare epocă, se evaluează performanța modelului pe setul de testare.
Evaluarea performanței modelului antrenat
Folosește model.predict() metodă de a prezice etichetele de sentiment pentru setul de testare. Calculați scorul de precizie folosind acucy_score() funcția din scikit-learn.
y_pred = np.argmax (model.predict (x_test), axa=-1)
imprimare("Precizie:", scorul de precizie (np.argmax (test_y, axa=-1), y_pred))
Precizia acestui model este de aproximativ 84%.
Salvarea modelului
Salvați modelul folosind model.save() metodă. Utilizați pickle pentru a serializa și a salva obiectul tokenizer.
model.save(„sentiment_analysis_model.h5”)
cu deschis(„tokenizer.pickle”, 'wb') la fel de mâner:
pickle.dump (tokenizer, mâner, protocol=pickle. HIGHEST_PROTOCOL)Obiectul tokenizer va tokeniza propriul text de intrare și îl va pregăti pentru alimentarea modelului antrenat.
Utilizarea modelului pentru a clasifica sentimentul propriului text
După crearea și salvarea modelului, îl puteți folosi pentru a clasifica sentimentul propriului text. Mai întâi, încărcați modelul salvat și tokenizerul.
# Încărcați modelul salvat și tokenizerul
import keras
model = keras.models.load_model(„sentiment_analysis_model.h5”)
cu deschis(„tokenizer.pickle”, „rb”) la fel de mâner:
tokenizer = pickle.load (mâner)
Definiți o funcție pentru a prezice sentimentul textului introdus.
defprezice_sentiment(text):
# Tokenizați și introduceți textul introdus
text_sequence = tokenizer.texts_to_sequences([text])
text_sequence = pad_sequences (text_sequence, maxlen=100)
# Faceți o predicție folosind modelul antrenat
predicted_rating = model.predict (secvență_text)[0]
dacă np.argmax (predicted_rating) == 0:
întoarcere'Negativ'
elif np.argmax (predicted_rating) == 1:
întoarcere'Neutru'
altfel:
întoarcere'Pozitiv'
În cele din urmă, preziceți propriul text.
text_input = „Mi-a plăcut foarte mult șederea mea la acel hotel. Personalul a fost extraordinar, iar camera fantastică!”
predicted_sentiment = predict_sentiment (intrare_text)
imprimare (predicted_sentiment)Sentimentul prezis al recenziei de mai sus este următorul:
Modelul este capabil să clasifice corect sentimentele tuturor celor trei recenzii.
Prezicerea sentimentelor folosind modele pre-antrenate
Uneori, în învățarea automată, este posibil să aveți provocarea de a găsi setul de date potrivit. De asemenea, este posibil să vă lipsească resursele pentru a vă crea propriul set de date. Aici intervin modelele pre-antrenate. Trebuie să știi cum să folosești API-ul lor și să-i lași să se ocupe de restul.