Att bygga en egen modell för sentimentanalys kan verka skrämmande. Den här guiden leder dig genom stegen för att komma igång.

Sentimentanalys är en naturlig språkbehandlingsteknik (NLP) som identifierar attityden bakom en text. Det är också känt som opinion mining. Målet med sentimentanalys är att identifiera om en viss text har positiva, negativa eller neutrala känslor. Det används ofta av företag för att automatiskt klassificera känslan i kundrecensioner. Att analysera stora mängder recensioner hjälper till att få värdefulla insikter om kundernas preferenser.

Ställa in din miljö

Du måste vara bekant med Grunderna i Python att följa igenom. Navigera till Google Colab eller öppna Jupyter Notebook. Skapa sedan en ny anteckningsbok. Utför följande kommando för att installera de nödvändiga biblioteken i din miljö.

Den fullständiga källkoden för detta projekt är tillgänglig i denna GitHub-förråd.

! pip installera tensorflow scikit-lär dig pandas numpy pickle5

Du kommer att använda NumPy och pandas bibliotek för att manipulera datasetet

instagram viewer
. TensorFlow för att skapa och träna maskininlärningsmodellen. Scikit-lär för att dela upp datasetet i tränings- och testset. Slutligen kommer du att använda pickle5 för att serialisera och spara tokenizer-objektet.

Importera de obligatoriska biblioteken

Importera de nödvändiga biblioteken som du kommer att använda för att förbehandla data och skapa modellen.

importera numpy som np
importera pandor som pd
importera tensorflöde som tf
från sklearn.model_selection importera train_test_split
från sklearn.metrics importera precision_score
från tensorflow.keras.preprocessing.text importera Tokenizer
från tensorflow.keras.förbearbetningssekvens importera pad_sekvenser
från tensorflow.keras.modeller importera Sekventiell
från tensorflow.keras.lager importera Inbäddning, Conv1D, GlobalMaxPooling1D, Dense, Dropout
importera pickle5 som ättikslag

Du kommer att använda de klasser du importerar från modulerna längre fram i koden.

Laddar datamängden

Här kommer du att använda datauppsättningen Trip Advisor hotellrecensioner från Kuggla att bygga sentimentanalysmodellen.

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

Ladda datauppsättningen och skriv ut dess första fem rader. Att skriva ut de första fem raderna hjälper dig att kontrollera kolumnnamnen på din datauppsättning. Detta kommer att vara avgörande vid förbearbetning av datamängden.

Datauppsättningen Trip Advisor hotellrecensioner har en indexkolumn, en recensionskolumn och en klassificeringskolumn.

Dataförbehandling

Välj Recension och Betyg kolumner från datamängden. Skapa en ny kolumn baserad på kolumnen Betyg och namnge den känsla. Om betyget är högre än 3, märk känslan som positiv. Om betyget är mindre än 3, märk det som negativ. Om betyget är exakt 3, märk det som neutral.

Välj endast gransknings- och sentimentkolumnerna från datamängden. Blanda raderna slumpmässigt och återställ dataramens index. Blandning och återställning säkerställer att data distribueras slumpmässigt, vilket är nödvändigt för korrekt träning och testning av modellen.

df = df[['Recension', 'Betyg']]
df['känsla'] = df['Betyg'].tillämpa(lambda x: 'positiv'om x > 3
annan'negativ'om x < 3
annan'neutral')
df = df[['Recension', 'känsla']]
df = df.sample (frac=1).reset_index (drop=Sann)

Konvertera Recension text till en sekvens av heltal med hjälp av tokenizern. Detta skapar en ordbok över de unika orden som finns i granskningstexten och mappar varje ord till ett unikt heltalsvärde. Använd pad_sekvenser funktion från Keras för att säkerställa att alla recensionssekvenser har samma längd.

