[PYTHON] Eine Geschichte über das Lesen eines Bilderbuchs durch Synthetisieren von Sprache mit COTOHA API und Cloud Vision API

Was ist die COTOHA-API?

Es handelt sich um eine Gruppe von APIs, die für die von NTT herausgegebene Sprachanalyse usw. verwendet werden können. Nicht nur die Syntaxanalyse, sondern auch die Spracherkennung und Sprachsynthese (gegen Gebühr) sind enthalten, sodass Sie die meisten Konversationsroboter und Sprachanalysen durchführen können! Es ist voll von Funktionen, die den juckenden Ort erreichen können, wie z. B. Keyword-Extraktion und Stagnationsentfernung, die bisher stetig implementiert wurden, und die Übereinstimmungsrate der Benutzerantworten beim Deep Learning kann ebenfalls verwendet werden. Wenn also Genauigkeit vorliegt, Japanisch Ist es nicht das Stärkste im Umgang mit?

COTOHA API-Seite

Es handelt sich um einen Dienst, der verschiedene APIs für die Verarbeitung natürlicher Sprache / Sprachverarbeitung wie Syntaxanalyse, Korrespondenzanalyse, Schlüsselwortextraktion, Spracherkennung und Zusammenfassung bereitstellt. Mithilfe der 40-jährigen Forschungsergebnisse der NTT Group, wie dem japanischen Wörterbuch und der Technologie zur Klassifizierung der Bedeutungen von mehr als 3000 Wortarten, kann die erweiterte Analyse problemlos mit der API verwendet werden.

Dieses Produkt

Ich dachte, dass es sehr interessant wäre, wenn ich Zeichen aus den Bildern des Bilderbuchs extrahieren, die Sätze analysieren, die Richtung hinzufügen und als Theater ausgeben könnte, also habe ich diesen Proto ausprobiert. Ich verbringe Tage damit, meine Tochter nicht zu treffen, die wegen des Koronavirus zum Haus der Eltern ihrer Frau zurückkehrt. Deshalb habe ich es geschafft, weil ich mit ihr spielen wollte, als es nachließ. Wenn Sie sich normal mit der Zeichenerkennung → Sprachsynthese verbinden, werden Sie ein Mann, der Hiragana-Sticks liest, sodass Sie ihn nicht bekommen können. Nicht gut für die Ausbildung meiner Tochter. Hier kommt die COTOHA-API ins Spiel. Verwenden Sie die COTOHA-API, um ein Bilderbuch emotional vorzulesen.

Als rauer Fluss,

1. Extrahieren Sie Text aus Bildern mit Cloud Vision OCR
2. Konvertieren Sie Hiragana mit Google Übersetzer in Kanji
3. Korrigieren Sie Konvertierungsfehler mit der Spracherkennungsfehlererkennung (β) der COTOHA-API
4. Erkennen Sie die Emotionen von Sätzen durch Emotionsanalyse der COTOHA API
5. Analysieren Sie Zeichenpersönlichkeiten mit der COTOHA API-Benutzerattributschätzung (β).
6. Verwenden Sie die HOYA VoiceText-API, um den besten Sprecher und Sprechstil auszuwählen und die Stimme zu synthetisieren. Dies ist das Verfahren.

Das Ergebnis wird für jede Phase als txt- oder json-Datei gespeichert und zur Verwendung in der nächsten Phase geschrieben.

1. Extrahieren Sie Text aus Bildern mit Cloud Vision OCR

Dies ist diesmal nicht das Hauptproblem, daher werde ich nicht ins Detail gehen. Weitere Informationen finden Sie im separaten hier. Das für diesen Test verwendete Bilderbuch ist Garth Williams '"Shiroi Sagi and Kuroi Sagi".

Der Grund, warum ich mich dafür entschieden habe, war, dass es leicht zu erkennen schien und dass es das erste Bilderbuch war, das ich gekauft und zu Tode gelesen hatte. Der Quellcode ist unten. Grundsätzlich wird Englisch unter der Annahme entfernt, dass nur Japanisch angezeigt wird.

import copy
from google.cloud import vision
from pathlib import Path
import re

def is_japanese(text):
    if re.search(r'[Ah-Hmm]', text):
        return True
    else:
        return False

client = vision.ImageAnnotatorClient()
row_list = []
res_list = []
text_path = "./ehon_text/text.txt"

