Dieser Artikel ist der erste Tagesartikel von Zeals Adventskalender 2019. Freut mich, dich kennenzulernen. Ich bin Tamaki, der nächstes Jahr zu Zeals kommt. Zeals ist in einem Geschäft mit Chatbot-Technologie namens Chat Commerce tätig. Außerdem forsche ich derzeit an der Universität mit der Verarbeitung natürlicher Sprache. Es gibt eine Konversation im Bot, die keine Verarbeitung natürlicher Sprache einführt, aber ich dachte, dass es interessant wäre, eine Technologie zur Verarbeitung natürlicher Sprache hinzuzufügen, deshalb habe ich beschlossen, sie zum Thema dieses Artikels zu machen.

Was ist Word2Vec?

Einfach ausgedrückt handelt es sich um eine Technologie, die den Grad der Ähnlichkeit zwischen Wörtern und das Addieren und Subtrahieren von Wörtern ermöglicht, indem Wörter durch Vektordarstellungen ersetzt und mithilfe eines neuronalen Netzwerks gelernt werden. (Es ist zu vage, um Masakari zu fliegen) Lassen Sie uns die Ähnlichkeits- und Additions- / Subtraktionsfunktionen in den Chatbot integrieren! Das ist die Geschichte dieser Zeit.

Chatbot-Konversationsfluss zum Erstellen

Eine Chatbot-Konversation ist ein Fluss des Hörens von Benutzern und des Vorschlags der besten basierend darauf. Machen wir also einen Chat-Bot, der den Benutzern diesmal meinen Boom Vtuber vorstellt. Der Ablauf der Chat-Bot-Konversation ist diesmal wie folgt.

Lassen Sie den Benutzer Funktionen eingeben
Einführung des Vtuber, der für die Funktionen am besten geeignet ist

Vtuber vorstellen

Wir werden entscheiden, welche Vtuber eingeführt werden soll. Aus diesem Grund haben wir dieses Mal Personen ausgewählt, die unter Vtubers starke Merkmale aufweisen und eine große Anzahl von Registranten haben.

Die erste ist Schwestern. Es ist ein Vtuber mit sehr hoher VR-Technologie. Klicken Sie hier für den Youtube-Kanal von Omesys

Der zweite ist Tsukinomi Rabbit. Vtuber mit interessanter Videoplanung. Klicken Sie hier für den Youtube-Kanal von Tsukinomi Rabbit

Die dritte Person ist eine Blumenpartitur. Es ist ein Vtuber mit sehr hohen Gesangsfähigkeiten. Klicken Sie hier für den Youtube-Kanal für Blumenmusik

Gesamtbild des Programms

Jetzt erstellen wir ein Chatbot-Programm, das den obigen Vtuber einführt. Der Gesamtablauf des Programms ist wie folgt.

Holen Sie sich Tweets Tweeten unter dem Namen Vtuber von Twitter
Formatieren von Tweets zum Trainieren von Word2Vec
Generieren Sie ein Word2Vec-Modell mit formatierten Tweets
Integrieren Sie das Word2Vec-Modell in den Chatbot

Die Verzeichnisstruktur sieht so aus.

.
├── chatbot.py
├── make_model.py
├── model_test.py
└── twitter

Hier ist das diesmal erstellte Github-Repository https://github.com/ssabcire/chatbot

Version, um diese Zeit zu nutzen

macOS Catalina 10.15.1
Python 3.7.3
gensim==3.8.1
pyknp==0.4.1
pandas==0.25.1
go version 1.11.1

Holen Sie sich Daten von Twitter

Holen Sie sich Tweets über Vtuber. Ich denke nicht, dass der Code, der auf die Twitter-API trifft, sehr wichtig ist, daher werde ich nur erklären, wie man eine Binärdatei aus dem bereits erstellten Repository erstellt und auf die API trifft.

Bitte klonen Sie dies. https://github.com/ssabcire/get-tweets

git clone https://github.com/ssabcire/get-tweets.git

Erstellen Sie als Nächstes keys.go und legen Sie den Twitter-API-Schlüssel und das Verzeichnis zum Speichern von Tweets fest.

`keys.go`


package lib

const consumerKey string = ""
const consumerSecret string = ""
const accessToken string = ""
const accessTokenSecret string = ""

// path = $HOME+Pfadformat. PATH wird im Home-Verzeichnis erstellt
const path = "py/chatbot/search-Omeshisu"

Klicken Sie dann auf die Twitter-API, um eine Binärdatei für die Suche zu generieren.

cd search
go build
./Suche Omeshisu

