Ich habe Python berührt, aber ich habe wenig Erfahrung mit der Implementierung von maschinellem Lernen. → Ich möchte vor allem etwas mit natürlicher Sprachverarbeitung machen Mit diesem Gefühl habe ich ein Buzz-Schätzmodell erstellt.
Beziehen Sie es über das Twitter-Konto (Qiita Popular Posts), das Trendartikel mithilfe der Twitter-API einführt. 3229 Daten werden gesammelt, die URL und die Piktogramme im Tweet werden entfernt und dann in die JSON-Datei kopiert.
def retrieveTweets(screenName, count):
global totalIdx
timeLine = t.statuses.user_timeline(screen_name=screenName, count=count)
maxId = 0
for tweetsIdx, tweet in enumerate(timeLine):
maxId = tweet["id"]
addArticleTitles(tweet)
totalIdx += 1
print("Starting additional retrieving...")
retrieveContinuedTweets(screenName, count, maxId)
def retrieveContinuedTweets(screenName, count, maxId):
global totalIdx, isFinished
tmpMaxId = maxId
while True:
timeLine = t.statuses.user_timeline(screen_name=screenName, count=count, max_id=tmpMaxId)
prevMaxId = 0
for tweetsIdx, tweet in enumerate(timeLine):
tmpMaxId = tweet["id"]
addArticleTitles(tweet)
print("totalIdx = {}, prevMaxId = {}, maxId = {}, title = {}\n".format(totalIdx, prevMaxId, tmpMaxId, trendArticleTitles[totalIdx]["articleTitle"]))
if prevMaxId == 0 and totalIdx % 200 != 0:
isFinished = True
break
prevMaxId = tmpMaxId
totalIdx += 1
if isFinished:
print("Finished collecting {} qiita_trend_titles.".format(totalIdx))
break
def addArticleTitles(tweet):
global trendArticleTitles
tmpTitle = re.sub(r"(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+\$,%#]+)", "", tweet["text"]) #URL in Tweets entfernen
tmpTitle = ''.join(s for s in tmpTitle if s not in emoji.UNICODE_EMOJI)
articleTitle = tmpTitle[:len(tmpTitle)-1] #Entfernen Sie den halbbreiten Raum am Ende
datum = {"articleTitle": articleTitle}
trendArticleTitles.append(datum)
Verwenden Sie die Qiita-API, um die Titel regulärer Artikel abzurufen, die nicht summend sind. Hier wurden 9450 Daten gesammelt und in eine JSON-Datei sowie Trendartikel-Titel verschoben.
articleTitles = []
idx = 0
print("Starting collecting article titles...")
for page in range(3, 101):
#Schließen Sie frühe Seiten aus, um Artikel von Spam-Konten auszuschließen
params = {"page": str(page), "per_page": str(per_page)}
response = requests.get(url, headers=headers, params=params)
resJson = response.json()
for article in resJson:
if article.get("likes_count") < notBuzzThreshold:
title = article.get("title")
articleTitles.append({"articleTitle": title})
print("{}th article title = {}, url = {}".format(idx, title, article["url"]))
idx += 1
print("Finished collecting {} qiita_article_titles.".format(idx))
Laden Sie zunächst die beiden oben gesammelten Arten von Artikeltiteldaten. Während wir ein Flag hinzufügen, um festzustellen, ob es sich um einen Trendartikel handelt, werden wir ihn als einzelnes Datenelement fertigstellen. Mischen Sie für alle Fälle den Inhalt der kombinierten Daten.
Wieder wird die JSON-Datei am Ende ausgegeben und die Datenerfassung ist abgeschlossen.
mergedData = []
for datum in trendData:
mergedData.append({
"articleTitle": datum["articleTitle"],
"isTrend": 1
})
for datum in normalData:
mergedData.append({
"articleTitle": datum["articleTitle"],
"isTrend": 0
})
#Mische die Reihenfolge der kombinierten Ergebnisse
random.shuffle(mergedData)
print("Finished shuffling 'Merged Article Titles'.")
Ich habe versucht, ein Schätzmodell mit Naive Bayes zu erstellen, war mir aber nicht sicher, womit ich anfangen sollte. Daher habe ich Naive Bayes selbst überprüft und einen Artikel ausprobiert, der die Spam-Erkennung in Naive Bayes implementiert, damit ich vor dieser Implementierung ein Gefühl dafür bekommen kann.
Chap2_SpamDetection.md Es wurde anhand eines tatsächlichen Beispiels erklärt, und ich konnte den Teil wie "Was war Naive Bayes überhaupt?" Bestätigen.
[WIP] Einführung, da der einfache Bayes-Klassifikator überhaupt nicht einfach ist In dem Artikel, der die Farbe der Formel zeigt, konnte ich bestätigen, welche Art von Berechnung durchgeführt wird.
Nachdem ich viel über Naive Bayes gelernt habe, habe ich die Implementierung geübt. Ich ging weiter entlang der ↓. Maschinelles Lernen ~ Junk-Mail-Klassifizierung (Naive Bayes-Klassifizierer) ~
Jetzt, da Sie ein Gefühl für Naive Bayes haben, ist es Zeit, sich mit dem Hauptthema zu befassen. Ich werde über die Teile schreiben, die gegenüber der Implementierung des in der Praxis verwendeten Artikels geändert wurden.
Da der Spam-Erkennungsdatensatz auf Englisch ist, kann er direkt in scikit-learn geworfen werden, der Titel des Qiita-Artikels jedoch nicht. Fügen Sie zuerst MeCab und ipadic-NEologd hinzu, damit Sie Wörter auf Japanisch gut teilen können. (Das Ergebnis der Teilung wurde vorerst mit CountVectorizer erhalten, war aber unnatürlich.)
Ich habe mich hauptsächlich auf die folgende Seite bezogen.
Aus der Implementierung der Spam-Erkennungspraxis haben wir Folgendes hinzugefügt:
def getStopWords():
stopWords = []
with open("./datasets/Japanese.txt", mode="r", encoding="utf-8") as f:
for word in f:
if word != "\n":
stopWords.append(word.rstrip("\n"))
print("amount of stopWords = {}".format(len(stopWords)))
return stopWords
def removeEmoji(text):
return "".join(ch for ch in text if ch not in emoji.UNICODE_EMOJI)
stopWords = getStopWords()
tagger = MeCab.Tagger("mecabrc")
def extractWords(text):
text = removeEmoji(text)
text = neologdn.normalize(text)
words = []
analyzedResults = tagger.parse(text).split("\n")
for result in analyzedResults:
splittedWord = result.split(",")[0].split("\t")[0]
if not splittedWord in stopWords:
words.append(splittedWord)
return words
Wenn Sie die Wortaufteilungsmethode an den Argumentanalysator von CountVectorizer übergeben, scheint sich auch Japanisch gut aufzuteilen. groß.
vecCount = CountVectorizer(analyzer=extractWords, min_df=3)
Wir haben drei Texte für die Vorhersage vorbereitet: "" Ich habe die App veröffentlicht "", "Unity Tutorial", "Git Command Memo". "Ich habe versucht, die App freizugeben" soll "summen".
Offensichtlich ist die Anzahl der Wörter gering. Ich habe das Gefühl, dass es nicht normal geteilt wurde.
word size: 1016
word content: {'Von': 809, 'ms': 447, 'nginx': 464, 'django': 232, 'intellij': 363}
Train accuracy = 0.771
Test accuracy = 0.747
[0 0 0]
Es scheint, dass die Wörter geteilt werden können, aber es gibt viele Wörter ... Die Klassifizierung ist wie erwartet.
word size: 3870
word content: {'Von': 1696, 'MS': 623, 'Teams': 931, 'Zu': 1853, 'Benachrichtigung': 3711}
Train accuracy = 0.842
Test accuracy = 0.783
[1 0 0]
Die Anzahl der Wörter wurde reduziert und die Genauigkeit der Testdaten wurde leicht erhöht. Ich fühlte die Wichtigkeit der Vorbehandlung.
word size: 3719
word content: {'MS': 623, 'Teams': 931, 'Zu': 1824, 'Benachrichtigung': 3571, 'Machen': 1735}
Train accuracy = 0.842
Test accuracy = 0.784
[1 0 0]
Die Genauigkeit der Trainingsdaten hat leicht abgenommen, aber die Genauigkeit der Testdaten hat sich entsprechend erhöht. Außerdem habe ich vergessen, die Klassifizierungswahrscheinlichkeit anzuzeigen, daher werde ich sie hier anzeigen. Der Text, von dem ich annahm, dass er summt, war ehrlich gesagt mit einer höheren Wahrscheinlichkeit überrascht als ich erwartet hatte. (Es ist unzuverlässig, wenn Sie es nicht mit mehr Texten versuchen ...)
word size: 3700
word content: {'MS': 648, 'Teams': 955, 'Zu': 1838, 'Benachrichtigung': 3583, 'Machen': 1748}
[1 0 0]
[[0.23452364 0.76547636]
[0.92761086 0.07238914]
[0.99557625 0.00442375]]
Train accuracy = 0.841
Test accuracy = 0.785
Diesmal schien die Änderung der Genauigkeit im Bereich des Fehlers zu liegen. Ich konnte nur die in NEologd enthaltenen Mindestbedingungen garantieren, daher dachte ich, dass die Genauigkeit durch die Vektorisierung technischer Begriffe verbessert werden könnte. Danach scheint sich die Genauigkeit zu verbessern, selbst wenn Sie wichtige Wörter mit TF-IDF usw. aus dem Artikeltitel und dem Artikelinhalt extrahieren und verwenden.
Recommended Posts