with open(text_path, 'w') as f:
    for x in range(1, 15):
        p = Path(__file__).parent / "ehon_image/{}.png ".format(x)
        with p.open('rb') as image_file:
            content = image_file.read()
        image = vision.types.Image(content=content)
        response = client.text_detection(image=image)
        if len(response.text_annotations) == 0:
            row_list.append("-")
        for lines in response.text_annotations:
            if lines.locale != "ja":
                for text in str(lines.description).split("\n"):
                    if is_japanese(text):
                        print(text)
                        f.write(text + '\n')
            else:
                print(lines.description)
                f.write(lines.description)
            break
        f.write("\n")

Das Ausführungsergebnis sieht wie folgt aus (Teilauszug). Es ist nicht 100% wie erwartet, aber mäßig genau. Die meisten Sätze sind Hiragana und können leicht zu erkennen sein. Es scheint, dass "ki" und "sa" und "po" und "bo" schwierig sind, deshalb mache ich oft einen Fehler. Da die Zeichen in diesem Bilderbuch kleiner sind als die Bilder insgesamt, gibt es ein großes Problem mit der Auflösung. Ich habe es richtig erkannt, als ich nur die Charaktere fotografiert habe. Glücklicherweise wird der Text des Ergebnisses diesmal nicht angezeigt und die Stimme wird synthetisiert. Selbst wenn "Löwenzahn" zu "Löwenzahn" wird, fühlt es sich an, als wäre es für einen Moment gelesen worden, und es gibt kein starkes Gefühl von Unbehagen. Sie sollten Ihrer Tochter nicht ausgesetzt sein.

Nach einer Weile setzte sich das schwarze Kaninchen.
Und ich habe etwas gemacht, das sehr gut aussah.
"was fehlt dir?」
Ich hörte ein weißes Schwert.
"Ja, ich habe einen Moment nachgedacht."
Der schwarze Sage antwortete.

2. Konvertieren Sie Hiragana mit Google Übersetzer in Kanji

Hiragana wird mehr geschätzt, wenn es um die Erkennung von Bildern geht, aber nachfolgende Operationen mit Text liefern bessere Ergebnisse mit Sätzen, die mit Kanji und Kana gemischt sind (sollten). Japanisch ist eine Mendokusai-Sprache, und der Schwierigkeitsgrad beim Verstehen des Programms hängt stark davon ab, ob es sich um eine Mischung aus Kanji oder Kana oder nur um Hiragana handelt. Es ist schwierig, die Bedeutung nur mit Hiragana zu analysieren, das nur fundierte Informationen enthält. Die Intonation des Vorlesens zum Zeitpunkt der Sprachsynthese ist ebenfalls unterschiedlich, und die Genauigkeit bei der Anwendung der Analyse sollte auch Kanji umfassen.

Vorerst habe ich diesmal Google Übersetzer verwendet. Der Quellcode ist unten.

import urllib
import json

kanji_text_path = "./ehon_text/kanji_text.txt"

with open('./ehon_text/text.txt', 'r') as f:
    lines = f.readlines()

url = "http://www.google.com/transliterate?"
kanji_text = ""

with open('./ehon_text/kanji_text.txt', 'w') as f:
    for line in lines:
        if line == "\n":
            f.write(line)
        else:
            param = {'langpair':'ja-Hira|ja','text':line.strip().replace('　','').replace(' ','')}
            paramStr = urllib.parse.urlencode(param)
            readObj = urllib.request.urlopen(url + paramStr)
            response = readObj.read()
            data = json.loads(response)
            for text in data:
                kanji_text += text[1][0]
            print(kanji_text)
            f.write(kanji_text)
            kanji_text = ""

Das Ausführungsergebnis sieht so aus. Es ist schmerzhaft, dass "Was ist los?" Wird "assimiliert?" .. Kinpouge wird ebenfalls ordnungsgemäß konvertiert, dies ist jedoch möglicherweise nicht so gut, da die Sprachsynthese-API vorgelesen wird oder subtil ist.

Nach einer Weile setzte sich das schwarze Kaninchen.
Und er machte ein sehr trauriges Gesicht.
„Hast du dich assimiliert?“ Ich hörte ein weißes Kaninchenlied.
"Ja, ich habe einen Moment nachgedacht", antwortete der schwarze Hase.
Dann machte Nibiki ein Versteck auf dem Feld, wo Küken und goldene Phönixblumen blühten.

