Sentiment-Analyse von Zeitungen mit Fundus und Flair

Erstellt mit FullJourney

Haben Sie sich schon einmal gefragt, wie die allgemeine Stimmung zu einem bestimmten Thema ist? Die Stimmungsanalyse ist ein leistungsfähiges Instrument, das uns helfen kann, die öffentliche Meinung zu verstehen und den emotionalen Ton eines geschriebenen Textes zu erfassen. In diesem Blogbeitrag tauchen wir in die Welt der Stimmungsanalyse ein, indem wir mehr als 20 Zeitungsschlagzeilen untersuchen. Wir werden zwei unglaubliche Werkzeuge benutzen: Fundus, eine Web-Scraping-Bibliothek, und Flair, eine hochmoderne Natural Language Processing (NLP)-Bibliothek.

Wir beginnen mit Fundus, um einen Datensatz von Zeitungsüberschriften zu durchsuchen und zu sammeln. Dann werden wir die Stimmungsanalysefunktionen von Flair verwenden, um jede Schlagzeile als positiv, negativ oder neutral zu kategorisieren. Abschließend werden wir die Stimmungsstatistiken präsentieren, die Ihnen wertvolle Einblicke in die allgemeine öffentliche Wahrnehmung geben, die sich in den Schlagzeilen widerspiegelt.

Machen Sie sich bereit, die versteckten Emotionen in den Schlagzeilen zu entschlüsseln und entdecken Sie die Macht der Stimmungsanalyse mit Fundus und Flair!

What are Flair and Fundus

• Flair ist eine bekannte Open-Source-NLP-Bibliothek, die auf Python basiert. Sie bietet Werkzeuge für verschiedene Aufgaben der natürlichen Sprachverarbeitung wie Named Entity Recognition (NER), Textklassifikation, Sentimentanalyse und mehr.
• Fundus, ist dagegen nicht direkt ein NLP-Tool. Es handelt sich um ein einfaches Python-Paket, das auf Flair aufbaut und speziell für das effiziente Crawlen von Online-Nachrichtenartikeln entwickelt wurde. Es führt zwar selbst keine NLP-Aufgaben durch, hilft Ihnen aber beim Sammeln der Rohtextdaten (Nachrichtenartikel), die Sie dann mit Tools wie Flair für NLP verwenden können.

Wie man mit Flair und Fundus eine Gefühlsanalyse durchführt

Schritt 1: Installiere die Bibliotheken

pip install fundus flair

Schritt 2: Importiere die Bibliotheken

from fundus import PublisherCollection, Crawler
from flair.data import Sentence
from flair.models import TextClassifier

Schritt 3: Mit Fundus die Schlagzeilen durchstöbern

def crawl_headlines(crawlers, name_of_publishers, article_number=20):
    """Crawls headlines from a list of crawlers for specified publishers.This function takes three arguments:
        - crawlers: A list of web crawlers, each responsible for a specific publisher.
        - name_of_publishers: A list of publisher names corresponding to the crawlers.
        - article_number (optional): The maximum number of articles to crawl per publisher. Defaults to 20.
    It returns a dictionary where the keys are publisher names and the values are lists of headlines crawled from those publishers.
    """
    headlines = {}
    for crawler, name_of_publisher in zip(crawlers, name_of_publishers):
        """Iterates through crawlers and corresponding publisher names."""
        publisher = []
        for article in tqdm(crawler.crawl(max_articles=article_number)):
            """Crawls the title of articles from the current crawler up to the specified article_number."""
            publisher.append(article.title)
        headlines[name_of_publisher] = publisher
    return headlines

Ok, dieser Code definiert eine Funktion namens crawl_headlines, die Schlagzeilen von Nachrichtenseiten sammelt. Hier eine Schritt-für-Schritt-Erklärung:

Funktionsparameter:

• crawlers: Dies ist eine Liste, die verschiedene Web-Crawler enthalten soll. Jeder Crawler ist für eine bestimmte Nachrichtenseite (Publisher) zuständig.
• name_of_publishers: Diese Liste enthält die Namen der Nachrichtenseiten (Publisher), die den Crawlern in der crawlers-Liste entsprechen.
• article_number (optional): Diese Zahl legt fest, wie viele Artikel pro Nachrichtenseite maximal gesammelt werden sollen. Standardmäßig ist der Wert auf 20 gesetzt.

Rückgabewert:

Die Funktion gibt ein Wörterbuch zurück (headlines).