tokenizer = Tokenizer (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Recension'])
word_index = tokenizer.word_index
sekvenser = tokenizer.texts_to_sequences (df['Recension'])
padded_sequences = padde_sequences (sekvenser, maxlen=100, trunkering='posta')

Konvertera sentimentetiketterna till One-hot-kodning.

sentiment_labels = pd.get_dummies (df['känsla']).värden

One-hot encoding representerar kategorisk data i ett format som är lättare för dina modeller att arbeta med.

Dela upp datamängden i tränings- och testset

Använd scikit-learn för att slumpmässigt dela upp datasetet i tränings- och testset. Du kommer att använda träningssetet för att träna modellen för att klassificera känslorna i recensionerna. Och du kommer att använda testsetet för att komma åt hur bra modellen är på att klassificera nya osynliga recensioner.

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

Datauppsättningens uppdelningsstorlek är 0,2. Det betyder att 80 % av datan kommer att träna modellen. Och resten 20% kommer att testa modellens prestanda.

Skapa det neurala nätverket

Skapa en neuralt nätverk med sex lager.

modell = Sequential()
model.add (Inbäddning(5000, 100, input_length=100))
model.add (Conv1D(64, 5, aktivering='relu'))
model.add (GlobalMaxPooling1D())
model.add (Dense(32, aktivering='relu'))
model.add (Dropout(0.5))
model.add (Dense(3, aktivering='softmax'))
model.compile (optimizer='Adam', förlust="categorical_crossentropy", statistik=['noggrannhet'])
model.summary()

Det första lagret i det neurala nätverket är ett inbäddningslager. Detta lager lär sig en tät representation av ord i vokabulären. Det andra lagret är ett Conv1D-lager med 64 filter och en kärnstorlek på 5. Detta lager utför faltningsoperationer på inmatningssekvenserna med hjälp av ett litet skjutfönster i storlek 5.

Det tredje lagret reducerar sekvensen av funktionskartor till en enda vektor. Den tar det maximala värdet över varje funktionskarta. Det fjärde lagret utför en linjär transformation på ingångsvektorn. Det femte lagret sätter slumpmässigt en bråkdel av inmatningsenheterna till 0 under träning. Detta hjälper till att förhindra övermontering. Det sista lagret omvandlar utdata till en sannolikhetsfördelning över de tre möjliga klasserna: positiv, neutral och negativ.

Utbildning av det neurala nätverket

Anpassa tränings- och testseten till modellen. Träna modellen i tio epoker. Du kan ändra antalet epoker efter eget tycke.

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

Efter varje epok utvärderas modellens prestanda på testsetet.

Utvärdering av den tränade modellens prestanda

Använd model.predict() metod för att förutsäga sentimentetiketterna för testsetet. Beräkna noggrannhetspoängen med hjälp av precision_score() funktion från scikit-learn.

y_pred = np.argmax (model.predict (x_test), axis=-1)
skriva ut("Noggrannhet:", precision_score (np.argmax (y_test, axis=-1), y_pred))

Noggrannheten för denna modell är cirka 84%.

Sparar modellen

Spara modellen med hjälp av model.save() metod. Använd pickle för att serialisera och spara tokenizer-objektet.

model.save("sentiment_analysis_model.h5")
med öppen("tokenizer.pickle", 'wb') som hantera:
 pickle.dump (tokenizer, handtag, protocol=pickle. HIGHEST_PROTOCOL)

Tokenizer-objektet kommer att tokenisera din egen inmatade text och förbereda den för matning till den tränade modellen.

Använda modellen för att klassificera känslan av din egen text

När du har skapat och sparat modellen kan du använda den för att klassificera känslan i din egen text. Ladda först den sparade modellen och tokenizern.

# Ladda den sparade modellen och tokenizern
importera keras
model = keras.models.load_model("sentiment_analysis_model.h5")
med öppen("tokenizer.pickle", 'rb') som hantera:
 tokenizer = pickle.load (handtag)

Definiera en funktion för att förutsäga känslan av inmatad text.

defförutsäga_sentiment(text):
# Tokenisera och fylla på inmatningstexten
 text_sequence = tokenizer.texts_to_sequences([text])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Gör en förutsägelse med hjälp av den tränade modellen
 predicted_rating = model.predict (text_sequence)[0]
om np.argmax (predicted_rating) == 0:
lämna tillbaka'Negativ'
elif np.argmax (predicted_rating) == 1:
lämna tillbaka'Neutral'
annan:
lämna tillbaka'Positiv'

Slutligen, förutsäg din egen text.

text_input = "Jag älskade absolut min vistelse på det hotellet. Personalen var fantastisk och rummet var fantastiskt!"
predicted_sentiment = predict_sentiment (text_input)
print (predicted_sentiment)

Den förutspådda känslan av recensionen ovan är som följer:

Modellen kan klassificera känslorna för alla tre recensioner korrekt.

Förutsäga känslor med hjälp av förtränade modeller

Ibland i maskininlärning kan du ha utmaningen att hitta rätt datauppsättning. Du kanske också saknar resurser för att skapa din egen datauppsättning. Det är här förutbildade modeller kommer in. Du måste veta hur man använder deras API och låta dem sköta resten.