3. Korrigieren Sie Konvertierungsfehler mit der Spracherkennungsfehlererkennung (β) der COTOHA-API

Zu diesem Zeitpunkt war ich ein wenig interessiert, daher dachte ich, dass es möglich sein würde, den mit den obigen Konvertierungsfehlern vermischten Satz durch Anwenden der Spracherkennungsfehlererkennung (β) zu korrigieren, also habe ich es versucht. Selbst bei der Spracherkennung ist die Syntaxanalyse unzureichend, wenn die Sprache kurz ist, und es tritt eine fehlerhafte Konvertierung auf. Da es korrigiert, sollte es für den Gebrauch geeignet sein, auch wenn es für diesen Zweck verwendet wird. Der Quellcode ist unten. Derzeit werden nur diejenigen mit einer Zuverlässigkeit von über 0,9 durch die Ergebnisse des ersten Kandidaten ersetzt.

import requests
import json

access_token_publish_url = "https://api.ce-cotoha.com/v1/oauth/accesstokens"
api_base_url = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientid = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientsecret = "XXXXXXXXXXXXXXXXXXXXX"

headers = {'Content-Type': 'application/json',}
data = json.dumps({"grantType": "client_credentials","clientId": clientid,"clientSecret": clientsecret})
response = requests.post(access_token_publish_url, headers=headers, data=data)
print(response)
access_token = json.loads(response.text)["access_token"]

api_url = api_base_url + "nlp/beta/detect_misrecognition"
headers = {"Authorization": "Bearer " + access_token, "Content-Type": "application/json;charset=UTF-8"}

with open('./ehon_text/kanji_text.txt', 'r') as f:
    lines = f.readlines()

with open('./ehon_text/kanji_text2.txt', 'w') as f:
    for line in lines:
        print(line)
        data = json.dumps({"sentence": line})
        response = requests.post(api_url, headers=headers, data=data)
        result = json.loads(response.text)
        if result["result"]["score"] > 0.9:
            for candidate in result["result"]["candidates"]:
                if candidate["detect_score"] > 0.9:
                    line = line.replace(candidate["form"], candidate["correction"][0]["form"])
        # print(response)
        # print(json.loads(response.text))
        print(line)
        f.write(line)

Das Ergebnis ist wie folgt: In Google Transrate wurden alle "zwei" in "double" konvertiert, aber einige (aber nicht alle) davon wurden verbessert. Es gab keinen Teil, der erschwert wurde, daher denke ich, dass dies die richtige Antwort ist. (Ich meine, Kaninchen werden als Tiere gezählt)

before

Jeden Morgen sprang Nibiki vom Bett auf und sprang ins Morgenlicht. Und wir haben es genossen, den ganzen Tag zusammen zu spielen.

after

Jeden Morgen sprangen sie aus ihrem Bett und sprangen ins Morgenlicht. Und wir haben es genossen, den ganzen Tag zusammen zu spielen.

4. Erkennen Sie die Emotionen von Sätzen durch Emotionsanalyse der COTOHA API

Mit der COTOHA-API können Sie emotionale Wörter aus Text extrahieren und Negative und Positive für den gesamten Satz verwenden. Tatsächlich gibt es einige Sprachsynthesen, die einige Emotionen als Parameter angeben können. Wenn dieses Ergebnis zum Zeitpunkt der Sprachsynthese als Parameter verwendet werden kann, sollte es möglich sein, mit mehr Emotionen vorzulesen. Außerdem werde ich es dieses Mal nicht verwenden, da ich keine Spracherkennung mache. Abhängig davon, wie ich es verwende, kann ich möglicherweise detaillierte Emotionen wie "Es gibt nichts" des Benutzers aufnehmen.

Viele der Dinge, die sich mit Emotionen befassen, sind solche, die einfach nur Negative und Positive ergeben, und solche, die mehrere Emotionen wie glücklich, traurig, wütend usw. als Prozentsatz zurückgeben, aber in der COTOHA-API ist das erstere das Merkmal des gesamten Satzes. Letzteres liegt nahe an der Einheit eines typischen Wortes.

Dieses Mal hatte ich vor, die Stimmen für das weiße und das schwarze Kaninchen je nach Erzähler zu trennen.