• Die Schlüssel (keys) des Wörterbuchs sind die Namen der Nachrichtenseiten (Publisher) aus der name_of_publishers-Liste.
• Die Werte (values) des Wörterbuchs sind Listen, die jeweils die gesammelten Schlagzeilen (Artikeltitel) der entsprechenden Nachrichtenseite enthalten.

Funktionsablauf:

Leeres Wörterbuch initialisieren: Zuerst wird ein leeres Wörterbuch namens headlines deklariert. In diesem Wörterbuch werden später die gesammelten Schlagzeilen gespeichert.

Crawlers und Publisher iterieren: Die Funktion durchläuft dann die crawlers-Liste und die name_of_publishers-Liste gleichzeitig mithilfe einer zip-Schleife. Dabei werden jeweils der aktuelle Crawler und der dazugehörige Publisher-Name miteinander verbunden.

Schlagzeilen pro Publisher sammeln:

• Innerhalb der Schleife wird eine leere Liste namens publisher initialisiert. Diese Liste wird später die Schlagzeilen des aktuellen Publishers speichern.
• Als nächstes wird die crawl-Methode des aktuellen Crawlers aufgerufen. Diese Methode durchsucht die Webseite des Publishers nach Artikeln. Dabei wird der Parameter max_articles auf article_number gesetzt, um die Anzahl der gesammelten Artikel zu begrenzen.
• Das Ergebnis der crawl-Methode wird an eine Fortschrittsanzeige namens tqdm übergeben (diese Zeile könnte je nach Bibliothek auch anders aussehen).
• Für jeden Artikel in den Ergebnissen der crawl-Methode wird der Titel des Artikels mit article.title extrahiert und an die publisher-Liste angehängt.

Schlagzeilen im Wörterbuch speichern:

• Nachdem alle Artikel des aktuellen Publishers durchlaufen wurden, wird die Liste publisher mit den gesammelten Schlagzeilen dem headlines-Wörterbuch hinzugefügt. Der Schlüssel dafür ist der Name des Publishers aus der name_of_publishers-Liste.

Rückgabe: Schließlich gibt die Funktion das headlines-Wörterbuch zurück, welches die gesammelten Schlagzeilen aller angegebenen Publisher enthält.

Schritt 4: Labels mit Flair vorhersagen

def predict_labels(publisher_headlines):
    """Predicts sentiment labels for headlines from each publisher.This function takes a dictionary `publisher_headlines` as input. 
    The dictionary keys are publisher names and the values are lists of headlines.
    The function performs sentiment analysis on each headline and stores the predicted labels 
    in a new dictionary with the same publisher names as keys.
    It returns a dictionary where the keys are publisher names and the values are lists of predicted sentiment labels 
    for the corresponding headlines.
    """
    sentiments_per_publisher = {}
    # Load a sentiment classifier (TextClassifier likely refers to a custom class or library)
    tagger = TextClassifier.load('sentiment')  
    for key, values in publisher_headlines.items():
        """Iterates through each publisher and its corresponding headlines."""
        temp = []
        for value in values:
            """Iterates through each headline for the current publisher"""
            sentence = Sentence(value)  # Create a Sentence object (likely custom class) for the headline
            tagger.predict(sentence)    # Predict sentiment label for the sentence using the loaded classifier
            temp.append(sentence.get_label().value)  # Append the predicted label value to a temporary list
        sentiments_per_publisher[key] = temp  # Add the list of predicted labels for the publisher to the result dictionary
    return sentiments_per_publisher

Diese Funktion sagt die sentimentale Tendenz (positiv, negativ oder neutral) für Schlagzeilen einzelner Nachrichtenseiten voraus.

Eingabeparameter:

• publisher_headlines: Dies ist ein Wörterbuch, welches die Schlagzeilen gruppiert nach Nachrichtenseiten (Publisher) enthält.
• Die Schlüssel (keys) des Wörterbuchs sind dabei die Namen der Nachrichtenseiten.
• Die Werte (values) des Wörterbuchs sind Listen, die jeweils die Schlagzeilen der entsprechenden Nachrichtenseite enthalten.

Funktionsablauf:

Leeres Wörterbuch initialisieren: Zuerst wird ein leeres Wörterbuch namens sentiments_per_publisher deklariert. In diesem Wörterbuch werden die vorhergesagten Sentiment-Labels gespeichert.

Sentiment-Klassifizierer laden: Es wird ein Sentiment-Klassifizierer geladen. Die genaue Implementierung ist in der Zeile tagger = TextClassifier.load('sentiment') nicht direkt ersichtlich.

• TextClassifier könnte auf eine benutzerdefinierte Klasse oder Bibliothek verweisen, die Sentiment-Analyse durchführen kann.
• Der Parameter 'sentiment' deutet darauf hin, dass der Klassifizierer speziell für die Erkennung von Sentiment in Texten trainiert ist.

