Sentiment-Analyse mit Twitter-Daten durchführen!

Daten sind Wasser, sie zu reinigen, um sie essbar zu machen, ist eine Funktion des Datenanalysten: Kashish Rastogi

Inhaltsverzeichnis:

• Problemstellung
• Beschreibung der Daten
• Textreinigung mit NLP
• Finden Sie heraus, ob der Text: mit Platz
• Textbereinigung mit Präprozessorbibliothek
• Stimmungsanalyse der Daten
• Datenvisualisierung

Ich übernehme die verfügbaren Twitter-Daten hier auf der DataPeaker-Plattform.

Bibliotheken importieren

Pandas als pd importieren
Importieren
importiere plotly.express als px
nltk importieren
spacig importieren

Ich lade ein kleines geräumiges Modell. Es gibt 3 Modellgrößen, die Sie herunterladen können spacy (wenig, mittel und groß) nach Ihren Anforderungen.

nlp = spacy.load('en_core_web_sm')

Die Daten sehen so aus

df = pd.read_csv(r'Location of File')
von DF['id']
df.kopf(5)

Problemstellung

Der entscheidende Punkt ist, die Stimmung der Textdaten zu finden. Der bereitgestellte Text stammt von Kunden verschiedener Technologiefirmen, die Telefone herstellen, Laptops, Gadgets, etc. Die Aufgabe besteht darin, festzustellen, ob die Tweets eine negative Stimmung haben, positiv oder neutral gegenüber dem Unternehmen.

Beschreibung der Daten

Etikett: Die Beschriftungsspalte hat 2 einzigartige Werte 0 Ja 1.

Pio: Die Tweet-Spalten enthalten den von den Kunden bereitgestellten Text

Datenmanipulation

Finden Sie die Form der Daten

Es gibt 2 Spalten und 7920 Reihen.

df.shape

Tweets-Klassifizierung

fig = px.pie(df, name=df.label, Loch = 0,7, Titel="Tweets-Klassifizierung",
             Höhe=250, color_discrete_sequence=px.colors.qualitative.T10)
fig.update_layout(Rand = Diktat(t=100, b=40, l=60, r=40), 
                  plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                  title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                  font=dict(Farbe="#8a8d93"),
                  )

Nehmen Sie sich einen Moment Zeit und sehen Sie sich die Daten an. Siehst du?

• Es gibt kein zu analysierendes Markup, ist Klartext (yaa!).
• Es gibt viele Dinge zu filtern wie:

• • Twitter-Kennung ist maskiert (@Nutzername), was nützt uns nichts.
  • Etiketten
  • Links
  • Spezielle Charaktere
• Wir sehen, dass der Text einen numerischen Wert hat.
• Es gibt viele Tippfehler und Verkürzungen im Text.
• Es gibt viele Firmennamen (Sony, Apfel).
• Der Text ist nicht in Kleinbuchstaben

Lass uns den Text aufräumen

Finden Sie heraus, ob der Text:

• Twitter-Benutzernamen
• Etiketten
• Zahlenwerte
• Links

Löschen, wenn der Text hat:

• Twitter-Benutzername, da Sie zu diesem Zeitpunkt keine zusätzlichen Informationen angeben, da aus Sicherheitsgründen, Benutzername wurde in fiktive Namen geändert
• Hashtag-Wörter geben dem Text in der Stimmungsanalyse keine sinnvolle Bedeutung.
• Der URL-Link fügt dem Text auch keine Informationen hinzu.
• Entfernen
  • Bewertung für sauberen Text
  • Wörter kürzer als 3 sind sicher aus dem Text zu entfernen, da die Wörter so sein werden wie (Soja, Soja, es ist) die keine spezifische Bedeutung oder Funktion im Text haben
  • Stoppwörter sind immer die beste Option zum Entfernen

Entfernen Nutzername des Textes