Aufgrund der Einschränkung der Twitter-API wird es einige Zeit dauern, aber jetzt kann ich die Tweets von "Omeshisu" twittern lassen.

Modellerstellung aus Tweets

Als Nächstes formatieren wir den Tweet und generieren ein Word2Vec-Modell.

`make_model.py`


import re
import json
from itertools import islice
from pathlib import Path
from typing import List, Set, Iterator
from pyknp import Juman
from gensim.models.word2vec import Word2Vec


def make_w2v(json_files: Iterator[Path], model_path: str):
    '''
Speichern Sie das Word2Vec-Modell in Tweet
    '''
    model = Word2Vec(_make_sentences(json_files), size=100,
                     window=5, min_count=3, workers=4)
    model.save(model_path)


def morphological_analysis(tweet: str) -> List[str]:
    '''
Morphologische Analyse von Tweet und Return als Liste
    '''
    text = _remove_unnecessary(tweet)
    if not text:
        return []
    return [mrph.genkei for mrph in Juman().analysis(text).mrph_list()
            if mrph.hinsi in ['Substantiv', 'Verb', 'Adjektiv']]


def _make_sentences(json_files: Iterator[Path]) -> List[List[str]]:
    '''
Liest einen Tweet, führt eine morphologische Analyse durch und gibt eine zweidimensionale Liste zurück
    '''
    return [morphological_analysis(tweet) for tweet in _load_files(json_files)]


def _load_files(json_files: Iterator[Path]) -> Set[str]:
    '''
Lesen Sie alle Dateien aus der Liste, die den PFAD der abgerufenen JSON-Tweets enthält.
Gibt einen Textsatz zurück
    '''
    tweets = set()
    for file in json_files:
        with file.open(encoding='utf-8') as f:
            try:
                tweets.add(json.load(f)['full_text'])
            except json.JSONDecodeError as e:
                print(e, "\njsofilename: ", file)
    return tweets


def _remove_unnecessary(tweet: str) -> str:
    '''
Löschen Sie unnötige Teile von Tweets
    '''
    # URL, 'RT@...:', '@<ID> '
    text = re.sub(
        r'(https?://[\w/:%#\$&\?\(\)~\.=\+\-]+)|(RT@.*?:)|(@(.)+ )',
        '', tweet
    )
    #Tweet ist Hiragana 1,Wenn es nur 2 Zeichen gibt,Leer
    # [", #, @]Kann nicht mit Juman umgehen
    return re.sub(
        r'(^[Ah-Hmm]{1,2}$)|([ |　])|([#"@])',
        '', text
    )


if __name__ == '__main__':
    cwd = Path().cwd()
    make_w2v(
        islice((cwd / "twitter" / "search-omesis").iterdir(), 0, 5000),
        str(cwd / 'omesis.model')
    )
    make_w2v(
        islice((cwd / "twitter" / "search-kahu").iterdir(), 0, 5000),
        str(cwd / 'kahu.model')
    )
    make_w2v(
        islice((cwd / "twitter" / "search-mito").iterdir(), 0, 5000),
        str(cwd / 'mito.model')
    )

Zunächst werde ich diese Methode oben erläutern. Erstellen Sie ein Modell mit der Klasse "Word2Vec". Da es notwendig ist, ein zweidimensionales Array an das erste Argument zu übergeben, erstellen wir ein zweidimensionales Array mit "_make_sentences ()".

def make_w2v(json_files: Iterator[Path], model_path: str):
    model = Word2Vec(_make_sentences(json_files), size=100,
                     window=5, min_count=3, workers=4)
    model.save(model_path)

_make_sentences () nimmt einen Tweet aus der Liste der Tweets, analysiert den Tweet morphologisch und erstellt eine Liste mit Wörtern.

def _make_sentences(json_files: Iterator[Path]) -> List[List[str]]:
    return [morphological_analysis(tweet) for tweet in _load_files(json_files)]

Juman ++ wird für die morphologische Analyse verwendet. Ich benutze diesmal Human, aber jeder, der die Morphologie analysieren kann, ist in Ordnung. Verwenden Sie also bitte, was Sie wollen.

def morphological_analysis(tweet: str) -> List[str]:
    '''
Morphologische Analyse von Tweet und Return als Liste
    '''
    text = _remove_unnecessary(tweet)
    if not text:
        return []
    return [mrph.genkei for mrph in Juman().analysis(text).mrph_list()
            if mrph.hinsi in ['Substantiv', 'Verb', 'Adjektiv']]

Lassen Sie uns nun dieses Skript ausführen.

python make_model.py