Durch Iterieren Sentiment-Labels vorhersagen: Die Funktion durchläuft dann das publisher_headlines-Wörterbuch mit einer Schleife.

• Bei jeder Iteration werden der aktuelle Publisher-Name (key) und die zugehörigen Schlagzeilen (values) aus dem Wörterbuch entnommen.

Sentiment-Label pro Schlagzeile vorhersagen:

• Innerhalb der Schleife wird eine leere Liste namens temp initialisiert. Diese Liste wird später die vorhergesagten Sentiment-Labels für die Schlagzeilen des aktuellen Publishers speichern.
• Für jede Schlagzeile (value) in der Liste der Schlagzeilen des aktuellen Publishers (values):
• Erstellt die Funktion ein Sentence-Objekt (wahrscheinlich eine benutzerdefinierte Klasse) und übergibt ihm die aktuelle Schlagzeile (value).
• Ruft die predict-Methode des geladenen Klassifizierers (tagger) mit dem Sentence-Objekt auf. Dadurch wird das Sentiment-Label für die Schlagzeile vorhergesagt.
• Ruft die get_label().value-Methode des Sentence-Objekts auf, um den Wert des vorhergesagten Sentiment-Labels zu erhalten.
• Fügt den Wert des vorhergesagten Sentiment-Labels an die temporäre Liste temp an.

Labels dem Ergebniswörterbuch hinzufügen:

• Nachdem alle Schlagzeilen des aktuellen Publishers durchlaufen wurden, wird die Liste temp mit den vorhergesagten Sentiment-Labels dem sentiments_per_publisher-Wörterbuch hinzugefügt. Der Schlüssel dafür ist der Name des Publishers (key) aus der publisher_headlines-Eingabe.

Rückgabe: Schließlich gibt die Funktion das sentiments_per_publisher-Wörterbuch zurück. Dieses enthält die vorhergesagten Sentiment-Labels für die Schlagzeilen, gruppiert nach Nachrichtenseiten (Publisher).

Schritt 5: Schreibfunktion für die Statistik

def print_statistics(sentiments_per_publisher, number_of_articles=20):
    """
    This function iterates over a dictionary of sentiments per publisher and prints statistics about the sentiment distribution.Args:
        sentiments_per_publisher (dict): A dictionary where keys are publishers and values are lists of sentiment labels for their articles.
        number_of_articles (int, optional): The number of articles to consider when calculating statistics. Defaults to 20.
    """
    for keys, values in sentiments_per_publisher.items():
        """
        Iterates over each publisher and their corresponding sentiment labels.
        """
        positive = 0
        negative = 0
        something_else = 0
        for value in values:
            """
            Iterates over each sentiment label for the current publisher.
            """
            if value == "POSITIVE":
                positive += 1
            elif value == "NEGATIVE":
                negative += 1
            else:
                something_else += 1
        print(f"Publisher {keys} has {positive} positive and {negative} negative headlines from {number_of_articles}.")
        if something_else >= 1:
            print(f"If something got wrong then it has {something_else} something_else headlines.")
        print()
    return

Eingabeparameter:

• sentiments_per_publisher: Dies ist ein Wörterbuch, welches die vorhergesagten Sentiment-Labels für Schlagzeilen gruppiert nach Nachrichtenseiten (Publisher) enthält.
• Die Schlüssel (keys) des Wörterbuchs sind dabei die Namen der Nachrichtenseiten.
• Die Werte (values) des Wörterbuchs sind Listen, die jeweils die vorhergesagten Sentiment-Labels für die Schlagzeilen der entsprechenden Nachrichtenseite enthalten.
• number_of_articles (optional): Die Anzahl der Schlagzeilen, die bei der Berechnung der Statistik berücksichtigt werden sollen. Standardmäßig ist der Wert auf 20 gesetzt.

Funktionsablauf:

Durch Iterieren Statistiken sammeln: Die Funktion durchläuft das sentiments_per_publisher-Wörterbuch mit einer Schleife.

• Bei jeder Iteration werden der aktuelle Publisher-Name (keys) und die zugehörigen Sentiment-Labels (values) aus dem Wörterbuch entnommen.

Sentiment-Verteilung zählen:

• Innerhalb der Schleife werden drei Variablen initialisiert:
• positive zum Zählen positiver Schlagzeilen
• negative zum Zählen negativer Schlagzeilen
• something_else zum Zählen von Schlagzeilen mit unbekanntem Sentiment
• Für jedes Sentiment-Label (value) in der Liste der Sentiment-Labels des aktuellen Publishers (values):
• Wenn das Label “POSITIVE” lautet, wird der Zähler positive um 1 erhöht.
• Wenn das Label “NEGATIVE” lautet, wird der Zähler negative um 1 erhöht.
• Falls das Label weder “POSITIVE” noch “NEGATIVE” ist, wird der Zähler something_else um 1 erhöht.

Statistiken ausgeben:

• Nach dem Durchlaufen aller Sentiment-Labels des aktuellen Publishers werden Statistiken ausgegeben.
• Es wird die Anzahl positiver und negativer Schlagzeilen für den aktuellen Publisher (keys) ausgegeben, wobei die Anzahl der ausgewerteten Schlagzeilen (number_of_articles) mit angegeben wird.
• Falls es Schlagzeilen mit unbekanntem Sentiment (something_else größer gleich 1) gibt, wird eine separate Meldung ausgegeben.
• Anschließend wird ein leerer Zeilenumbruch eingefügt.

Rückgabe: Die Funktion gibt keinen Wert zurück (return None).

Schritt 6: Main Funktion:

if __name__ == "__main__":
    print("Crawling headlines ...")
    # Selecting two crawlers
    crawler1 = Crawler(PublisherCollection.de.BerlinerZeitung)
    crawler2 = Crawler(PublisherCollection.de.Stern)
    crawlers = [crawler1, crawler2]
    names_of_publishers = ["BerlinerZeitung", "Stern"]
    headlines = crawl_headlines(crawlers, names_of_publishers, article_number=20)
    print("Crawling headlines finished.")
    print("Doing Sentiment Analysis ...")
    sentiments_per_publisher = predict_labels(headlines)
    print("Sentiment Analysis finished.")
    print_statistics(sentiments_per_publisher)

Crawler für verschiedene Nachrichtenseiten erstellen:

• crawler1 = Crawler(PublisherCollection.de.BerlinerZeitung) - Erstellt einen Crawler-Objekt namens crawler1 speziell für die Berliner Zeitung.
• crawler2 = Crawler(Crawler.de.Stern) - Erstellt einen Crawler-Objekt namens crawler2 speziell für den Stern.
• crawlers = [crawler1, crawler2] - Fügt die beiden erstellten Crawler-Objekte in eine Liste namens crawlers ein.
• names_of_publishers = ["BerlinerZeitung", "Stern"] - Erstellt eine Liste namens names_of_publishers, welche die Namen der beiden ausgewählten Nachrichtenseiten enthält.

Schlagzeilen sammeln:

• headlines = crawl_headlines(crawlers, names_of_publishers, article_number=20) - Ruft die Funktion crawl_headlines auf.
• Diese Funktion übergibt die erstellten Crawler (crawlers) und die Nachrichtenseiten-Namen (names_of_publishers) sowie die gewünschte Anzahl an Artikeln pro Seite (article_number=20) an die Funktion.
• Die Funktion crawl_headlines sammelt die Schlagzeilen der angegebenen Nachrichtenseiten und speichert sie in einem Wörterbuch namens headlines.

Sentiment-Analyse durchführen:

• sentiments_per_publisher = predict_labels(headlines) - Ruft die Funktion predict_labels auf.
• Diese Funktion erhält das Wörterbuch mit den gesammelten Schlagzeilen (headlines) als Eingabe.
• Die Funktion predict_labels führt eine Sentiment-Analyse durch und sagt die sentimentale Tendenz (positiv, negativ oder neutral) für jede Schlagzeile voraus.
• Die vorhergesagten Sentiment-Labels werden in einem neuen Wörterbuch namens sentiments_per_publisher gespeichert, gruppiert nach Nachrichtenseite.

Überschrift ausgeben:

• print("Sentiment Analysis finished.") - Diese Zeile gibt die Nachricht "Sentiment Analysis finished." auf der Konsole aus.

Statistiken ausgeben:

• print_statistics(sentiments_per_publisher) - Ruft die Funktion print_statistics auf.
• Diese Funktion erhält das Wörterbuch mit den vorhergesagten Sentiment-Labels (sentiments_per_publisher) als Eingabe.
• Die Funktion print_statistics analysiert die Verteilung der Sentiment-Tendenzen und gibt statistische Informationen darüber für jede Nachrichtenseite aus.

Schritt 7: Ergebnisse

Herausgeber Stern hat 16 positive und 4 negative Schlagzeilen von 20.

Herausgeber BerlinerZeitung hat 16 positive und 4 negative Schlagzeilen von 20.

