Artikelinhalt

Im Rahmen meiner Python-Studie habe ich die Twitter-API, die Erstellung von Wortwolken, die negative / positive Beurteilung von Wörtern usw. ausprobiert.

Ich habe WordCloud nur mit positiven Wörtern (Befürworter, Verben) unter den Wörtern erstellt, die mit dem Schlüsselwort "transfer girl" getwittert wurden.

"Transfer Girl" ist der Name einer Idolgruppe namens Transfer Girl *. Wenn Sie ein Sternchen hinzufügen, werden die Daten, die erfasst werden können, verringert, sodass diesmal ausgeschlossen wird.

Die Schritte werden wie folgt erstellt.

1. Holen Sie sich Tweet-Daten mit der Twitter-API und registrieren Sie sie in mongoDB
Registrieren Sie das japanische Bewertungspolaritätswörterbuch in mongoDB
1. Beurteilen Sie den Inhalt des Tweets als negativ oder positiv und erstellen Sie jede WordCloud

1. 1. Holen Sie sich Tweet-Daten mit der Twitter-API und registrieren Sie sie in mongoDB

Ich werde versuchen, den Tweet sofort zu bekommen.

`get_time_lines.py`


import json
import config
from requests_oauthlib import OAuth1Session
from time import sleep
import emoji
from mongo_dao import MongoDAO

#Piktogramme entfernen
def remove_emoji(src_str):
    return ''.join(c for c in src_str if c not in emoji.UNICODE_EMOJI)

#API-Schlüsseleinstellung(Separate Dateikonfiguration.In py definiert)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET

#Authentifizierungsprozess
twitter = OAuth1Session(CK, CS, AT, ATS)  

#Endpunkt der Zeitleistenerfassung
url = "https://api.twitter.com/1.1/search/tweets.json"  

#Schlüsselwörter zu bekommen
keyword = 'Transfer Mädchen'

#Parameterdefinition
params = {'q': keyword,
          'count': 200}

# arg1:DB Name
# arg2:Collection Name
mongo = MongoDAO("db", "tenkou")
mongo.delete_many({})

#Holen Sie sich ab dem zweiten Mal die neuesten 200 / Parameter['max_id']Holen Sie sich Tweets älter als die eingestellte ID
for j in range(100):
    res = twitter.get(url, params=params)
    if res.status_code == 200:
        #API verbleibende Anzahl
        limit = res.headers['x-rate-limit-remaining']
        print("API remain: " + limit)
        if limit == 1:
            sleep(60*15)

        n = 0
        result = json.loads(res.text)
        #Prozess per Tweet
        tweets = result['statuses']
        for tweet in tweets:
            #Wenn ein Piktogramm vorhanden ist, kann Wordcloud nicht verwendet werden. Löschen Sie es daher
            tweet['text'] = remove_emoji(tweet['text'])
            #Registrieren Sie die gesamten Tweet-Daten
            mongo.insert_one(tweet)
        
            if len(tweets) >= 1:
                params['max_id'] = tweets[-1]['id']-1

Schreiben Sie config in eine andere py-Datei

`config.py`


CONSUMER_KEY = "****"
CONSUMER_SECRET = "****"
ACCESS_TOKEN = "****"
ACCESS_TOKEN_SECRET = "****"

Die Operationsklasse von mongoDB sieht so aus

`(Teilauszug) Mongo_dao.py`


from pymongo import MongoClient

class MongoDAO(object):

    def __init__(self, dbName, collectionName):
        self.client = MongoClient()
        self.db = self.client[dbName] #Legen Sie den DB-Namen fest
        self.collection = self.db.get_collection(collectionName)

    def insert_one(self, document):
        return self.collection.insert_one(document)

    def insert_many(self, documents):
        return self.collection.insert_many(documents)

Die Textdaten reichen für die Tweet-Daten aus, aber ich denke, dass sie später für etwas verwendet werden können, also setze ich alles ein.

2. Registrieren Sie das japanische Bewertungspolaritätswörterbuch in mongoDB

Dieser Prozess erzeugt Daten für die negative / positive Beurteilung von Wörtern. Für die Beurteilungsdaten verwendeten wir das "Japanese Evaluation Polar Dictionary (Nomenclature)", das vom Inui-Okazaki Laboratory der Tohoku University erstellt und veröffentlicht wurde.

Japanisches Bewertungspolaritätswörterbuch (Nomenklatur)

Die Wörterbuchdaten haben das folgende Format.

Ein paar Tage wird / wird (Staats-) Ziel
10%e ~ wird / wird (Staats-) Ziel
100%e ~ wird / wird (Staats-) Ziel

Für die Daten werden "Wort", "Negativ (n) / Positiv (p) / Neutral (e)" und "Zustand" in Tabulatortrennzeichen registriert.

`insert_noun.py`


from mongo_dao import MongoDAO
import codecs

mongo = MongoDAO("db","noun")

dict_path = './dict/noun_dict.trim'

with codecs.open(dict_path, "r", "utf-8") as f:
    for line in f:
        d = line[:-1].split('\t')
        if d[1] == 'n':
            d.append(-1)
        elif d[1] == 'p':
            d.append(1)
        else:
            d.append(0)
        mongo.insert_one({"word": d[0], "np": d[1], "evaluation": d[2], "score": d[3]})

Dabei werden die heruntergeladenen Wörterbuchdaten in Registerkarten getrennt und in mongoDB eingefügt. Da das negative / positive Urteil für etwas verwendet werden könnte, haben wir die Daten "Punktzahl" hinzugefügt, wobei das Positive "1", das Negative "-1" und die anderen "0" sind.