Erstellen Sie eine Funktion zum Entfernen des Benutzernamens aus dem Text mit dem einfachen finde alle() Panda-Funktion. Wo werden wir die Wörter auswählen, die mit beginnen? ‚@‘.

def remove_pattern(input_txt):
    r = wiederfinden(R"@(w+)", input_txt)
    für ich in r:
        input_txt = re.sub(ich, '', input_txt)      
    return input_txt
df[''@_remove'] = np.vektorisieren(remove_pattern)(df['tweet'])
df[''@_remove'][:3]

Finden Etiketten im Text

Erstellen einer Funktion zum Extrahieren von Hashtags aus Text mit dem einfachen finde alle() Panda-Funktion. Wo werden wir die Wörter auswählen, die mit beginnen? ‚#‘ und speichern Sie sie in einem Datenrahmen.

hashtags = []
def hashtag_extract(x):
    # Schleife die Wörter im Tweet durch
    für ich in x:
        ht = re.findall(R"#(w+)", ich)
        hashtags.append(ht)
    Hashtags zurückgeben

Durch die Übergabefunktion und das Extrahieren von Hashtags können wir jetzt visualisieren, wie viele Hashtags es in positiven und negativen Tweets gibt

# Extrahieren von Hashtags aus Negativ-/Pos-Tweets
dff_0 = hashtag_extract(df['tweet'][df['label'] == 0])
dff_1 = hashtag_extract(df['tweet'][df['label'] == 1])
dff_all = hashtag_extract(df['tweet'][df['label']])
# Entschachtelungsliste
dff_0 = Summe(dff_0,[])
dff_1 = Summe(dff_1,[])
dff_all = Summe(dff_all,[])

Zählen der häufig verwendeten Hashtags bei Label = 0. FreqDist bedeutet, dass es uns sagt, wie oft dieses Wort im gesamten Dokument vorgekommen ist.

data_0 = nltk.FreqDist(dff_0)
data_0 = pd.DataFrame({'Hashtag': aufführen(data_0.keys()),
                  'Zählen': aufführen(data_0.values())}).sort_values(by='Count', aufsteigend=Falsch)
Daten_0[:5]

Wenn Sie mehr über Plotly und seine Verwendung erfahren möchten, Besuche ist Blog. Jedes Diagramm wird mit verschiedenen Parametern gut erklärt, die Sie beim Plotten von Diagrammen beachten müssen.

fig = px.bar(Daten_0[:30], x='Hashtag', y='Count', Höhe=250,
             Titel="Oberteil 30 Hashtags",
             color_discrete_sequence=px.colors.qualitative.T10)
fig.update_yaxes(showgrid=Falsch),
fig.update_xaxes(Kategoriereihenfolge ="total absteigend")
fig.update_traces(hovertemplate=Keine)
fig.update_layout(Rand = Diktat(t=100, b=0, l=60, r=40), 
                  Schwebemodus ="x vereint",
                  xaxis_tickangle = 300,
                  xaxis_title=" ", yaxis_title=" ",
                  plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                  title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                  font=dict(Farbe="#8a8d93")
                  )

Übergeben von Text

Sätze = nlp(str(Text))

Finden NordenZahlenwerte im Text

spacy bietet Funktionen wie_num, die angibt, ob der Text numerische Werte hat oder nicht

für Token in Sätzen:
    if token.like_num:
        text_num = token.text
drucken(text_num)

Finden URL-Link im Text

spacy bietet die Funktion like_url, die angibt, ob der Text einen URL-Link enthält oder nicht

# Links finden
für Token in Sätzen:
    if token.like_url:
        text_links = token.text
        drucken(text_links)

Es gibt eine Bibliothek in Python, die hilft, den Text zu bereinigen, du findest die dokumentation. hier

Heutzutage, diese Bibliothek unterstützt die Reinigung, Tokenisierung und Analyse

• URLs
• Etiketten
• Erwähnungen
• Reservierte Wörter (RT, FAV)
• Emojis
• Emoticons

Bibliothek importieren

!pip installiere Tweet-Präprozessor
Präprozessor als p . importieren

Rufen Sie eine Funktion auf, um den Text zu bereinigen

def preprocess_tweet(Reihe):
    Text = Zeile['tweet']
    text = p.sauber(Text)
    Rückgabetext

df['clean_tweet'] = df.anwenden(preprocess_tweet, Achse=1)
df[:6]

Wie wir sehen, clean_tweet-Spalten enthalten nur Text, alle Benutzernamen werden entfernt, Hashtag- und URL-Links

Einige der Schritte für die Reinigung sind immer noch wie

• den ganzen text herunterladen
• Noten entfernen
• Zahlen entfernen

Code:

def preprocessing_text(Text):
     # Kleinbuchstaben schreiben
     text = text.str.lower()
     # Satzzeichen entfernen
     text = text.str.replace('[^ ws]', '', regex=Wahr)
     # Ziffern entfernen
     text = text.str.replace('[D]+', '', regex=Wahr)
     Rückgabetext
 pd.set_option('max_colwidth', 500)
 df['clean_tweet'] = preprocessing_text(df['clean_tweet'])
 df['clean_tweet'][:5]

Wir haben unseren Text sauber, lass uns die leeren Worte entfernen.

Was sind leere Worte? Müssen Sie die Stoppwörter entfernen??

Stoppwörter sind die häufigsten Wörter in jeder natürlichen Sprache. Leere Worte sind wie ich, Soja, Ihre, Wenn, etc., füge dem Text keine zusätzlichen Informationen hinzu.

Stoppwörter müssen nicht jedes Mal entfernt werden, wenn es von der Fallstudie abhängt, Hier finden wir das Gefühl des Textes, also müssen wir nicht mit den worten aufhören.

aus nltk.corpus importieren Stoppwörter
# Stoppwörter entfernen
stop = stopwords.words('english')
df['clean_tweet'] = df['clean_tweet'].anwenden(Lambda x: ' '.join([Wort für Wort in x.split() wenn Wort nicht in (halt)]))
df['clean_tweet'][:5]

Nachdem wir alle Schritte umgesetzt haben, haben wir unseren sauberen Text erhalten. Jetzt, Was tun mit dem Text?

• Können wir herausfinden, welche Wörter häufig verwendet werden??
• Welche Wörter werden am negativsten verwendet / positiv im Text?

Wörter tokenisieren und Häufigkeit und Wortzahl berechnen und in einem Datenrahmen speichern.

Eine Häufigkeitsverteilung zeichnet auf, wie oft jedes Wort vorgekommen ist. Zum Beispiel, ein neues Wort wurde häufig in vollständigen Daten verwendet, gefolgt von anderen Wörtern iPhone, Telefon, etc.

a = df['clean_tweet'].Str.Katze(sep=' ')
Wörter = nltk.tokenize.word_tokenize(ein)
word_dist = nltk.FreqDist(Wörter)
dff = pd.DataFrame(word_dist.most_common(), 
                    Spalten=['Word', 'Frequenz'])
dff['Word_Count'] = dff.Word.apply(len)
dff[:5]

fig = px.histogramm(dff[:20], x='Word', y='Frequenz', Höhe = 300, 
                   Titel="Am gebräuchlichsten 20 Wörter in Tweets", color_discrete_sequence=px.colors.qualitative.T10)
fig.update_yaxes(showgrid=Falsch),
fig.update_xaxes(Kategoriereihenfolge ="total absteigend")
fig.update_traces(hovertemplate=Keine)
fig.update_layout(Rand = Diktat(t=100, b=0, l=70, r=40),
                        Schwebemodus ="x vereint",
                        xaxis_tickangle = 360,
                        xaxis_title=" ", yaxis_title=" ",
                        plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                        title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                        font=dict(Farbe="#8a8d93"),
                          )

fig = px.bar(dff.tail(10), x='Word', y='Frequenz', Höhe = 300, 
                   Titel="Am wenigsten üblich 10 Wörter in Tweets", color_discrete_sequence=px.colors.qualitative.T10)
fig.update_yaxes(showgrid=Falsch),
fig.update_xaxes(Kategoriereihenfolge ="total absteigend")
fig.update_traces(hovertemplate=Keine)
fig.update_layout(Rand = Diktat(t=100, b=0, l=70, r=40),
                        Schwebemodus ="x vereint",
                        xaxis_title=" ", yaxis_title=" ",
                        plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                        title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                        font=dict(Farbe="#8a8d93"),
                          )

fig = px.bar(ein, Höhe = 300, Titel="Häufigkeit von Wörtern in Tweets", 
             color_discrete_sequence=px.colors.qualitative.T10)
fig.update_yaxes(showgrid=Falsch),
fig.update_xaxes(Kategoriereihenfolge ="total absteigend")
fig.update_traces(hovertemplate=Keine)
fig.update_layout(Rand = Diktat(t=100, b=0, l=70, r=40), showlegend=Falsch,
                        Schwebemodus ="x vereint",
                        xaxis_tickangle = 360,
                        xaxis_title=" ", yaxis_title=" ",
                        plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                        title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                        font=dict(Farbe="#8a8d93"),
                          )

Stimmungsanalyse

from nltk.sentiment.vader import SentimentIntensityAnalyzer
von nltk.sentiment.util import *
#Stimmungsanalyse
SIA = SentimentIntensityAnalyzer()
df["clean_tweet"]= df["clean_tweet"].astyp(str)
# Modell anwenden, Variablenerstellung
df['Polaritätswert']=df["clean_tweet"].anwenden(Lambda x:SIA.polarity_scores(x)['Compound'])
df['Neutraler Wert']=df["clean_tweet"].anwenden(Lambda x:SIA.polarity_scores(x)['Neu'])
df['Negativer Score']=df["clean_tweet"].anwenden(Lambda x:SIA.polarity_scores(x)['neg'])
df['Positiver Score']=df["clean_tweet"].anwenden(Lambda x:SIA.polarity_scores(x)['pos'])
# Konvertieren 0 zu 1 Dezimalwert für eine kategoriale Variable
df['Sentiment']=''
df.loc[df['Polaritätswert']>0,'Sentiment']='Positive'
df.loc[df['Polaritätswert']==0,'Sentiment']='Neutral'
df.loc[df['Polaritätswert']<0,'Sentiment']='Negative'
df[:5]

Klassifizierung von Tweets nach Sentiment

fig_pie = px.pie(df, Namen="Gefühl", Titel="Tweets-Klassifizierung", Höhe=250,
                 Loch = 0,7, color_discrete_sequence=px.colors.qualitative.T10)
fig_pie.update_traces(textfont=dict(Farbe="#F f f"))
fig_pie.update_layout(Rand = Diktat(t=80, b=30, l=70, r=40),
                      plot_bgcolor="#2d3035", paper_bgcolor="#2d3035",
                      title_font=dict(Größe = 25, Farbe="#a5a7ab", Familie="Seite, serifenlos"),
                      font=dict(Farbe="#8a8d93"),
                      Legende = Diktat(Ausrichtung="h", yanchor="Unterseite", y = 1, xanker ="rechts", x=0,8)
                      )

Fazit:

Wir haben gesehen, wie man Textdaten bereinigt, wenn wir einen Twitter-Benutzernamen haben, Hashtag, URL-Links, Ziffern und führte eine Stimmungsanalyse für Textdaten durch.

Wir haben gesehen, wie man mit Hilfe von spacy herausfinden kann, ob der Text URL-Links oder Ziffern enthält.

Über den Autor:

Kannst du mich verbinden?

Linkedin

Halb

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.

Verwandt