Der ganze Code:

from fundus import PublisherCollection, Crawler
from tqdm import tqdm
from flair.data import Sentence
from flair.models import TextClassifier

def crawl_headlines(crawlers, name_of_publishers, article_number=20):
    """Crawls headlines from a list of crawlers for specified publishers.
    This function takes three arguments:
        - crawlers: A list of web crawlers, each responsible for a specific publisher.
        - name_of_publishers: A list of publisher names corresponding to the crawlers.
        - article_number (optional): The maximum number of articles to crawl per publisher. Defaults to 20.
    It returns a dictionary where the keys are publisher names and the values are lists of headlines crawled from those publishers.
    """
    headlines = {}
    for crawler, name_of_publisher in zip(crawlers, name_of_publishers):
        """Iterates through crawlers and corresponding publisher names."""
        publisher = []
        for article in tqdm(crawler.crawl(max_articles=article_number)):
            """Crawls the title of articles from the current crawler up to the specified article_number."""
            publisher.append(article.title)
        headlines[name_of_publisher] = publisher
    return headlines

def predict_labels(publisher_headlines):
    """Predicts sentiment labels for headlines from each publisher.
    This function takes a dictionary `publisher_headlines` as input.
    The dictionary keys are publisher names and the values are lists of headlines.
    The function performs sentiment analysis on each headline and stores the predicted labels
    in a new dictionary with the same publisher names as keys.
    It returns a dictionary where the keys are publisher names and the values are lists of predicted sentiment labels
    for the corresponding headlines.
    """
    sentiments_per_publisher = {}
    # Load a sentiment classifier (TextClassifier likely refers to a custom class or library)
    tagger = TextClassifier.load('sentiment')
    for key, values in publisher_headlines.items():
        """Iterates through each publisher and its corresponding headlines."""
        temp = []
        for value in values:
            """Iterates through each headline for the current publisher"""
            sentence = Sentence(value)  # Create a Sentence object (likely custom class) for the headline
            tagger.predict(sentence)  # Predict sentiment label for the sentence using the loaded classifier
            temp.append(sentence.get_label().value)  # Append the predicted label value to a temporary list
        sentiments_per_publisher[
            key] = temp  # Add the list of predicted labels for the publisher to the result dictionary
    return sentiments_per_publisher

def print_statistics(sentiments_per_publisher, number_of_articles=20):
    """
    This function iterates over a dictionary of sentiments per publisher and prints statistics about the sentiment distribution.
    Args:
        sentiments_per_publisher (dict): A dictionary where keys are publishers and values are lists of sentiment labels for their articles.
        number_of_articles (int, optional): The number of articles to consider when calculating statistics. Defaults to 20.
    """
    for keys, values in sentiments_per_publisher.items():
        """
        Iterates over each publisher and their corresponding sentiment labels.
        """
        positive = 0
        negative = 0
        something_else = 0
        for value in values:
            """
            Iterates over each sentiment label for the current publisher.
            """
            if value == "POSITIVE":
                positive += 1
            elif value == "NEGATIVE":
                negative += 1
            else:
                something_else += 1
        print(f"Publisher {keys} has {positive} positive and {negative} negative headlines from {number_of_articles}.")
        if something_else >= 1:
            print(f"If something got wrong then it has {something_else} something_else headlines.")
        print()
    return

if __name__ == "__main__":
    print("Crawling headlines ...")
    # Selecting two crawlers
    crawler1 = Crawler(PublisherCollection.de.BerlinerZeitung)
    crawler2 = Crawler(PublisherCollection.de.Stern)
    crawlers = [crawler1, crawler2]
    names_of_publishers = ["BerlinerZeitung", "Stern"]
    headlines = crawl_headlines(crawlers, names_of_publishers, article_number=20)
    print("Crawling headlines finished.")
    print("Doing Sentiment Analysis ...")
    sentiments_per_publisher = predict_labels(headlines)
    print("Sentiment Analysis finished.")
    print_statistics(sentiments_per_publisher)

Fazit

In diesem Tutorial haben wir gelernt, wie man Flair und Fundus für das Crawling von Schlagzeilen und die Sentiment-Analyse verwendet. Wenn Sie diesen Code hilfreich fanden, klatschen Sie bitte in die Hände und kommentieren Sie diesen Beitrag! Ich würde mich auch freuen, wenn Sie mir folgen würden, um mehr über Data Science und andere verwandte Themen zu erfahren. Vielen Dank fürs Lesen!

Referenzen

Fundus-Github: https://github.com/flairNLP/fundus

Flair-Github: https://github.com/flairNLP/flair