Twitter (heute X) ist ein Mikrokosmos der digitalen Welt – ein Raum, in dem Ideen, Emotionen und Manipulationen aufeinandertreffen. Bots, Hassrede und Fake-Netzwerke stellen eine wachsende Bedrohung für die Integrität dieses Ökosystems dar, indem sie Desinformation verbreiten, Polarisierung schüren und öffentliche Diskurse beeinflussen. Bis Mitte 2023 bot `snscrape` eine leistungsstarke Methode, um Twitter-Daten ohne die Einschränkungen der offiziellen Twitter API zu sammeln. In Kombination mit KNIME, einer Open-Source-Plattform für Datenanalyse und Visualisierung, können diese Phänomene detailliert untersucht werden. Dieser Beitrag ist ein exhaustives Handbuch zur Nutzung von snscrape und KNIME, um Bots, Hate Speech und Fake-Netzwerke zu identifizieren, zu analysieren und zu visualisieren – mit umfassenden Workflows, technischen Details, Visualisierungen und tiefgehenden Erkenntnissen.
1. Einführung: Kontext und Relevanz
Die digitale Ära hat die Art und Weise, wie Informationen verbreitet werden, revolutioniert, doch mit ihr kamen auch Herausforderungen: Automatisierte Bots verstärken Narrative, Hassrede vergiftet Diskussionen, und koordinierte Fake-Netzwerke manipulieren Trends. Studien wie die des Oxford Internet Institute zeigen, dass Bots bei politischen Ereignissen bis zu 20 % der Tweets ausmachen können, während Hate Speech Research toxische Inhalte als wachsende Bedrohung identifiziert. Dieser Beitrag kombiniert snscrape – ein Tool, das bis 2023 Twitter-Daten ohne API-Zugang lieferte – mit KNIME, um diese Phänomene systematisch zu analysieren.
1.1 Snscrape: Historischer Überblick
`Snscrape` wurde von JustAnotherArchivist entwickelt und nutzte Webscraping, um Tweets, Nutzerdaten und Interaktionen direkt von Twitter zu extrahieren. Es war besonders nützlich vor Twitters Übernahme durch Elon Musk und den API-Einschränkungen ab Juni 2023 (Twitter API Changes).
- Module: TwitterSearchScraper, TwitterUserScraper, TwitterProfileScraper.
- Installation: pip install snscrape==0.6.2.
1.2 KNIME: Eine Plattform für Big Data
KNIME Analytics Platform ist ein Open-Source-Werkzeug, das Datenintegration, Analyse und Visualisierung durch visuelle Workflows ermöglicht. Es wurde 2004 an der Universität Konstanz initiiert und hat sich zu einem Standard in der Datenwissenschaft entwickelt.
- Erweiterungen:
- Vorteile: Kein Coding erforderlich, skalierbar für Millionen Datensätze.
Technische Voraussetzungen
- Software: Python 3.8+, KNIME 5.x.
- Bibliotheken: `pandas`, `networkx`, `textblob`, `matplotlib`, `seaborn`, `scikit-learn`, `nltk`.
- Hardware: 32 GB RAM, 8-Core-CPU; für Big Data: AWS EC2 oder Google Cloud Compute.
2. Datenbeschaffung mit snscrape
2.1 Tweets eines Nutzers
python
import snscrape.modules.twitter as sntwitter
import pandas as pd
from datetime import datetime
username = "example_user"
tweets = []
for i, tweet in enumerate(sntwitter.TwitterUserScraper(username).get_items()):
if i >= 10000: # Großes Sample für Analyse
break
tweets.append({
"id": tweet.id,
"date": tweet.date,
"content": tweet.content,
"username": tweet.username,
"followers": tweet.user.followersCount,
"following": tweet.user.friendsCount,
"created": tweet.user.created,
"retweet_count": tweet.retweetCount,
"like_count": tweet.likeCount,
"hashtags": tweet.hashtags or [],
"mentions": [user.username for user in tweet.mentionedUsers] if tweet.mentionedUsers else [],
"is_retweet": hasattr(tweet, "retweetedTweet")
})
df_user = pd.DataFrame(tweets)
df_user.to_csv("user_tweets.csv", index=False)
print(f"Tweets von {username}: {len(df_user)}")
2.2 Keyword- und Hashtag-Suche
python
query = "hate #fakenews lang:en since:2023-01-01 until:2023-03-01"
search_tweets = []
for i, tweet in enumerate(sntwitter.TwitterSearchScraper(query).get_items()):
if i >= 50000: # Massendaten für Netzwerkanalyse
break
search_tweets.append({
"id": tweet.id,
"date": tweet.date,
"content": tweet.content,
"username": tweet.username,
"hashtags": tweet.hashtags or [],
"retweeted": tweet.retweetedTweet.username if hasattr(tweet, "retweetedTweet") else None,
"mentions": [user.username for user in tweet.mentionedUsers] if tweet.mentionedUsers else [],
"reply_count": tweet.replyCount
})
df_search = pd.DataFrame(search_tweets)
df_search.to_csv("search_tweets.csv", index=False)
print(f"Gesammelte Tweets: {len(df_search)}")
2.3 Datenbankintegration
Für große Datenmengen (z. B. 500.000 Tweets):
python
import sqlite3
import pandas as pd
conn = sqlite3.connect("twitter_data.db")
df_user.to_sql("user_tweets", conn, if_exists="replace", index=False)
df_search.to_sql("search_tweets", conn, if_exists="replace", index=False)
# Beispielabfrage
df_sample = pd.read_sql_query("SELECT * FROM user_tweets LIMIT 10", conn)
print(df_sample.head())
conn.close()
Links: SQLite, Pandas SQL.
3. Datenaufbereitung in KNIME
3.1 Workflow für Datenaufbereitung
- Datenimport:
- CSV Reader Node: Lädt user_tweets.csv und search_tweets.csv.
- Database Connector Node: Verbindet mit twitter_data.db.
- Database Table Selector Node: Wählt Tabellen aus der Datenbank.
- Spaltenauswahl und Umbenennung:
- Column Filter Node: Wählt id, date, content, username, followers, following, created, retweet_count, hashtags, mentions, retweeted, reply_count.
- Column Rename Node: Benennt Spalten für Klarheit (z. B. content → tweet_text).
- Zeitformatierung und Berechnung:
- String to Date&Time Node: Konvertiert date und created in yyyy-MM-dd HH:mm:ss.
- Date&Time Difference Node: Berechnet Kontoalter (created bis heute) und Zeitdifferenzen zwischen Tweets.
- Datenbereinigung:
- Missing Value Node: Ersetzt fehlende hashtags mit [] und retweeted mit NULL.
- Duplicate Row Filter Node: Entfernt doppelte Tweets nach id.
3.2 Beispielausgabe
id | date | tweet_text | username | followers | following | created | retweet_count | hashtags | mentions | retweeted | reply_count |
---|---|---|---|---|---|---|---|---|---|---|---|
123456789 | 2023-02-01 10:00:00 | „Hate this!“ | example_user | 50 | 200 | 2023-01-15 00:00:00 | 5 | [] | [] | NULL | 2 |
987654321 | 2023-02-01 10:01:00 | „#fakenews bad“ | example_user | 50 | 200 | 2023-01-15 00:00:00 | 10 | [„fakenews“] | [„user2“] | user3 | 3 |
Workflow-Diagramm
[CSV Reader] → [Database Connector] → [Database Table Selector] → [Column Filter] →
[Column Rename] → [String to Date&Time] → [Date&Time Difference] → [Missing Value] → [Duplicate Row Filter]
4. Identifikation von Bots in KNIME
4.1 Statische Analyse: Aktivitätsmuster
- Math Formula Node:
- Tweets pro Tag: $$ROWCOUNT$$ / (DAYS_BETWEEN(MAX($date$), MIN($date$)) + 1).
- Follower/Following-Verhältnis: $followers$ / MAX($following$, 1).
- Rule Engine Node:
- Bot-Kriterien: $time_diff$ < 1 OR $tweets_per_day$ > 50 OR ($account_age$ < 30 AND $follower_following_ratio$ < 0.1) => „Bot Suspect“.
- Statistics Node: Berechnet Mittelwerte und Verteilungen von time_diff und tweets_per_day.
4.2 Visualisierung
- Histogram Node: Zeitdifferenzen (Bins: 50, Farbe: „Skyblue“, Titel: „Verteilung der Zeitdifferenzen zwischen Tweets“).
- Scatter Plot Node: followers vs. following (Alpha: 0.1, Punktgröße: 10, Titel: „Follower vs. Following bei Verdachtskonten“).
- Line Plot Node: Tweet-Häufigkeit über Zeit (date).
4.3 Workflow
[CSV Reader] → [Date&Time Difference] → [Math Formula] → [Rule Engine] → [Statistics] →
[Histogram] → [Scatter Plot] → [Line Plot]
Erkenntnisse
- Bots zeigen unnatürliche Posting-Frequenzen (< 1 Sekunde) und hohe Tagesraten (> 50 Tweets) (Oxford Bot Study).
- Neue Konten (< 30 Tage) mit niedrigem Verhältnis (< 0.1) sind typisch für automatisierte Profile (USC Bot Detection).
5. Erkennung von Hate Speech in KNIME
5.1 Text- und Sentimentanalyse
- Strings to Document Node: Konvertiert tweet_text in analysierbare Dokumente.
- Sentiment Analysis Node: Berechnet Polarität und Subjektivität (Textprocessing-Extension erforderlich).
- Dictionary Tagger Node: Markiert Hasswörter aus einer benutzerdefinierten Liste (z. B. Hatebase oder LIWC).
- Bag of Words Creator Node: Erstellt Wortvektoren für weiterführende Analysen.
- TF-IDF Node: Berechnet Termhäufigkeiten für Keyword-Identifikation.
- Row Filter Node: Filtert Tweets mit Polarität < -0.5 oder markierten Hasswörtern.
5.2 Alternative Methode: Python-Integration
- Python Script Node: Nutzt textblob für erweiterte Sentiment-Analyse:
python
from textblob import TextBlob
import pandas as pd
input_df = input_table.copy()
input_df["polarity"] = input_df["tweet_text"].apply(lambda x: TextBlob(x).sentiment.polarity)
output_table = input_df
5.3 Visualisierung
- Bar Chart Node: Polaritätsverteilung (Farbe: „Red“, Titel: „Sentiment-Verteilung potenzieller Hate Speech“).
- Word Cloud Node: Häufigste Hasswörter (Größe nach TF-IDF).
Workflow
[CSV Reader] → [Strings to Document] → [Sentiment Analysis] → [Dictionary Tagger] →
[Bag of Words Creator] → [TF-IDF] → [Row Filter] → [Python Script] → [Bar Chart] → [Word Cloud]
Erkenntnisse
- Tweets mit Polarität < -0.5 und Keywords wie „hate“, „kill“ oder „stupid“ sind toxisch (Hate Speech Survey).
- Politische Diskurse und ethnische Beleidigungen dominieren (Davidson et al., 2017).
6. Aufdeckung von Fake-Netzwerken in KNIME
6.1 Netzwerk- und Interaktionsanalyse
- GroupBy Node: Aggregiert Retweets (retweeted) und Mentions (mentions) pro username.
- Joiner Node: Verknüpft Retweet- und Mention-Daten für Netzwerkbildung.
- Network Creator Node: Erstellt gerichtetes Netzwerk aus username → retweeted/mentions.
- Network Feature Calculator Node: Berechnet Clustering-Koeffizienten und Zentralitätsmaße (z. B. Betweenness).
6.2 Zeitliche Analyse
- Extract Date&Time Fields Node: Extrahiert Stunde aus date.
- Pivoting Node: Gruppiert Tweets nach Stunde und username.
6.3 Visualisierung
- Network Viewer Node: Visualisiert Netzwerk (Knotengröße nach Retweet-Count, Farbe: „Skyblue“).
- Time Series Plot Node: Tweet-Aktivität nach Stunde (Titel: „Zeitliche Verteilung der Netzwerkaktivität“).
- Heatmap Node: Korrelation zwischen retweet_count und reply_count.
Workflow
[CSV Reader] → [GroupBy] → [Joiner] → [Network Creator] → [Network Feature Calculator] →
[Extract Date&Time Fields] → [Pivoting] → [Network Viewer] → [Time Series Plot] → [Heatmap]
Erkenntnisse
- Hohe Clustering-Koeffizienten (> 0.5) und Retweet-Schleifen deuten auf Koordination (NetworkX Docs).
- Zeitliche Synchronität (z. B. stündliche Spitzen) zeigt organisierte Aktionen (MIT Study on Bots).
7. Skalierung für Big Data in KNIME
Für 500.000+ Tweets:
- Big-Data-Integration:
- Spark Executor Node: Parallele Verarbeitung mit Apache Spark.
- Hadoop File Input Node: Import aus HDFS.
- Datenbank:
- Database Writer Node: Speichert in PostgreSQL oder MySQL.
- Database SQL Executor Node: Führt komplexe Abfragen (z. B. SELECT COUNT(*) FROM tweets WHERE retweet_count > 10).
- Sampling und Partitionierung:
- Row Sampling Node: Reduziert auf 10 % für Visualisierung.
- Partitioning Node: Teilt Daten in Trainings- und Testsets für ML-Modelle.
Workflow
[CSV Reader] → [Database Connector] → [Database Writer] → [Spark Executor] → [Hadoop File Input] →
[Row Sampling] → [Partitioning] → [Network Viewer]
8. Erweiterte Analysen und Visualisierungen
8.1 Machine-Learning-Integration
- Learner Node (e.g., Decision Tree): Klassifiziert Tweets als „Bot“ oder „Mensch“ basierend auf tweets_per_day, follower_following_ratio.
- Predictor Node: Wendet Modell auf neue Daten an.
- ROC Curve Node: Visualisiert Modellgenauigkeit.
8.2 Geografische Analyse (falls verfügbar)
- Geospatial View Node: Heatmap von Tweet-Standorten (falls Geodaten vorhanden).
- OSM Map Node: Netzwerk auf OpenStreetMap.
Workflow
[CSV Reader] → [Partitioning] → [Decision Tree Learner] → [Predictor] → [ROC Curve] →
[Geospatial View] → [OSM Map]
9. Analytische Erkenntnisse
- Bot-Verhalten:
- Hohe Frequenz (< 1 Sekunde) und > 50 Tweets/Tag sind starke Indikatoren.
- Neue Konten (< 30 Tage) mit niedrigem Verhältnis (< 0.1) sind typisch (Botometer).
- Hate Speech:
- Negative Polarität (< -0.5) mit Keywords wie „hate“ oder „kill“ zeigt Toxizität.
- Politische und ethnische Inhalte dominieren (Hate Speech Dataset).
- Fake-Netzwerke:
- Clustering-Koeffizienten > 0.5 und Retweet-Schleifen deuten auf Koordination.
- Zeitliche Spitzen (z. B. stündlich) bestätigen Synchronität (MIT Study).
10. Fazit und Ausblick
Die Kombination von snscrape und KNIME bietet eine umfassende Lösung zur Analyse und Visualisierung von Bots, Hate Speech und Fake-Netzwerken auf Twitter. Snscrape lieferte bis 2023 Daten ohne API-Barrieren, während KNIME durch seine Workflows, Big-Data-Tools und Visualisierungen tiefe Einblicke ermöglicht. Trotz Twitters Einschränkungen bleiben die Methoden für historische Daten, andere Plattformen oder archivierte Sets relevant. Zukünftige Analysen könnten OpenWeatherMap API für Kontext, BERT-Modelle für präzisere Sentiment-Analysen oder Gephi für erweiterte Netzwerkvisualisierungen integrieren. Die digitale Landschaft entwickelt sich weiter, und diese Ansätze bilden ein Fundament für die Bekämpfung von Manipulation im Informationszeitalter.
Schreibe einen Kommentar