"Was ist los (traurig)", sagte Rosagi (glücklich)

Ich fand es seltsam, wenn es einen Unterschied in den Emotionen dieser drei Personen in einem Satz gab, und ich dachte, dass einfach eine lange Stichprobe einfacher zu Ergebnissen führen würde, also warf ich sie in die API für "Satz". Es ist eine Einheit.

Der Quellcode ist unten.

import requests
import json
import copy

access_token_publish_url = "https://api.ce-cotoha.com/v1/oauth/accesstokens"
api_base_url = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientid = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientsecret = "XXXXXXXXXXXXXXXXXXXXX"

headers = {'Content-Type': 'application/json',}
data = json.dumps({"grantType": "client_credentials","clientId": clientid,"clientSecret": clientsecret})
response = requests.post(access_token_publish_url, headers=headers, data=data)
access_token = json.loads(response.text)["access_token"]

api_url = api_base_url + "nlp/v1/sentiment"
headers = {"Authorization": "Bearer " + access_token, "Content-Type": "application/json;charset=UTF-8"}

with open('./ehon_text/kanji_text2.txt', 'r') as f:
    lines = f.readlines()

story = []
text_list = []
page_sentenses = []
aa = {"sentiment": "", "text": ""}
with open('./ehon_json/ehon.json', 'w') as f:
    for line in lines:
        for text in line.split("。"):
            if text != "\n":
                data = json.dumps({"sentence": text})
                response = requests.post(api_url, headers=headers, data=data)
                result = json.loads(response.text)
                # print(text)
                # print(result["result"]["sentiment"])
                text_list.append({"sentiment": result["result"]["sentiment"], "text": text})
        story.append(copy.deepcopy(text_list))
        text_list = []
    json.dump(story, f, indent=4, ensure_ascii=False)

Das Ergebnis (ein Beispiel für eine Antwort) sieht wie folgt aus. Ich dachte, dass es beim Schreiben nur neutral wäre, aber es gibt unerwartete Höhen und Tiefen der Emotionen. Sowohl Negative als auch Positive kamen richtig heraus, daher denke ich, dass es hilfreich ist, mit Emotionen vorzulesen.

Jeden Morgen sprangen sie aus ihrem Bett und sprangen ins Morgenlicht.
{'result': {'sentiment': 'Neutral', 'score': 0.3747452771403413, 'emotional_phrase': []}, 'status': 0, 'message': 'OK'}
Und ich machte ein sehr trauriges Gesicht
{'result': {'sentiment': 'Negative', 'score': 0.6020340536995118, 'emotional_phrase': [{'form': 'Sieht sehr traurig aus', 'emotion': 'N'}]}, 'status': 0, 'message': 'OK'}

5. Analysieren Sie Zeichenpersönlichkeiten mit der COTOHA API-Benutzerattributschätzung (β).

Die COTOHA-API verfügt über eine Funktion zur Schätzung von Benutzerattributen (β), und es wird eine ziemlich detaillierte Person zurückgegeben. Da die Anzahl der Lautsprecher auch bei der Sprachsynthese größer ist, habe ich mich gefragt, ob es möglich wäre, die Lautsprecher anhand dieser Informationen automatisch abzugleichen. Ich wollte wirklich alles automatisch im Programm machen, aber mir fiel keine Logik ein, um zu entscheiden, welche Äußerung wem gehört. .. Dieses Mal wurde es manuell durchgeführt. Bei japanischen Bilderbüchern sind die Zeilen oft richtig in "" eingeschlossen, also Die Spezifikation besteht darin, zuerst einzugeben, wie viele Zeichen vorhanden sind, den Inhalt von "" mit einem regulären Ausdruck zu extrahieren und den Benutzer aufzufordern, für jede Äußerung eine ID zuzuweisen. Die ID des Erzählers wird auf 0 gesetzt. Der Quellcode ist unten

import requests
import re
import json

char0 = []
char_num = int(input("Please input number of characters =>"))
for i in range(1, char_num+1):
    exec('char{} = []'.format(i))

with open('./ehon_json/ehon.json', 'r') as f:
    story = json.load(f)

