Créez un nuage de mots avec uniquement des mots positifs / négatifs sur Twitter

Contenu de l'article

Dans le cadre de mon étude de Python, j'ai essayé l'API Twitter, la création de nuage de mots, le jugement de mots négatifs / positifs, etc.

Ce que j'ai fait, c'est créer WordCloud en utilisant uniquement des mots positifs (avocats, verbes) parmi les mots tweetés avec le mot-clé "transfer girl".

• "Transfer Girl" est le nom d'un groupe d'idols appelé Transfer Girl *. Si vous ajoutez un astérisque, les données qui peuvent être acquises diminueront, donc cette fois elles sont exclues.

Les étapes sont créées par la procédure suivante.

1. 1. Obtenez des données de tweet à l'aide de l'API Twitter et enregistrez-les dans mongoDB
2. Enregistrer le dictionnaire japonais de polarité d'évaluation dans mongoDB
3. 3. Jugez le contenu du tweet comme négatif ou positif et créez chaque WordCloud

1. 1. Obtenez des données de tweet à l'aide de l'API Twitter et enregistrez-les dans mongoDB

Je vais essayer d'obtenir le tweet immédiatement.

get_time_lines.py

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

#Supprimer les pictogrammes
def remove_emoji(src_str):
    return ''.join(c for c in src_str if c not in emoji.UNICODE_EMOJI)

#Paramètre de clé API(Config de fichier séparé.Défini dans py)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET

#Processus d'authentification
twitter = OAuth1Session(CK, CS, AT, ATS)  

#Point final d'acquisition de la chronologie
url = "https://api.twitter.com/1.1/search/tweets.json"  

#Mots-clés à obtenir
keyword = 'Transfert fille'

#Définition des paramètres
params = {'q': keyword,
          'count': 200}

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

#Obtenez les derniers 200 / paramètres à partir de la deuxième fois['max_id']Obtenez des tweets plus anciens que l'ID défini dans
for j in range(100):
    res = twitter.get(url, params=params)
    if res.status_code == 200:
        #Nombre restant de l'API
        limit = res.headers['x-rate-limit-remaining']
        print("API remain: " + limit)
        if limit == 1:
            sleep(60*15)

        n = 0
        result = json.loads(res.text)
        #Processus par tweet
        tweets = result['statuses']
        for tweet in tweets:
            #S'il y a un pictogramme, wordcloud ne peut pas être utilisé, supprimez-le
            tweet['text'] = remove_emoji(tweet['text'])
            #Enregistrez toutes les données du tweet
            mongo.insert_one(tweet)
        
            if len(tweets) >= 1:
                params['max_id'] = tweets[-1]['id']-1

Ecrire la configuration dans un autre fichier py

config.py

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

La classe d'opération de mongoDB ressemble à ceci

(Extrait partiel) Mongo_dao.py

from pymongo import MongoClient

class MongoDAO(object):

    def __init__(self, dbName, collectionName):
        self.client = MongoClient()
        self.db = self.client[dbName] #Définir le nom de la base de données
        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)

Les données de texte sont suffisantes pour les données de tweet, mais je pense qu'elles peuvent être utilisées pour quelque chose plus tard, alors je mets tout.

2. Enregistrer le dictionnaire japonais de polarité d'évaluation dans mongoDB

Ce processus crée des données pour un jugement négatif / positif des mots. Pour les données de jugement, nous avons utilisé le «Japanese Evaluation Polar Dictionary (Nomenclature)» créé et publié par le laboratoire Inui-Okazaki de l'Université Tohoku.

Dictionnaire japonais de la polarité d'évaluation (nomenclature)

Les données du dictionnaire ont le format suivant.

Quelques jours e ~ sera (état) objectif
10%e ~ devient / devient (état) objectif
100%e ~ devient / devient (état) objectif

Comme pour les données, «mot», «négatif (n) / positif (p) / neutre (e)» et «état» sont enregistrés dans des délimiteurs de tabulation.

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]})

Dans ce processus, les données de dictionnaire téléchargées sont séparées en onglets et insérées dans mongoDB. Puisque le jugement négatif / positif pourrait être utilisé pour quelque chose, nous avons ajouté les données "score" où le positif est "1", le négatif est "-1" et les autres sont "0".

3. 3. Jugez le contenu du tweet comme négatif ou positif et créez chaque WordCloud

tweet_analyze.py

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

target = "tenkou"
#Préparation MeCab
tagger = MeCab.Tagger("-Ochasen")

#Obtenir des données de mongoDB
mongo = MongoDAO("db", target)
target_results = mongo.find()

#Pour stocker les résultats d'analyse
positive_words = []
negative_words = []
neutral_words = []
tweet_score = 0

#Changer la destination de la connexion de base de données en données de dictionnaire
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)

#Mots à exclure du nuage de mots
stop_words = ['RT','@', '//','NECOPLASTIC', 'Nekopura', 'chat','chuLa', 'FESTIVE','FES', 'TIVE',
            'Nana Land','JYAPON','Nana','terre','JAPONISM','JYA','NEO','PON','Qu'est-ce que Kini','Quoi',
            'Kini','Faire','Prendre','Teru','viens','Devenir','Est','Être','Laisser','Oru','Dollar','Brouiller']
#Utilisez la police de votre appareil
font_path = 'C:\\WINDOWS\\Fonts\\meiryo.ttc'

#Créer un nuage de mots avec des mots positifs
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 ")

#Créer un nuage de mots avec des mots négatifs
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:
            #Extraire uniquement les adjectifs et la nomenclature des mots de partie
            pos = token.part_of_speech.split(',')[0]
            if pos in ['adjectif','verbe']:
                #Omettre les mots inutiles(Après avoir vu le résultat réel, j'ai écrit des mots qui semblent inutiles)
                if token.base_form not in ["chose", "Yo", "alors", "cette", "Il"]:
                    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 ""

référence

Python - Comment créer Word Cloud Analyse des émotions des phrases japonaises avec python (+ bases du traitement du langage) J'ai beaucoup appris. Merci beaucoup.

Résultat d'exécution

Nuage de mot de mots positifs Il s'est avéré qu'il avait été tweeté avec de merveilleux mots ressemblant à des idoles tels que «passion», «belle fille», «parfait» et «soigné».

Nuage de mot de mots négatifs Lorsque j'ai recherché des tweets, j'ai trouvé de nombreux tweets de personnes qui avaient été victimes d'intimidation avec la fille de transfert de mots. On peut en déduire que ces tweets ont également influencé ce résultat.

Impressions

Avec ce contenu, j'ai pu apprendre la sensation du traitement du langage naturel à l'aide de python. Puisque l'analyse utilisant Twitter comme source de données n'est pas une phrase dure, de nombreux mots ne sont pas pris en compte dans l'analyse. De plus, de nombreux tweets autres que ceux liés au contenu que vous souhaitez traiter seront capturés dans la recherche, j'ai donc pensé que c'était difficile de les exclure.

De plus, je me suis rendu compte qu'il est assez difficile de juger à partir du contexte si un mot qui est utilisé à la fois dans un sens bon et mauvais tel que «dangereux» est utilisé pour un jugement négatif / positif.