Es dauert lange, eine ganze Menge Tweets zu analysieren, aber ich konnte drei Word2Vec-Modelle generieren.

Bestätigung der vom Modell gelernten Wörter

Werfen wir einen Blick darauf, welche Wörter im Modell gelernt wurden

`model_test.py`


from pathlib import Path
from gensim.models.word2vec import Word2Vec

cwd = Path().cwd()
model = Word2Vec.load(str(cwd / "kahu.model"))
print(model.wv.index2entity)

['Blumenwertung', 'Machen', 'Ausstellung', 'gehen', 'singen', 'Lied', 'Werden', 'von', 'ich liebe', .......

Wörter werden so gelernt. Schauen wir uns als nächstes das Wort an, das "Hanafu" am ähnlichsten ist.

print(model.wv.most_similar(positive=['Blumenwertung'], topn=5))
> [('Machen', 0.9999604225158691), ('von', 0.9999315738677979), ('Werden', 0.9999290704727173), ('Sagen', 0.9999224543571472), ('Überwachung', 0.9999198317527771)]

Beobachtung ist das einzige Wort, das in den oberen Wörtern Sinn macht ... Sie können auch die Ähnlichkeit zwischen Wörtern überprüfen.

print(model.wv.similarity('Lied', 'Blumenwertung'))
> 0.9998921

Lassen Sie uns die Ähnlichkeit dieses Word2Vec und andere Funktionen verwenden, um es in unseren Chatbot zu integrieren.

Chat-Bot erstellen

Das Erstellen eines Bots mit der LINE-API war schwierig, da ich keine Zeit hatte ~~, daher werde ich dieses Mal Standardeingabe und Standardausgabe verwenden.

`chatbot.py`


import random
from pathlib import Path
from typing import List, Tuple
from gensim.models.word2vec import Word2Vec
from make_model import morphological_analysis


def exec(vtubers: List[Tuple[str, str]]):
    print("Einführung in Vtuber aus den Funktionen. Welche Funktionen möchten Sie Vtuber sehen?")
    utterance = input("Beispiel:interessant,süß,Hohe Technologie, ...Bitte geben Sie die Funktion als Testversion ein: ")
    if not utterance:
        return print("Keine Funktionen eingegeben")
    wakati_utterance = morphological_analysis(utterance)
    if not wakati_utterance:
        return print("Entschuldigen Sie, aber geben Sie die Funktionen mit anderen Worten ein.")
    s = set()
    for name, path in vtubers:
        model = Word2Vec.load(path)
        utterance_entities = [word for word in wakati_utterance
                              if word in model.wv.index2entity]
        if not utterance_entities:
            continue
        most_similar_word = model.wv.most_similar_to_given(
            name, utterance_entities)
        if model.wv.similarity(name, most_similar_word) > 0.95:
            s.add(name)
    if s:
        print("Hier ist der Vtuber, der den von Ihnen eingegebenen Funktionen entspricht!", _introduce(s.pop()))
    else:
        print('''Es tut mir leid, aber ich konnte keinen Vtuber mit dieser Funktion finden..
Wie wäre es stattdessen damit?.''', _introduce())


def _introduce(name: str = "") -> str:
    if not name:
        return random.choice((_message1(), _message2(), _message3()))
    elif name == "Omeshisu":
        return _message1()
    elif name == "Blumenwertung":
        return _message2()
    elif name == "Tsukinomi-Kaninchen":
        return _message3()


def _message1() -> str:
    return """\"Omeshisu\"
Klicken Sie hier für den Link https://www.youtube.com/channel/UCNjTjd2-PMC8Oo_-dCEss7A"""


def _message2() -> str:
    return """\"Blumenwertung\"
Klicken Sie hier für den Link https://www.youtube.com/channel/UCQ1U65-CQdIoZ2_NA4Z4F7A"""


def _message3() -> str:
    return """\"Tsukinomi-Kaninchen\"
Klicken Sie hier für den Link https://www.youtube.com/channel/UCD-miitqNY3nyukJ4Fnf4_A"""


if __name__ == '__main__':
    cwd = Path().cwd()
    exec([('Omeshisu', str(cwd / 'omesis.model')),
          ('Blumenwertung', str(cwd / 'kahu.model')),
          ('Tsukinomi-Kaninchen', str(cwd / 'mito.model'))
          ])

Lassen Sie uns den Code kurz erklären. Erhält Standardeingaben und führt morphologische Analysen durch.

def exec(vtubers: List[Tuple[str, str]]):
    print("Einführung in Vtuber aus den Funktionen. Welche Funktionen möchten Sie Vtuber sehen?")
    utterance = input("Beispiel:interessant,süß,Hohe Technologie, ...Bitte geben Sie die Funktion als Testversion ein: ")
    if not utterance:
        return print("Keine Funktionen eingegeben")
    wakati_utterance = morphological_analysis(utterance)
    if not wakati_utterance:
        return print("Entschuldigen Sie, aber geben Sie die Funktionen mit anderen Worten ein.")

Überprüfen Sie anhand von "wakati_utterance" in der Liste mit den morphologisch analysierten Wörtern, ob jedes Wort im Word2Vec-Modell vorhanden ist, und fügen Sie es gegebenenfalls der Liste hinzu. Nehmen Sie dann den mit dem höchsten Ähnlichkeitsgrad heraus. Wenn der Wert 0,95 oder mehr beträgt (bitte entscheiden Sie sich für jeden), fügen Sie ihn zu Set hinzu und führen Sie Vtuber ein. Wenn die Ähnlichkeit 95% oder mehr beträgt, kann man mit Sicherheit sagen, dass das Wort ein Merkmal von Vtuber ist! Das ist die Idee.

    s = set()
    for name, path in vtubers:
        model = Word2Vec.load(path)
        utterance_entities = [word for word in wakati_utterance
                              if word in model.wv.index2entity]
        if not utterance_entities:
            continue
        most_similar_word = model.wv.most_similar_to_given(
            name, utterance_entities)
        if model.wv.similarity(name, most_similar_word) > 0.95:
            s.add(name)
    if s:
        print("Hier ist der Vtuber, der den von Ihnen eingegebenen Funktionen entspricht!", _introduce(s.pop()))
    else:
        print('''Es tut mir leid, aber ich konnte keinen Vtuber mit dieser Funktion finden..
Wie wäre es stattdessen damit?.''', _introduce())

Lassen Sie uns dieses Skript als Test ausführen.

python chatbot.py
Einführung in Vtuber aus den Funktionen. Welche Funktionen möchten Sie Vtuber sehen?
Beispiel:interessant,süß,Hohe Technologie, ...Bitte geben Sie die Funktion als Testversion ein:interessant
Hier ist der Vtuber, der den von Ihnen eingegebenen Funktionen entspricht!"Omeshisu"
Klicken Sie hier für den Link https://www.youtube.com/channel/UCNjTjd2-PMC8Oo_-dCEss7A

python chatbot.py
Einführung in Vtuber aus den Funktionen. Welche Funktionen möchten Sie Vtuber sehen?
Beispiel:interessant,süß,Hohe Technologie, ...Bitte geben Sie die Funktion als Testversion ein:Singstimme
Hier ist der Vtuber, der den von Ihnen eingegebenen Funktionen entspricht!"Blumenwertung"
Klicken Sie hier für den Link https://www.youtube.com/channel/UCQ1U65-CQdIoZ2_NA4Z4F7A

Ummmm. Ich konnte es schön vorstellen. Es ist das Beste!

Probleme mit diesem Programm

Dieses Mal habe ich beschlossen, es nicht einzuführen, je nachdem, ob das eingegebene Wort im Modell enthalten ist Wenn Sie entweder "Lied ist gut" oder "Lied ist nicht gut" eingeben, reagiert der obige Code auf "Lied", und Personen, die gut singen können, werden vorgestellt. Ich verstehe die Abhängigkeit von Sätzen nicht. Word2Vec kann jedoch Wörter berechnen, sodass Sie dies möglicherweise gut tun können, indem Sie "Song-Poor = " ausführen. Es scheint interessant, hier mehr Ideen auszuprobieren.

Bonus

Ich habe das schon lange geschrieben, aber in Wirklichkeit verwenden Chatbots nicht viel Redefreiheit. Der Grund dafür ist, dass der Benutzer nicht frei sprechen kann, sondern ein Auswahlformat wie Schnellantwort erhält. Dies liegt daran, dass die Antwortrate höher ist, wenn Sie zur Beantwortung aufgefordert werden. (↓ Schnelle Antwort ist eine Funktion, die wie folgt angezeigt wird)

abschließend

Der Vtuber, den ich am meisten empfehle, ist Kyo Hanabusa. Es ist süß und das Lied ist so gut, dass ich froh bin zu weinen, wenn du es dir ansiehst! !! !! Kyo Hanabusas Youtube-Kanal ist hier ... Vielen Dank für Ihre Zusammenarbeit ...!

[PYTHON] Erstellen Sie einen Chatbot, der die kostenlose Eingabe mit Word2Vec unterstützt