story_list = []
for page in story:
    page_list = []
    for sentense in page:
        # try:
        speech_list = re.split("(?<=」)|(?=「)", sentense["text"])
        for speech in speech_list:
            if speech != "":
                if speech.find("「") > -1:
                    while True:
                        try:
                            print(sentense)
                            print(speech)
                            id = int(input("Please input char ID =>"))
                            if id <= char_num and id > 0:
                                break
                        except:
                            print("once again")
                    exec('char{}.append(speech)'.format(id))
                    page_list.append({"sentiment": sentense["sentiment"], "text": speech, "char": id})
                else:
                    char0.append(speech)
                    page_list.append({"sentiment": sentense["sentiment"], "text": speech, "char": 0})
    story_list.append(copy.deepcopy(page_list))
print(story_list)

access_token_publish_url = "https://api.ce-cotoha.com/v1/oauth/accesstokens"
api_base_url = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientid = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
clientsecret = "XXXXXXXXXXXXXXXXXXXXX"

headers = {'Content-Type': 'application/json',}
data = json.dumps({"grantType": "client_credentials","clientId": clientid,"clientSecret": clientsecret})
response = requests.post(access_token_publish_url, headers=headers, data=data)
access_token = json.loads(response.text)["access_token"]

api_url = api_base_url + "nlp/beta/user_attribute"
headers = {"Authorization": "Bearer " + access_token, "Content-Type": "application/json;charset=UTF-8"}

char_list = []
for i in range(0, char_num+1):
    exec('l = char{}'.format(i))
    data = json.dumps({"document": l})
    response = requests.post(api_url, headers=headers, data=data)
    result = json.loads(response.text)
    char_list.append(result)
    print(result)

with open('./ehon_json/char.json', 'w') as f:
    json.dump(char_list, f, indent=4, ensure_ascii=False)

Auf diese Weise erstellte ich eine Liste von Äußerungen für jeden Sprecher, einschließlich des Erzählers, des weißen Kaninchens und des schwarzen Kaninchens, und warf sie in die API. Klicken Sie hier für die Ergebnisse.

·Erzähler

{
        "result": {
            "age": "40-49 Jahre alt",
            "civilstatus": "verheiratet",
            "habit": [
                "SMOKING"
            ],
            "hobby": [
                "COLLECTION",
                "COOKING",
                "FORTUNE",
                "GOURMET",
                "INTERNET",
                "SHOPPING",
                "STUDY",
                "TVGAME"
            ],
            "location": "Kinki",
            "occupation": "Mitarbeiter"
        },
        "status": 0,
        "message": "OK"
    }

・ Shiroi Sagi

    {
        "result": {
            "age": "40-49 Jahre alt",
            "civilstatus": "verheiratet",
            "earnings": "-1M",
            "hobby": [
                "COOKING",
                "GOURMET",
                "INTERNET",
                "TVDRAMA"
            ],
            "location": "Kanto",
            "occupation": "Mitarbeiter"
        },
        "status": 0,
        "message": "OK"
    }

・ Kuroisagi

    {
        "result": {
            "age": "40-49 Jahre alt",
            "earnings": "-1M",
            "hobby": [
                "INTERNET"
            ],
            "location": "Kanto",
            "occupation": "Mitarbeiter"
        },
        "status": 0,
        "message": "OK"
    }

Von oben der Erzähler, das weiße Kaninchen und das schwarze Kaninchen. Hmmm? Dieses Ergebnis war möglicherweise etwas enttäuschend. Oder besser gesagt, die Dokumentation sagte, dass es so etwas wie "Geschlecht" zurückgeben würde, aber es war nicht in den Ergebnissen enthalten. Ist es noch in der Beta? Aber es ist eine Geschichte über das Heiraten, und ich denke, es ist ein Erwachsener, also ist es vielleicht unerwartet richtig. Ich frage mich, ob es unmöglich wäre, ein großes Gesprächsprotokoll zu senden, wenn ich es so genau erhalten wollte.

Wenn sich die Genauigkeit hier erhöht, kann es möglich sein, für jedes Zeichen eine Vorlage zu erstellen und die Spracherkennung zu verwenden, um mit den Zeichen im Bilderbuch zu sprechen. Dieses Mal habe ich vorerst manuell eine solche Stimme mit Bezug auf dieses Ergebnis ausgewählt.

6. Verwenden Sie die HOYA VoiceText-API, um den besten Sprecher und Sprechstil auszuwählen und die Stimme zu synthetisieren.