3. 3. Beurteilen Sie den Inhalt des Tweets als negativ oder positiv und erstellen Sie jede WordCloud

`tweet_analyze.py`


import MeCab
from mongo_dao import MongoDAO
import word_cloud
from wordcloud import WordCloud

target = "tenkou"
#MeCab Vorbereitung
tagger = MeCab.Tagger("-Ochasen")

#Holen Sie sich Daten von mongoDB
mongo = MongoDAO("db", target)
target_results = mongo.find()

#Zum Speichern von Analyseergebnissen
positive_words = []
negative_words = []
neutral_words = []
tweet_score = 0

#Ändern Sie das DB-Verbindungsziel in Wörterbuchdaten
mongo = MongoDAO("db", "noun")

for target_result in target_results:
    text = target_result['text']
    mecab_results = tagger.parse(text)

    for result in mecab_results.split('\n'):
        word = result.split('\t')[0]
        mongo_result = mongo.find_one(filter={"word":word})

        if type(mongo_result) is dict:
            tweet_score += mongo_result['score']
            if mongo_result['np'] == 'n':
                negative_words.append(word)
            elif mongo_result['np'] == 'p':
                positive_words.append(word)
            elif mongo_result['np'] == 'e':
                neutral_words.append(word)
        else:
            neutral_words.append(word)

#Wörter, die aus der Wortwolke ausgeschlossen werden sollen
stop_words = ['RT','@', '//','NECOPLASTIC', 'Nekopura', 'Katze','chuLa', 'FESTIVE','FES', 'TIVE',
            'Nana Land','JYAPON','Nana','Land','JAPONISM','JYA','NEO','PON','Was für Kini','Was',
            'Kini','Machen','Nehmen','Teru','Kommen Sie','Werden','Ist','Sein','Lassen','Oru','Dollar','Verwischen']
#Verwenden Sie die Schriftart auf Ihrem Gerät
font_path = 'C:\\WINDOWS\\Fonts\\meiryo.ttc'

#Erstellen Sie eine Wortwolke mit positiven Wörtern
wordcloud = WordCloud(background_color="white",font_path=font_path,contour_color='steelblue', collocations = False,
                    contour_width=3,width=900, height=500,stopwords=set(stop_words)).generate(word_cloud.parseWordCloudText(positive_words))
wordcloud.to_file("./output_wordcloud/wordcloud_" + target + "_positive.png ")

#Erstellen Sie eine Wortwolke mit negativen Wörtern
wordcloud = WordCloud(background_color="white",font_path=font_path,contour_color='steelblue', collocations = False,
                    contour_width=3,width=900, height=500,stopwords=set(stop_words)).generate(word_cloud.parseWordCloudText(negative_words))
wordcloud.to_file("./output_wordcloud/wordcloud_" + target + "_negative.png ")

`word_cloud.py`


from janome.tokenizer import Tokenizer
from collections import defaultdict

def counter(texts):
    t = Tokenizer()
    words_count = defaultdict(int)
    words = []
    for text in texts:
        tokens = t.tokenize(text)
        for token in tokens:
            #Extrahieren Sie nur Adjektive und Nomenklaturen aus Teilwörtern
            pos = token.part_of_speech.split(',')[0]
            if pos in ['Adjektiv','Verb']:
                #Lassen Sie unnötige Wörter weg(Nachdem ich das tatsächliche Ergebnis gesehen hatte, schrieb ich Wörter, die unnötig erscheinen)
                if token.base_form not in ["Ding", "Yo", "damit", "Dies", "Es"]:
                    words_count[token.base_form] += 1
                    words.append(token.base_form)
    return words_count, words

def parseWordCloudText(textList):
    return " ".join(textList) if type(textList) is list else ""

Referenz

Python - So erstellen Sie eine Word Cloud Emotionsanalyse japanischer Sätze mit Python (+ Grundlagen der Sprachverarbeitung) Ich habe viel gelernt. Vielen Dank.

Ausführungsergebnis

Wortwolke positiver Wörter Es stellte sich heraus, dass es mit wunderbaren idolartigen Worten wie "Leidenschaft", "schönes Mädchen", "perfekt" und "ordentlich" getwittert wurde.

Wortwolke negativer Wörter Als ich nach Tweets suchte, fand ich viele Tweets von Menschen, die mit dem Wort Transfer Girl gemobbt wurden. Es kann gefolgert werden, dass diese Tweets auch dieses Ergebnis beeinflusst haben.

Impressionen

Mit diesem Inhalt konnte ich das Gefühl der Verarbeitung natürlicher Sprache mit Python lernen. Da die Analyse mit Twitter als Datenquelle kein harter Satz ist, gibt es viele Wörter, die in der Analyse nicht erfasst werden. Darüber hinaus werden viele andere Tweets als diejenigen, die sich auf den Inhalt beziehen, den Sie verarbeiten möchten, bei der Suche erfasst, sodass ich der Meinung war, dass es schwierig ist, sie auszuschließen.

Außerdem wurde mir klar, dass es ziemlich schwierig ist, anhand des Kontexts zu beurteilen, ob ein Wort, das sowohl in guten als auch in schlechten Bedeutungen wie "gefährlich" verwendet wird, für eine negative / positive Beurteilung verwendet wird.

[PYTHON] Erstellen Sie eine Wortwolke mit nur positiven / negativen Wörtern auf Twitter

Artikelinhalt

1. 1. Holen Sie sich Tweet-Daten mit der Twitter-API und registrieren Sie sie in mongoDB

get_time_lines.py

config.py

(Teilauszug) Mongo_dao.py