[PYTHON] Programm zur Twitter-Trendanalyse (persönliches Memo)
Hallo. Ich studiere derzeit Twitter-Trends an der Komazawa University ** GMS 2. Klasse **, wie der Titel schon sagt. ** In diesem Artikel werden Recherchen, Code und mögliche Referenzen vorgestellt.
Ursprünglich interessierte ich mich für Twitter-Trends und seit ich in der ersten Klasse war, verwende ich Python, Twitter API und MeCab, aber es war eine primitive Sache, die ** morphologisch Wort für Wort analysiert und aggregiert **. Ich habe auch mit Sprach- und Ortsinformationen gespielt und Kanji () angezeigt ↓ Dann haben wir zum Beispiel wie bei N-Gramm alle 2-12 Vokabeln aufgezeichnet und alle ** einfachen Trendanalysen ** zusammengefasst. Als Randnotiz habe ich viele manuelle Regeln für den Wortschatz aufgestellt, z. B. wo die Hilfswörter nicht kommen und die Hilfsverben, wie im Twitter-Trend. Dies ist der Beginn der zweiten Klasse ↓ Danach hatte ich die Idee, einen stetigen Trend zu definieren und zu modellieren, der im Laufe des Tages schwankt, aber ich fragte mich, wie er wohl aussehen würde. Dann wies ein Lehrer an einer bestimmten Universität darauf hin, dass die Punkte und Regeln in den Händen anderer lagen. Es geht um den Sommer der zweiten Klasse ↓ Ich bin ein wenig gewandert, aber https://pj.ninjal.ac.jp/corpus_center/goihyo.html ** Ich kam am Nationalen Institut für Sprachen Unidic, Klassifikationswörterbuch, Semantische Klassifikation ** an und versuchte, eine semantische Normalisierung und Clusterbildung von Wörtern durchzuführen. Es war ziemlich gut, aber es war eine Korrespondenztabelle mit mehreren Wörterbüchern? Es sollte ein Synonym für denselben Ton beim Umkehren sein, aber die Bedeutung wurde von einer extremen Person erwähnt, so dass sich einige Leute engagierten, aber das Problem ist Das glaube ich nicht. Außerdem gibt es in Unidic ein unbekanntes Wort, und es gibt das Problem, dass der Trend nicht berücksichtigt wird. Geht es um den Oktober der zweiten Klasse? ↓ Sobald die Bedeutung normalisiert war, habe ich CaboCha verwendet, weil ich in der vorherigen Phase gedacht hatte, dass ich die Abhängigkeit verwenden möchte, um einen Trend mit der Abhängigkeit der Bedeutung zu erstellen. ** Dies war ein Ärger und ich konnte es nicht auf dem Seminar-Server oder AWS tun, daher hatte ich Schwierigkeiten, es auf meinem Windows zu installieren und mit einem Unterprozess zu binden (da Python nur 32 Bit hat). Unidic und Cabocha (Kann Cabocha auch ein Wörterbuch angeben?) Die Trennzeichenposition war unterschiedlich, daher habe ich sie im gemeinsamen Teil auf dieselbe Weise wie das minimale gemeinsame Vielfache abgeglichen. ↓ Als Ergebnis konnten wir einen semantischen Trend erzeugen, der auf der Abhängigkeit der Bedeutung basiert. ** Da jedoch steht "Es sollte ein Synonym für denselben Sound sein, aber die Bedeutung wird von einer extremen Person bezeichnet", habe ich eine Korrektur vorgenommen, und das ist "Hit in der Kampagne!" Es gibt eine Methode namens "Follow and Tweet", und in "Simple Trend Analysis" gab es eine Methode zum Löschen mit doppelten Ausdruckstrends, aber ich habe mich auch dafür entschieden. ↓ Bisher konnten wir "Bedeutungstrends basierend auf Bedeutungsabhängigkeit" und "einfache Ausdruckstrends" analysieren, und jetzt denke ich, dass Bedeutungstrends im Gegensatz zu Ausdrücken schwer zu trennen sind. Ich meine, es ist eine tiefe Psychologie oder etwas Großes, und ich denke, es ist wichtig, sie in dieser Forschung konkret zu machen. Unabhängig? Aggregation für jeden semantischen Trend, der den Ausdruckstrend begleitet, ** Schätzung des Ausdruckstrends anhand des Bedeutungstrends, wie viel beide richtig verwendet werden können und wie kombiniert ** sind zukünftige Probleme. Jetzt, im November meines zweiten Jahres, gebe ich mein Bestes für meine Abschlussforschung. Ich habe es geschrieben, weil ich einen Absatz hatte. (Vielleicht hätte ich es früher schreiben sollen)
Heutzutage ist der Ausdruckstrend eine Liste von Buchstaben, und der Bedeutungstrend ist eine Liste von Bedeutungen, in denen Buchstaben durch Bedeutungen ersetzt werden.
** Wenn Sie es verwenden möchten, lassen Sie es mich bitte auch auf Twitter wissen. Ich machte mir darüber Sorgen. Bitte nehmen Sie an, dass Sie das Urheberrecht besitzen. ** ** ** Ich wollte es auch in einem Backup-Sinne schreiben. Die Umgebung ist Windows 10-64bit Python 3 (Verschiedenes) https://twitter.com/kenkensz9
Erstens ist es ein Programm zum Schätzen des Ausdruckstrends. custam_freq_sentece.txt ist der vollständige Text, der zur Analyse abgerufen wird custam_freq_tue.txt ist ein Trendkandidat. custam_freq.txt ist ein Trend. custam_freq_new.txt ist das Programm mit dem längsten Trend, wobei Duplikate vom Trend ausgeschlossen werden. Außerdem ändern sich die Trends stündlich. Der Teil von freshtime = int (time.time () * 1000) -200000. Dies sollte entsprechend der Geschwindigkeit der Tweet-Erfassung geändert werden. Es gibt auch ein Wortlisten-Badword, das nicht verarbeitet wird, wenn dieses Wort überhaupt im Tweet enthalten ist. Dies ist möglicherweise nicht die Version des Programms, aber es ist nicht einfach zu verwalten. Sie können es also gerne verwenden.
hyousyutu_trend.py
# coding: utf-8
import tweepy
import datetime
import re
import itertools
import collections
from pytz import timezone
import time
import MeCab
#import threading
#from multiprocessing import Pool
import os
#import multiprocessing
import concurrent.futures
import urllib.parse
#importieren
import pdb; pdb.set_trace()
import gc
import sys
import emoji
consumer_key = ""
consumer_secret = ""
access_token = ""
access_token_secret = ""
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
authapp = tweepy.AppAuthHandler(consumer_key,consumer_secret)
apiapp = tweepy.API(authapp)
#Authentifizierung
m_owaka = MeCab.Tagger("-Owakati")
m_ocha = MeCab.Tagger("-Ochasen")
#Definition der morphologischen Zersetzung von Mecab
lang_dict="{'en': 'Englisch', 'und': 'Unbekannt', 'is': 'isländisch', 'ay': 'Aimara', 'ga': 'irisch', 'az': 'Aserbaidschan', 'as': 'Assam', 'aa': 'In der Ferne', 'ab': 'Aphazian', 'af': 'Afrikaner', 'am': 'Amhara', 'ar': 'Arabisch', 'sq': 'albanisch', 'hy': 'Armenisch', 'it': 'Italienisch', 'yi': 'Idish', 'iu': 'Inuktitot', 'ik': 'Inupia', 'ia': 'Intering', 'ie': 'Interling', 'in': 'Indonesisch', 'ug': 'Uigur', 'cy': 'Wales', 'vo': 'Volapuk', 'wo': 'Wolof', 'uk': 'ukrainisch', 'uz': 'Usbekisch', 'ur': 'Urdu', 'et': 'estnisch', 'eo': 'Esperant', 'or': 'Oria', 'oc': 'Okinawan', 'nl': 'Niederländisch', 'om': 'Oromo', 'kk': 'Kasachisch', 'ks': 'Kaschmir', 'ca': 'katalanisch', 'gl': 'galizisch', 'ko': 'Koreanisch', 'kn': 'Cannada', 'km': 'Kambodschanisch', 'rw': 'Kyawanda', 'el': 'griechische Sprache', 'ky': 'Kirgisisch', 'rn': 'Kirundi', 'gn': 'Guarani', 'qu': 'Quetua', 'gu': 'Gujarat', 'kl': 'Grönland', 'ku': 'kurdisch', 'ckb': '中央kurdisch', 'hr': 'kroatisch', 'gd': 'gälisch', 'gv': 'gälisch', 'xh': 'Kosa', 'co': 'Korsika', 'sm': 'Samoa', 'sg': 'Sangho', 'sa': 'Sanskrit', 'ss': 'Siswati', 'jv': 'Javanisch', 'ka': 'georgisch', 'sn': 'Shona', 'sd': 'Sind', 'si': 'Sinhara', 'sv': 'Schwedisch', 'su': 'Sudan', 'zu': 'Zulu-', 'es': 'Spanisch', 'sk': 'slowakisch', 'sl': 'Slowenisch', 'sw': 'Swahili', 'tn': 'Setuwana', 'st': 'Seto', 'sr': 'serbisch', 'sh': 'セルボkroatisch', 'so': 'somali', 'th': 'Thai', 'tl': 'Tagalog', 'tg': 'Tadschikisch', 'tt': 'Tatar', 'ta': 'Tamil', 'cs': 'Tschechische Sprache', 'ti': 'Tigrinya', 'bo': 'Tibetisch', 'zh': 'Chinesisch', 'ts': 'Zonga', 'te': 'Terugu', 'da': 'dänisch', 'de': 'Deutsche', 'tw': 'Twi', 'tk': 'Torquemen', 'tr': 'Türkisch', 'to': 'Tonga', 'na': 'Nauru', 'ja': 'japanisch', 'ne': 'Nepalese', 'no': 'norwegisch', 'ht': 'haitianisch', 'ha': 'Hausa', 'be': 'weißer Russe', 'ba': 'Basikir', 'ps': 'Pasito', 'eu': 'baskisch', 'hu': 'ungarisch', 'pa': 'Punjabi', 'bi': 'Bisrama', 'bh': 'Bihar', 'my': 'birmanisch', 'hi': 'Hindi', 'fj': 'Fidschianisch', 'fi': 'finnisch', 'dz': 'Bhutan', 'fo': 'Gefährte', 'fr': 'Französisch', 'fy': 'Friesisch', 'bg': 'bulgarisch', 'br': 'Bretagne', 'vi': 'Vietnamesisch', 'iw': 'hebräisch', 'fa': 'persisch', 'bn': 'Bengali', 'pl': 'Polnische Sprache', 'pt': 'Portugiesisch', 'mi': 'Maori', 'mk': 'Macadonia', 'mg': 'Madagaskar', 'mr': 'Malata', 'ml': 'Malayalam', 'mt': 'maltesisch', 'ms': 'malaiisch', 'mo': 'Moldauisch', 'mn': 'mongolisch', 'yo': 'Jorba', 'lo': 'Laota', 'la': 'Latein', 'lv': 'lettisch', 'lt': 'litauisch', 'ln': 'Ringara', 'li': 'Limburg', 'ro': 'rumänisch', 'rm': 'Bewerten Sie Romantik', 'ru': 'Russisch'}"
lang_dict=eval(lang_dict)
lang_dict_inv = {v:k for k, v in lang_dict.items()}
#Sprachwörterbuch
all=[]
#Listeninitialisierung
if os.path.exists('custam_freq_tue.txt'):
alll=open("custam_freq_tue.txt","r",encoding="utf-8-sig")
alll=alll.read()
all=eval(alll)
del alll
#all=[]
#Exportbereit
#freq_write=open("custam_freq.txt","w",encoding="utf-8-sig")
sent_write=open("custam_freq_sentece.txt","a",encoding="utf-8-sig", errors='ignore')
#Exportbereit
use_lang=["japanisch"]
use_type=["tweet"]
#config
uselang=""
for k in use_lang:
k_key=lang_dict_inv[k]
uselang=uselang+" lang:"+k_key
#Konfigurationsvorbereitung
def inita(f,k):
suball=[]
small=[]
for s in k:
if not int(f)==int(s[1]):
#print("------",f)
suball.append(small)
small=[]
#print(s[0],s[1])
small.append(s)
f=s[1]
suball.append(small)
#Wenn 2 enthalten ist
return suball
def notwo(al):
micro=[]
final=[]
kaburilist=[]
for fg in al:
kaburilist=[]
if len(fg)>1:
for v in itertools.combinations(fg, 2):
micro=[]
for s in v:
micro.append(s[0])
micro=sorted(micro,key=len,reverse=False)
kaburi=len(set(micro[0]) & set(micro[1]))
per=kaburi*100//len(micro[1])
#print(s[1],per,kaburi,len(micro[0]),len(micro[1]),"m",micro)
if per>50:
kaburilist.append(micro[0])
kaburilist.append(micro[1])
else:
final.append([micro[0],s[1]])
#print("fin1",micro[0],s[1])
if micro[0] in micro[1]:
pass
#print(micro[0],micro[1])
#print("inbegriffen"*5)
#if micro[0] in kaburilist:
# kaburilist.remove(micro[0])
else:
pass
#print(fg[0][1],fg[0][0])
final.append([fg[0][0],fg[0][1]])
#print("fin3",fg[0][0],fg[0][1])
#if kaburilist:
#longword=max(kaburilist,key=len)
#final.append([longword,s[1]])
##print("fin2",longword,s[1])
#kaburilist.remove(longword)
#kaburilist=list(set(kaburilist))
#for k in kaburilist:
# if k in final:
# final.remove(k)
# #print("finremove1",k)
return final
def siage(fin):
fin=list(map(list, set(map(tuple, fin))))
finallen = sorted(fin, key=lambda x: len(x[0]))
finallendic=dict(finallen)
finalword=[]
for f in finallen:
finalword.append(f[0])
#print("f1",finalword)
notwo=[]
for v in itertools.combinations(finalword, 2):
#print(v)
if v[0] in v[1]:
#print("in")
if v[0] in finalword:
finalword.remove(v[0])
#print("f2",finalword)
finall=[]
for f in finalword:
finall.append([f,finallendic[f]])
finall = sorted(finall, key=lambda x: int(x[1]), reverse=True)
#print("final",finall)
kk=open("custam_freq_new.txt", 'w', errors='ignore')
kk.write(str(finall))
kk.close()
def eval_pattern(use_t):
tw=0
rp=0
rt=0
if "tweet" in use_t:
tw=1
if "retweet" in use_t:
rt=1
if "reply" in use_t:
rp=1
sword=""
if tw==1:
sword="filter:safe OR -filter:safe"
if rp==0:
sword=sword+" exclude:replies"
if rt==0:
sword=sword+" exclude:retweets"
elif tw==0:
if rp==1 and rt ==1:
sword="filter:reply OR filter:retweets"
elif rp==0 and rt ==0:
print("NO")
sys.exit()
elif rt==1:
sword="filter:retweets"
elif rp==1:
sword="filter:replies"
return sword
pat=eval_pattern(use_type)+" "+uselang
#Konfigurationslesefunktion und Ausführung
def a(n):
return n+1
def f(k):
k = list(map(a, k))
return k
def g(n,m):
b=[]
for _ in range(n):
m=f(m)
b.append(m)
return b
#Generierung der Seriennummernliste
def validate(text):
if re.search(r'(.)\1{1,}', text):
return False
elif re.search(r'(..)\1{1,}', text):
return False
elif re.search(r'(...)\1{1,}', text):
return False
elif re.search(r'(...)\1{1,}', text):
return False
elif re.search(r'(....)\1{1,}', text):
return False
else:
return True
#Funktion zur Überprüfung auf Duplikate
def eval_what_nosp(c,i):
no_term=[]
no_start=[]
no_in=[]
koyu_meisi=[]
if re.findall(r"[「」、。)(『』&@_;【/＜＞,！】＼／@]", c[0]):
no_term.append(i)
no_start.append(i)
no_in.append(i)
if len(c) == 4:
if "Suffix" in c[3]:
no_start.append(i)
if "Proprietäre Nomenklatur" in c[3]:
koyu_meisi.append(i)
if c[3]=="Substantiv-Nicht unabhängig-Allgemeines":
no_term.append(i)
no_start.append(i)
no_in.append(i)
if "Partikel" in c[3]:
no_term.append(i)
no_start.append(i)
#no_in.append(i)
if c[3]=="Partikel-Union":
no_start.append(i)
if c[3]=="Partikel":
no_start.append(i)
if "Oh" in c[2]:
if c[3]=="Substantiv-Verbindung ändern":
no_term.append(i)
no_start.append(i)
no_in.append(i)
if len(c) == 6:
if c[4]=="Sahen Suru":
no_start.append(i)
if c[3]=="Verb-Nicht unabhängig":
no_start.append(i)
if "Suffix" in c[3]:
no_start.append(i)
if c[3]=="Hilfsverb":
if c[2]=="Ta":
no_start.append(i)
no_in.append(i)
if c[3]=="Hilfsverb":
if c[2]=="Abwesend":
no_start.append(i)
if c[3]=="Hilfsverb":
if "Dauereinsatz" in c[5]:
no_term.append(i)
no_start.append(i)
if c[2]=="Machen":
if c[3]=="Verb-Unabhängigkeit":
if c[5]=="Kontinuierlicher Typ":
no_start.append(i)
no_in.append(i)
if c[2]=="Werden":
if c[3]=="Verb-Unabhängigkeit":
no_start.append(i)
no_in.append(i)
if c[2]=="Teru":
if c[3]=="Verb-Nicht unabhängig":
no_start.append(i)
no_in.append(i)
if c[2]=="ist":
if c[3]=="Hilfsverb":
no_start.append(i)
no_in.append(i)
if c[2]=="Chau":
if c[3]=="Verb-Nicht unabhängig":
no_start.append(i)
no_in.append(i)
if c[2]=="Gibt es":
if c[3]=="Verb-Unabhängigkeit":
no_term.append(i)
no_start.append(i)
no_in.append(i)
if c[2]=="Hilfsverb":
if c[3]=="Special da":
no_term.append(i)
no_start.append(i)
no_in.append(i)
if c[2]=="Masu":
if c[3]=="Hilfsverb":
no_term.append(i)
no_start.append(i)
no_in.append(i)
if "Dauereinsatz" in c[5]:
no_term.append(i)
if c[5]=="Wortverbindung":
no_start.append(i)
if c[2]=="Gib mir":
if c[3]=="Verb-Nicht unabhängig":
no_start.append(i)
no_in.append(i)
x=""
y=""
z=""
koyu=""
if no_term:
x=no_term[0]
if no_start:
y=no_start[0]
if no_in:
z=no_in[0]
if koyu_meisi:
koyu=koyu_meisi[0]
#print("koyu",koyu)
koyu=int(koyu)
return x,y,z,koyu
small=[]
nodouble=[]
seq=""
def process(ty,tw,un,tagg):
global all
global seq
global small
global nodouble
tw=tw.replace("\n"," ")
sent_write.write(str(tw))
sent_write.write("\n")
parselist=m_owaka.parse(tw)
parsesplit=parselist.split()
parseocha=m_ocha.parse(tw)
l = [x.strip() for x in parseocha[0:len(parseocha)-5].split('\n')]
nodouble=[]
no_term=[]
no_start=[]
no_in=[]
km_l=[]
for i, block in enumerate(l):
c=block.split('\t')
#sent_write.write("\n")
#sent_write.write(str(c))
#sent_write.write("\n")
#print(str(c))
ha,hi,hu,km=eval_what_nosp(c,i)
no_term.append(ha)
no_start.append(hi)
no_in.append(hu)
km_l.append(km)
#Schreiben abgeschlossen
if km_l[0]:
for r in km_l:
strin=parsesplit[r]
if not strin in nodouble:
all.append([strin,un])
nodouble.append(strin)
for s in range(2,8):
#Eine Kette von 2 bis 8.
#Wichtig, weil Sie die Genauigkeit verbessern können, anstatt sie schwerer zu machen
num=g(len(parsesplit)-s+1,range(-1,s-1))
for nr in num:
#2 für einen Satz-Alle Straßen von 8 Ketten
#print(no_term)
if not len(set(nr) & set(no_in)):
if not nr[-1] in no_term:
if not nr[0] in no_start:
small=[]
#print(str(parsesplit))
for nr2 in nr:
#print(nr2,parsesplit[nr2])
#Fügen Sie an der Position, die durch die Sequenz im Inneren indiziert wird, ein Wort zu klein hinzu
small.append(parsesplit[nr2])
seq="".join(small)
judge_whole=0
bad_direct_word=["Mögen","\'mat","I\'mat"]
#if "" in seq:
# judge_whole=1
#if "" in seq:
# judge_whole=1
for bd in bad_direct_word:
if seq==bd:
judge_whole=1
break
parselist=m_owaka.parse(seq)
l = [x.strip() for x in parseocha[0:len(parseocha)-5].split('\n')]
for n in range(len(l)):
if len(l[n].split("\t"))==6:
if l[n].split("\t")[3]=="Verb-Unabhängigkeit":
if len(l[n+1].split("\t"))==6:
if l[n+1].split("\t")[3]:
judge_whole=1
break
if judge_whole==0:
if validate(seq) and len(seq) > 3 and not re.findall(r'[「」、。『』/\＼／@]', seq):
if not seq in nodouble:
#Kontinuierliche Vermeidung
all.append([seq,un])
nodouble.append(seq)
#print("Erfolgreich hinzugefügt",seq)
#Aggregieren Sie dasselbe Wort nicht zweimal
else:
#print("Schon inbegriffen",seq)
pass
else:
#print("Ausschluss",seq)
pass
else:
#print("Der Anfang ist nein_ist Start",seq)
pass
else:
#print("Das Ende ist nein_Begriff",seq)
pass
#print("\n")
#print(parsesplit)
#print(l)
if tagg:
print("tagg",tagg)
for sta in tagg:
all.append(["#"+str(sta),un])
#Tag einschließen
N=1
#Anzahl der erfassten Tweets
def print_varsize():
import types
print("{}{: >15}{}{: >10}{}".format('|','Variable Name','|',' Size','|'))
print(" -------------------------- ")
for k, v in globals().items():
if hasattr(v, 'size') and not k.startswith('_') and not isinstance(v,types.ModuleType):
print("{}{: >15}{}{: >10}{}".format('|',k,'|',str(v.size),'|'))
elif hasattr(v, '__len__') and not k.startswith('_') and not isinstance(v,types.ModuleType):
print("{}{: >15}{}{: >10}{}".format('|',k,'|',str(len(v)),'|'))
def collect_count():
global all
global deadline
hh=[]
tueall=[]
#print("alllll",all)
freshtime=int(time.time()*1000)-200000
deadline=-1
#import pdb; pdb.set_trace()
#print(N_time)
print(len(N_time))
for b in N_time:
if int(b[1]) < freshtime:
deadline=b[0]
print("dead",deadline)
dellist=[]
if not deadline ==-1:
for b in N_time:
print("b",b)
if int(b[0]) < int(deadline):
dellist.append(b)
for d in dellist:
N_time.remove(d)
#print(N_time)
#import pdb; pdb.set_trace()
#time.sleep(2)
#import pdb; pdb.set_trace()
for a in all:
if int(a[1]) > freshtime:
#Anzahl der Tweets, die Sie erhalten möchten/45*Subtrahieren Sie den Wert von 1000. Jetzt 5000/45*1000=112000
tueall.append(a[0])
#print("tuealllappend"*10)
#print(tueall)
else:
all.remove(a)
#print("allremove",a)
#import pdb; pdb.set_trace()
c = collections.Counter(tueall)
c=c.most_common()
#print("c",c)
#print(c)
for r in c:
if r and r[1]>1:
hh.append([str(r[0]),str(r[1])])
k=str(hh).replace("[]","")
freq_write=open("custam_freq.txt","w",encoding="utf-8-sig", errors='ignore')
freq_write.write(str(k))
#import pdb; pdb.set_trace()
oldunix=N_time[0][1]
newunix=N_time[-1][1]
dato=str(datetime.datetime.fromtimestamp(oldunix/1000)).replace(":","-")
datn=str(datetime.datetime.fromtimestamp(newunix/1000)).replace(":","-")
dato=dato.replace(" ","_")
datn=datn.replace(" ","_")
#print(dato,datn)
#import pdb; pdb.set_trace()
freq_writea=open("trenddata/custam_freq-"+dato+"-"+datn+"--"+str(len(N_time))+".txt","w",encoding="utf-8-sig", errors='ignore')
freq_writea.write(str(k))
#import pdb; pdb.set_trace()
freq_write_tue=open("custam_freq_tue.txt","w",encoding="utf-8-sig", errors='ignore')
freq_write_tue.write(str(all))
#print(c)
def remove_emoji(src_str):
return ''.join(c for c in src_str if c not in emoji.UNICODE_EMOJI)
def deEmojify(inputString):
return inputString.encode('ascii', 'ignore').decode('ascii')
def get_tag(tw,text_content):
taglist=[]
entities=eval(str(tw.entities))["hashtags"]
for e in entities:
text=e["text"]
taglist.append(text)
for _ in range(len(taglist)+2):
for s in taglist:
text_content=re.sub(s,"",text_content)
#text_content=re.sub(r"#(.+?)+ ","",text_content)
return taglist,text_content
def get_time(id):
two_raw=format(int(id),'016b').zfill(64)
unixtime = int(two_raw[:-22],2) + 1288834974657
unixtime_th = datetime.datetime.fromtimestamp(unixtime/1000)
tim = str(unixtime_th).replace(" ","_")[:-3]
return tim,unixtime
non_bmp_map = dict.fromkeys(range(0x10000, sys.maxunicode + 1), '')
N_time=[]
def gather(tweet,type,tweet_type,removed_text):
global N
global N_all
global lagtime
global all_time
global all
global auth
global N_time
if get_time(tweet.id):
tim,unix=get_time(tweet.id)
else:
exit
#Holen Sie sich gute Tweet-Zeit
#original_text=tweet.text
nowtime=time.time()
tweet_pertime=str(round(N/(nowtime-all_time),1))
lag=str(round(nowtime-unix/1000,1))
#Verzögerung berechnen
lang=lang_dict[tweet.lang]
print(N_all,N,tweet_pertime,"/s","+"+lag,tim,type,tweet_type,lang)
#Informationsanzeige.(Alle Tweets, verarbeiteten Tweets, Verarbeitungsgeschwindigkeit, Verzögerung, Echtzeit, Erfassungsroute, Tweet-Typ, Sprache)
print(removed_text.replace("\n"," "))
taglist,tag_removed_text=get_tag(tweet,removed_text)
#import pdb; pdb.set_trace()
#print(type(tweet))
#import pdb; pdb.set_trace()
#Tags ausschließen
noemoji=remove_emoji(tag_removed_text)
try:
process(tweet_type,tag_removed_text,unix,taglist)
N_time.append([N,unix])
print("trt",tag_removed_text)
except Exception as pe:
print("process error")
print(pe)
#import pdb; pdb.set_trace()
#Zur eigentlichen Bearbeitung senden
surplus=N%1000
if surplus==0:
#sumprocess()
try:
collect_count()
except Exception as eeee:
print(eeee)
#exit
#Lass uns zählen
cft_read=open("custam_freq.txt","r",encoding="utf-8-sig")
cft_read=cft_read.read()
cft_read=eval(cft_read)
max_freq=cft_read[0][1]
#Maximalwert
allen=inita(max_freq,cft_read)
#Erstellen Sie eine Liste mit Trends mit derselben Häufigkeit.
finf=notwo(allen)
#Suchen und entfernen Sie doppelte Zeichenfolgen und doppelte Trends
siage(finf)
#Neu ist es_Schreiben Sie als Freq
print_varsize()
#Speicherinformationen anzeigen
N=N+1
#Streaming-Körper
def judge_tweet_type(tweet):
text = re.sub("https?://[\w/:%#\$&\?\(\)~\.=\+\-]+","",tweet.text)
if tweet.in_reply_to_status_id_str :
text=re.sub(r"@[a-zA-Z0-9_]* ","",text)
text=re.sub(r"@[a-zA-Z0-9_]","",text)
return "reply",text
else:
head= str(tweet.text).split(":")
if len(head) >= 2 and "RT" in head[0]:
text=re.sub(r"RT @[a-zA-Z0-9_]*: ","",text)
return "retwe",text
else:
return "tweet",text
badword=["Fragefeld","Lass uns Marshmallows werfen","Ich bekomme eine Frage","Teilnahme am Krieg","Lieferung","@","Folgen","Anwenden","Smartphone-Rollenspiel","Gacha","S4live","Kampagne","Drift Geister","Vorhanden","Genossenschaft leben","Wir akzeptieren Konsultationen völlig kostenlos","Omikuji","Gewinnchance","GET","erhalten","shindanmaker","Schlagen","Lotterie"]
N_all=0
def gather_pre(tweet,type):
global N_all
N_all=N_all+1
#Zählen Sie alle Tweets, die hier durchgehen
go=0
for b in badword:
if b in tweet.text:
go=1
break
#Beurteilen Sie, ob der Text ein schlechtes Wort enthält, GO-Urteil, da es nicht in 0 enthalten ist
if go == 0:
if tweet.lang=="ja":
tweet_type,removed_text=judge_tweet_type(tweet)
#Bestimmen Sie den Tweet-Typ
if tweet_type=="tweet":
try:
gather(tweet,type,tweet_type,removed_text)
#print(type(tweet))
#Senden, um die Verarbeitung zu sammeln.
except Exception as eee:
#gather("Ah","Ah","Ah","Ah")
#import pdb; pdb.set_trace()
pass
lagtime=0
def search(last_id):
#print(pat)
global pat
time_search =time.time()
for status in apiapp.search(q=pat,count="100",result_type="recent",since_id=last_id):
#Erhalten Sie neuere Tweets als den letzten Tweet, den Sie mit der Suche erhalten haben
gather_pre(status,"search")
#Suchkörper
interval = 2.16
#Suchanrufintervall
#min2
trysearch=0
#Suche Anzahl der Anrufe
class StreamingListener(tweepy.StreamListener):
def on_status(self, status):
global time_search
global trysearch
gather_pre(status,"stream")
time_stream=time.time()
time_stream-time_search % interval
if time_stream-time_search-interval>interval*trysearch:
#Für einen bestimmten Zeitraum(interbal)Führen Sie die Suche jedes Mal aus.
last_id=status.id
#executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
#executor.submit(search(last_id))
#Beim Versuch der Parallelverarbeitung
search(last_id)
trysearch=trysearch+1
#Streaming-Körper
def carry():
listener = StreamingListener()
streaming = tweepy.Stream(auth, listener)
streaming.sample()
#Stream-Call-Funktion
time_search =time.time()
#Die Zeit, zu der die Suche zuletzt ausgeführt, aber vor dem Stream definiert wurde
executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
#Parallele Definition
all_time=time.time()
#Definition der Ausführungsstartzeit
try:
carry()
except Exception as e:
import pdb; pdb.set_trace()
print(e)
#import pdb; pdb.set_trace()
pass
#except Exception as ee:
#print(ee)
#import pdb; pdb.set_trace()
#tragen Körper und Fehlerbehandlung
Im Folgenden finden Sie ein semantisches Trendprogramm, das ich jedoch mit Zuversicht empfehlen kann, da es hoch gelobt wird (). Ich habe den Teil, den ich aus der Cissolus mitgebracht habe, nicht geschrieben, aber ich werde ihn verlassen.
imi_trend.py
from bs4 import BeautifulSoup
import collections
import concurrent.futures
import datetime
import emoji
import itertools
import MeCab
from nltk import Tree
import os
from pathlib import Path
from pytz import timezone
import re
import spacy
import subprocess
import sys
import time
import tweepy
import unidic2ud
import unidic2ud.cabocha as CaboCha
from urllib.error import HTTPError, URLError
from urllib.parse import quote_plus
from urllib.request import urlopen
m=MeCab.Tagger("-d ./unidic-cwj-2.3.0")
os.remove("bunrui01.csv")
os.remove("all_tweet_text.txt")
os.remove("all_kakari_imi.txt")
bunrui01open=open("bunrui01.csv","a",encoding="utf-8")
textopen=open("all_tweet_text.txt","a",encoding="utf-8")
akiopen=open("all_kakari_imi.txt","a",encoding="utf-8")
catedic={}
with open('categori.txt') as f:
a=f.read()
aa=a.split("\n")
b=[]
bunrui01open.write(",,,")
for i, j in enumerate(aa):
catedic[j]=i
bunrui01open.write(str(j))
bunrui01open.write(",")
bunrui01open.write("\n")
print(catedic)
with open('./BunruiNo_LemmaID_ansi_user.csv') as f:
a=f.read()
aa=a.split(",\n")
b=[]
for bb in aa:
if len(bb.split(","))==2:
b.append(bb.split(","))
word_origin_num_to_cate=dict(b)
with open('./cate_rank2.csv') as f:
a=f.read()
aa=a.split("\n")
b=[]
for bb in aa:
if len(bb.split(","))==2:
b.append(bb.split(","))
cate_rank=dict(b)
class Synonym:
def getSy(self, word, target_url, css_selector):
try:
#Codiert, weil die URL, auf die zugegriffen werden soll, Japanisch enthält
self.__url = target_url + quote_plus(word, encoding='utf-8')
#Zugriff und Analyse
self.__html = urlopen(self.__url)
self.__soup = BeautifulSoup(self.__html, "lxml")
result = self.__soup.select_one(css_selector).text
return result
except HTTPError as e:
print(e.reason)
except URLError as e:
print(e.reason)
sy = Synonym()
alist = ["Auswahl"]
#Verwenden Sie "Japanische Sisoras Assoziative Synonyme", um zu suchen
target = "https://renso-ruigo.com/word/"
selector = "#content > div.word_t_field > div"
#for item in alist:
# print(sy.getSy(item, target, selector))
consumer_key = ""
consumer_secret = ""
access_token = ""
access_token_secret = ""
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
authapp = tweepy.AppAuthHandler(consumer_key,consumer_secret)
apiapp = tweepy.API(authapp)
#Authentifizierung(Hier api)
def remove_emoji(src_str):
return ''.join(c for c in src_str if c not in emoji.UNICODE_EMOJI)
def get_tag(tw,text_content):
taglist=[]
entities=eval(str(tw.entities))["hashtags"]
for e in entities:
text=e["text"]
taglist.append(text)
for _ in range(len(taglist)+2):
for s in taglist:
text_content=re.sub(s,"",text_content)
#text_content=re.sub(r"#(.+?)+ ","",text_content)
return taglist,text_content
def get_swap_dict(d):
return {v: k for k, v in d.items()}
def xcut(asub,a):
asub.append(a[0])
a=a[1:len(a)]
return asub,a
def ycut(asub,a):
asub.append(a[0])
a=a[1:len(a)]
return asub,a
def bunruikugiri(lastx,lasty):
hoge=[]
#import pdb; pdb.set_trace()
editx=[]
edity=[]
for _ in range(500):
edity,lasty=ycut(edity,lasty)
#target=sum(edity)
for _ in range(500):
target=sum(edity)
#rint("sum",sum(editx),"target",target)
if sum(editx)<target:
editx,lastx=xcut(editx,lastx)
elif sum(editx)>target:
edity,lasty=ycut(edity,lasty)
else:
hoge.append(editx)
editx=[]
edity=[]
if lastx==[] and lasty==[]:
return hoge
break
all_appear_cate=[]
all_unfound_word=[]
all_kumiawase=[]
nn=1
all_kakari_imi=[]
def process(tw,ty):
global nn
wordnum_toword={}
catenum_wordnum={}
word_origin_num=[]
mozisu=[]
try:
tw=re.sub("https?://[\w/:%#\$&\?\(\)~\.=\+\-]+","",tw)
tw=tw.replace("#","")
tw=tw.replace(",","")
tw=tw.replace("\u3000","") #Wichtig für die Übereinstimmung der Anzahl der Zeichen
tw=re.sub(re.compile("[!-/:-@[-`{-~]"), '', tw)
parseocha=m.parse(tw)
print(tw)
l = [x.strip() for x in parseocha[0:len(parseocha)-5].split('\n')]
bunrui_miti_sentence=[]
for i, block in enumerate(l):
if len(block.split('\t')) > 1:
c=block.split('\t')
d=c[1].split(",")
#Textverarbeitungsprozess
print(d,len(d))
if len(d)>9:
if d[10] in ["Machen"]:
word_origin_num.append(d[10])
bunrui_miti_sentence.append(d[8])
mozisu.append(len(d[8]))
elif d[-1] in word_origin_num_to_cate:
word_origin_num.append(int(d[-1]))
wordnum_toword[int(d[-1])]=d[8]
bunrui_miti_sentence.append(word_origin_num_to_cate[str(d[-1])])
mozisu.append(len(d[8]))
else:
#print("nai",d[8])
#Anzeige unbekannter Wörter
all_unfound_word.append(d[10])
bunrui_miti_sentence.append(d[8])
mozisu.append(len(c[0]))
else:
mozisu.append(len(c[0]))
all_unfound_word.append(c[0])
bunrui_miti_sentence.append(c[0])
#else:
# mozisu.append(l[])
#print("kouho",word_origin_num,"\n")
#Wörter zu ursprünglichen Zahlen
#print(tw)
#Wenn Sie Sätze mit semantischer Klassifikation und unbekannten Wörtern betrachten
for s in bunrui_miti_sentence:
print(s," ",end="")
print("\n")
stn=0
cmd = "echo "+str(tw)+" | cabocha -f1"
cmdtree="echo "+str(tw)+" | cabocha "
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,shell=True)
proctree = subprocess.Popen(cmdtree, stdout=subprocess.PIPE, stderr=subprocess.PIPE,shell=True)
proc=proc.communicate()[0].decode('cp932')
proctree=proctree.communicate()[0].decode('cp932')
print(proctree)
proclist=proc.split("\n")
#print(proc)
#f1 Informationen
#print(proclist)
#Auflistungsinformationen
procnumlist=[]
wordlis=[]
eachword=""
num=0
for p in proclist:
if p[0]=="*":
f=p.split(" ")[1]
t=p.split(" ")[2].replace("D","")
procnumlist.append([f,t])
if eachword:
wordlis.append([num,eachword])
num=num+1
eachword=""
elif p=="EOS\r":
wordlis.append([num,eachword])
num=num+1
eachword=""
break
else:
#print("aaaaa",p.split("\t")[0])
eachword=eachword+p.split("\t")[0]
tunagari_num_dict=dict(procnumlist)
print(tunagari_num_dict)
bunsetu_num_word=dict(wordlis)
#print(bunsetu_num_word)
bunsetu_mozisu=[]
for v in bunsetu_num_word.values():
bunsetu_mozisu.append(len(v))
if sum(bunsetu_mozisu) != sum(mozisu):
return
#print("mozisu",mozisu)
#print("bunsetumozi",bunsetu_mozisu)
res=bunruikugiri(mozisu,bunsetu_mozisu)
#print("res",res)
nnn=0
small_cateandcharlist=[]
big_cateandcharlist=[]
for gc in res:
for _ in range(len(gc)):
print(bunrui_miti_sentence[nnn],end=" ")
if bunrui_miti_sentence[nnn] in list(catedic.keys()):
small_cateandcharlist.append(bunrui_miti_sentence[nnn])
nnn=nnn+1
#Unbekannte Wörter und Hilfswörter werden als gleich angesehen, sodass das Mecabne-Gold-Wörterbuch verwendet werden kann.
if small_cateandcharlist==[]:
big_cateandcharlist.append(["null"])
else:
big_cateandcharlist.append(small_cateandcharlist)
small_cateandcharlist=[]
print("\n")
#print("bcacl",big_cateandcharlist)
twewtnai_kakari_imi=[]
if len(big_cateandcharlist)>1 and len(big_cateandcharlist)==len(bunsetu_num_word):
#Abhängigkeits- und morphologische Analysebegrenzer stimmen nicht überein
for kk, vv in tunagari_num_dict.items():
if vv != "-1":
for aaw in big_cateandcharlist[int(kk)]:
for bbw in big_cateandcharlist[int(vv)]:
twewtnai_kakari_imi.append([aaw,bbw])
if not "Rang Symbol" in str([aaw,bbw]):
if not "null" in str([aaw,bbw]):
if not "Zahlensymbol" in str([aaw,bbw]):
if not "Dinge" in str([aaw,bbw]):
all_kakari_imi.append(str([aaw,bbw]))
akiopen.write(str([aaw,bbw]))
else:
break
else:
return
akiopen.write("\n")
akiopen.write(str(bunrui_miti_sentence))
akiopen.write("\n")
akiopen.write(str(tw))
akiopen.write("\n")
print("tki",twewtnai_kakari_imi)
tweetnai_cate=[]
word_cate_num=[]
for k in word_origin_num:
if str(k) in word_origin_num_to_cate:
ram=word_origin_num_to_cate[str(k)]
print(ram,cate_rank[ram],end="")
tweetnai_cate.append(ram)
all_appear_cate.append(ram)
word_cate_num.append(catedic[ram])
catenum_wordnum[catedic[ram]]=int(k)
stn=stn+1
else:
if k in ["Machen"]:
all_appear_cate.append(k)
tweetnai_cate.append(k)
print("\n")
#print(tweetnai_cate)
#import pdb; pdb.set_trace()
for k in tweetnai_cate:
if k in catedic:
aac=catedic[k]
#print("gyaku",word_cate_num)
#print("wt",wordnum_toword)
#print("cw",catenum_wordnum)
bunrui01open.write(str(tw))
bunrui01open.write(",")
bunrui01open.write(str(tim))
bunrui01open.write(",")
bunrui01open.write(str(unix))
bunrui01open.write(",")
ps=0
for tt in list(range(544)):
if int(tt) in word_cate_num:
a=catenum_wordnum[tt]
#Wortnummer aus dem Schwert
bunrui01open.write(str(wordnum_toword[a]))
#Wörter aus Wortnummern
bunrui01open.write(",")
ps=ps+1
else:
bunrui01open.write("0,")
bunrui01open.write("end")
bunrui01open.write("\n")
textopen.write(str(nn))
textopen.write(" ")
textopen.write(tw)
textopen.write("\n")
nn=nn+1
#Setzen Sie alle Straßen
for k in list(itertools.combinations(tweetnai_cate,2)):
all_kumiawase.append(k)
except Exception as ee:
print(ee)
import pdb; pdb.set_trace()
pass
def judge_tweet_type(tweet):
if tweet.in_reply_to_status_id_str:
return "reply"
else:
head= str(tweet.text).split(":")
if len(head) >= 2 and "RT" in head[0]:
return "retwe"
else:
return "tweet"
#Beurteilung, ob es sich um eine Lippe, einen Retweet oder einen Tweet handelt
def get_time(id):
two_raw=format(int(id),'016b').zfill(64)
unixtime = int(two_raw[:-22],2) + 1288834974657
unixtime_th = datetime.datetime.fromtimestamp(unixtime/1000)
tim = str(unixtime_th).replace(" ","_")[:-3]
return tim,unixtime
#Tweet Zeit von ID
N=1
def gather(tweet,type,tweet_typea):
global all_appear_cate
global N
global all_time
global tim
global unix
tim,unix=get_time(tweet.id)
original_text=tweet.text.replace("\n","")
taglist,original_text=get_tag(tweet,original_text)
nowtime=time.time()
tweet_pertime=str(round(N/(nowtime-all_time),1))
lag=str(round(nowtime-unix/1000,1))
#lang=lang_dict[tweet.lang]
try:
process(remove_emoji(original_text),tweet_typea,)
except Exception as e:
print(e)
#import pdb; pdb.set_trace()
pass
print(N,tweet_pertime,"/s","+"+lag,tim,type,tweet_typea)
N=N+1
if N%500==0:
ccdd=collections.Counter(all_appear_cate).most_common()
for a in ccdd:
print(a)
#ccdd=collections.Counter(all_unfound_word).most_common()
#for a in ccdd:
# print("Abwesend",a)
ccdd=collections.Counter(all_kumiawase).most_common(300)
for a in ccdd:
print(a)
ccdd=collections.Counter(all_kakari_imi).most_common(300)
for a in ccdd:
print("all_kakari_imi",a)
#import pdb; pdb.set_trace()
#Sammle alle Stream- und Such-Tweets
def pre_gather(tw,ty):
#print(ty)
# if "http://utabami.com/TodaysTwitterLife" in tw.text:
print(tw.text)
if ty=="stream":
tweet_type=judge_tweet_type(tw)
if tw.lang=="ja" and tweet_type=="tweet":
gather(tw,ty,tweet_type)
elif ty=="search":
gather(tw,ty,"tweet")
def search(last_id):
time_search =time.time()
for status in apiapp.search(q="filter:safe OR -filter:safe -filter:retweets -filter:replies lang:ja",count="100",result_type="recent",since_id=last_id):
pre_gather(status,"search")
#Suchkörper
class StreamingListener(tweepy.StreamListener):
def on_status(self, status):
global time_search
global trysearch
pre_gather(status,"stream")
time_stream=time.time()
time_stream-time_search % interval
if time_stream-time_search-interval>interval*trysearch:
last_id=status.id
#executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
#executor.submit(search(last_id))
search(last_id)
trysearch=trysearch+1
#Streaming-Körper
def carry():
listener = StreamingListener()
streaming = tweepy.Stream(auth, listener)
streaming.sample()
interval = 2.1
trysearch=0
time_search =time.time()
#executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
all_time=time.time()
try:
#executor.submit(carry)
carry()
except Exception as er:
print(er)
import pdb; pdb.set_trace()
pass
Für jeweils 500 Tweets Anzahl der Vorkommen von einfacher Bedeutung Anzahl der Vorkommen mit 2-Gramm-Bedeutung Die Anzahl der Vorkommen einer sinnvollen kontinuierlichen? Auch für alle Tweet-Text, Informationen zur unidischen Analyse, CaboCha-Abhängigkeit, Ersetzung durch semantische Klassifizierung usw.
bunrui01.csv-Die horizontale Achse ist die Bedeutungsklassifikation von 544, die vertikale Achse ist der Tweet, 0 existiert nicht, 1 ist die zu schreibende CSV, so dass es das entsprechende Wort ist all_tweet_text-Verarbeiteter Tweet und welche Nummer er ist all_kakari_imi-Abhängiges Bedeutungspaar, was bedeutet, dass die Klassifikation ersetzt wird, Text kategori.txt-Ein txt, der die semantische Klassifikation von 544 beschreibt und zur Laufzeit ein Wörterbuch mit Index erstellt. Weitere Informationen zu BunruiNo_LemmaID_ansi_user.csv finden Sie unter https://pj.ninjal.ac.jp/corpus_center/goihyo.html Wie Sie sehen können, handelt es sich um eine Entsprechungstabelle mit dem Wort Original-Nr. Und der Bedeutungsklassifizierung. cate_rank2.csv-Ein Wörterbuch in der Reihenfolge des Auftretens von gleichzeitig erstellten semantischen Klassifikationen.
Ich werde die anderen Variablen später erklären,
Es ist für mein eigenes Memo, und Leute, die es verstehen, werden ihr Bestes tun, um es zu verstehen, also werde ich das tun.
Recommended Posts