Schließlich werden diese Informationen kombiniert und sprachsynthetisiert. In Bezug auf die Sprachsynthese konnte ich keine Emotionen für die COTOHA-API angeben. Da ich mich nur für den kostenlosen Plan registriert habe, habe ich diesmal versucht, HOYAs VOICE TEXT zu verwenden. Eigentlich wollte ich an der Coe-Station eine Sprachkomposition mit meiner eigenen Stimme machen und daraus eine App machen, die mein Vater jederzeit lesen würde, aber ich konnte es nicht aus eigener Kraft tun.

Bitte beachten Sie übrigens, dass die synthetische Stimme von HOYA auch eine Lizenz ist, die den Sekundärvertrieb usw. verbietet.

VoixeText Web API

Kommerzielle Nutzung, sekundäre Nutzung und Verbreitung von Sprachdaten, die mit der kostenlosen Version erstellt wurden, ist untersagt. Bitte überprüfen Sie die Nutzungsbedingungen, bevor Sie diesen Service nutzen.

Diesmal

Erzähler:"hikari"
Weißer Hase:"haruka"
Kuroi Sagi:"takeru"

Und sagte. Auch Emotionen

    "Neutral":""
    "Positive":"happiness"
    "Negative":"sadness"

Es ist eingestellt als. Wenn Sie normal synthetisieren, wird die Stimme unterbrochen, da der Puffer auf der Rückseite nicht ausreicht. Daher wird nach allen Wörtern das SSML-Tag "<vt_pause = 1000 />" hinzugefügt, um die Datei zu verlängern.

from voicetext import VoiceText
import copy
import json

speaker = {
    0:"hikari",
    1:"haruka",
    2:"takeru"
}

emotion = {
    "Neutral":"",
    "Positive":"happiness",
    "Negative":"sadness"
}

play_list = []
vt = VoiceText('XXXXXXXXXXXXXXXXX')
with open('./ehon_json/story.json', 'r') as f:
    story = json.load(f)
    for i, page in enumerate(story):
        play = {"image": "./ehon_image/{}.png ".format(i+1), "voice":[]}
        voice_list = []
        for j, speech in enumerate(page):
            print(speech)
            if speech["sentiment"] == "Neutral":
                vt.speaker(speaker[speech["char"]])
            else:
                vt.speaker(speaker[speech["char"]]).emotion(emotion[speech["sentiment"]])
            with open('./ehon_speech/{}_{}.wav'.format(i+1, j+1), 'wb') as f:
                print(speech["text"])
                f.write(vt.to_wave(speech["text"] + '<vt_pause=1000/>'))
            voice_list.append('./ehon_speech/{}_{}.wav'.format(i+1, j+1))
        play["voice"] = copy.deepcopy(voice_list)
        play_list.append(copy.deepcopy(play))
        voice_list = []


with open('./play_json/play.json', 'w') as f:
    json.dump(play_list, f, indent=4, ensure_ascii=False)

Schließlich

Das Folgende ist der Ton, der dieses Mal mit diesen Methoden erzeugt und synchron mit dem gelesenen Bild wiedergegeben wird.

pic.twitter.com/U6IXwKgUYG

— hatbot (@hatbot3) March 17, 2020

Vorerst werde ich es nur auf einen Teil setzen. Ich habe es diesmal geschafft und es war ziemlich interessant. Als Zukunftsaussicht wäre es interessant, daraus ein Gerät als "Bilderbuch-Lesekamera" wie Razpai zu machen, und ich dachte, es wäre gut, es mit einem Projektor zu verbinden, um daraus ein Theater zu machen. Wenn Sie es besser mit der Vision-API verbinden, können Sie eine interessante Erfahrung schaffen, indem Sie Wörter und Bilder verknüpfen. Es könnte interessant sein, selbst ein Bilderbuch zu schreiben oder über Graffiti im Bilderbuch zu sprechen. Emotionen können in relativ kleinen Einheiten aufgenommen werden, sodass Hintergrundmusik und Soundeffekte mit etwas mehr Modifikation hinzugefügt werden können.

Die COTOHA-API scheint besser spielbar zu sein, daher würde ich gerne einen Artikel schreiben, wenn ich ihn weiterhin implementiere.

Vorerst werde ich natürlich das Bilderbuch für meine Tochter lesen. Übrigens ist meine Tochter jetzt "1,5 Monate alt".