[PYTHON] (Hinweis) Web-App, die TensorFlow verwendet, um empfohlene Songnamen abzuleiten [Maschinelles Lernen]

Einführung

Dieser Artikel ist ** (Hinweis) Eine Web-App, die TensorFlow verwendet, um empfohlene Songnamen abzuleiten. [Erstellen einer Ausführungsumgebung mit Docker-Compose] ** ist eine Fortsetzung. Das letzte Mal habe ich TensorFlow und Flask mit Docker-Compose erstellt Dieses Mal möchte ich maschinelles Lernen mit TensorFlow + Keras organisieren. Bitte beachten Sie, dass dies ein Artikel ist, den ich für mich selbst erstellt habe. Daher ist es möglicherweise schwer zu verstehen, Informationen und Technologie sind möglicherweise veraltet: bow: Ich hoffe auch, dass es für diejenigen hilfreich ist, die selbst eine Art Webanwendung erstellen möchten.

Die eigentliche Webanwendung sieht wie im folgenden GIF aus. Als ich einen Satz in das Suchfeld eintippte, antwortete Herr Hamburg Hambird "gleiche Geschichte": klatschen: $ \ tiny {* Da es nur wenige Lerndaten gibt, werden nur einige Songs getroffen. .. Es ist schäbig} $: bow_tone1: $ \ tiny {* Wenn Sie auf den Score-Link klicken, wird ein Teil der Partitur angezeigt, der jedoch außerhalb des Geltungsbereichs des Artikels liegt.} $: no_good_tone1:

Verweise

Ich habe es als Referenz beim Erstellen dieses Artikels verwendet: bow_tone1:

• Sequential Model Guide
• [Neuronales Netz] Prinzip / Berechnungsformel für Multilayer Perceptron (MLP)
• Zusammenfassung der Verwendung von Keras [für Anfänger]
• [Einführendes maschinelles Lernen liest ein Beispiel für mehrschichtiges Perzeptron auf Keras](https://techblog.gmo-ap.jp/2017/11/09/%E6%A9%9F%E6%A2%B0%E5 % AD% A6% E7% BF% 92% E5% 85% A5% E9% 96% 80% E8% 80% 85% E3% 81% 8Ckeras% E3% 81% A7% E3% 83% 9E% E3% 83 % AB% E3% 83% 81% E3% 83% AC% E3% 82% A4% E3% 83% A4% E3% 83% BC% E3% 83% 91% E3% 83% BC% E3% 82% BB % E3% 83% 97% E3% 83% 88 /)
• Check Dense
• [Keras-Argument Hinweis] Was ist das angegebene 01_keras-Argument?
• TF-IDF
• Ungefähr wie Keras verwendet wird
• [Gebrauchsfertig! Kann im Geschäftsleben geübt werden! So erstellen Sie mit Python Apps für KI / maschinelles Lernen / Deep Learning](https://www.amazon.co.jp/%E3%81%99%E3%81%90 % E3% 81% AB% E4% BD% BF% E3% 81% 88% E3% 82% 8B-% E6% A5% AD% E5% 8B% 99% E3% 81% A7% E5% AE% 9F% E8% B7% B5% E3% 81% A7% E3% 81% 8D% E3% 82% 8B-Python% E3% 81% AB% E3% 82% 88% E3% 82% 8B-AI% E3% 83% BB% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 83% BB% E6% B7% B1% E5% B1% A4% E5% AD% A6% E7% BF% 92% E3% 82% A2% E3% 83% 97% E3% 83% AA% E3% 81% AE% E3% 81% A4% E3% 81% 8F% E3% 82% 8A% E6% 96% B9-% E3% 82% AF% E3% 82% B8% E3% 83% A9% E9% A3% 9B% E8% A1% 8C% E6% 9C% BA / dp / 4802611641)

TODO Karte

** (Hinweis) Eine Web-App, die TensorFlow verwendet, um empfohlene Songnamen abzuleiten. [Erstellen einer Ausführungsumgebung mit Docker-Compose] ** Diese Zeit ist ** maschinelles Lernen **.

• Ich habe die Artikel noch nicht organisiert, daher werde ich sie erstellen, wenn ich Zeit habe. Kann sterben ohne zu starten: angel_tone2: Bitte beachten Sie auch, dass sich die Karte beim Schreiben ändern kann. ..

Umgebung

^{* Ich denke, es wird funktionieren, auch wenn es nicht die folgende Version ist, aber bitte beachten Sie, dass es alt ist: no_good_tone2: </ sup>}

OS：Ubuntu 18.04.4 LTS
---------------------- -----------
Flask                  1.1.0
gunicorn               19.9.0
Keras                  2.3.1
Keras-Applications     1.0.8
Keras-Preprocessing    1.1.2
matplotlib             3.1.1
mecab-python3          0.996.2
numpy                  1.16.4
pandas                 0.24.2
Pillow                 7.1.2
pip                    20.1
Python                 3.6.9
requests               2.22.0
scikit-learn           0.21.2
sklearn                0.0
tensorflow             2.2.0

Ablauf des Teils, der auf empfohlene Songs folgt

Zunächst möchte ich folgende Funktionen erstellen. Es ist eine Web-API, die den empfohlenen Songtitel zurückgibt, wenn Sie ihn eingeben und ihm einen Satz geben (Songatmosphäre usw.). Die eigentliche Web-API lautet wie folgt.

Im Beispiel ist der Parameter der GET-Methode "ein Lied, das traurig ist und jemandem Glück wünscht". Ich konnte den Songtitel "Clouds go" in JSON bekommen. [(Beispiel) Web-API-Link](http://52.192.175.215:8888/recommend/api/what-music/ Ein Lied, das jemandem Glück wünscht)

Der Verarbeitungsablauf innerhalb dieser Web-API ist wie folgt. Der Songtitel wird am Ende wie ein Flow zurückgegeben, aber die Gewichtsdaten werden in der Mitte gelesen. Dies ist ein vorab trainiertes Modell, das durch maschinelles Lernen erstellt wurde. Lassen Sie uns also organisieren, wie ein trainiertes Modell erstellt wird.

Ablauf des maschinellen Lernens

Der folgende Ablauf ist aus Sicht des Entwicklers und der Ablauf bis zum maschinellen Lernen. Bereiten Sie zunächst die zu lernenden Daten vor. Dies geschieht mit Text, der vom Menschen verstanden werden kann. Als nächstes wird eine Vorverarbeitung durchgeführt, damit die Maschine (der Computer) sie verstehen kann. In diesem Beispiel werden die Trainingsquellendaten durch ein Verfahren namens TF-IDF in einen numerischen Vektor konvertiert. Schließlich wird maschinelles Lernen mit MLP (Multilayer Perceptron) durchgeführt. Details von jedem werden später beschrieben.

Erstellung von Lernquelldaten

Die Daten, die die Lernquelle darstellen, werden wie unten gezeigt durch Kommas getrennt. Originaldaten des maschinellen Lernens Enthält Songinformationen (Atmosphäre, Künstlername usw.), aus denen der Songtitel abgeleitet werden soll. Es ist durch "|" (Pipe) getrennt, aber ohne ist es in Ordnung.

Vorbehandlung (TF-IDF)

Mit TF-IDF in einen numerischen Vektor konvertieren. Laden Sie zunächst die oben erstellten Lernquellendaten. Teilen Sie dann den Satz für die TF-IDF-Berechnung in Wörter (separates Schreiben). Dieser Prozess verwendet MeCab für die morphologische Analyse. Als Referenz ist die Quelle der Teilung wie folgt.

Unten finden Sie den Code, der in Google Colaboratory eingefügt werden soll. $ \ tiny {* Starr es nicht an} $: no_good_tone1: Bitte einfügen und in der Reihenfolge von oben ausführen. ..

Installieren Sie die erforderlichen Bibliotheken

#Installieren Sie die erforderlichen Bibliotheken
!apt-get install mecab libmecab-dev mecab-ipadic-utf8
!pip3 install mecab-python3

Getrennter Teil (Teilauszug)

import MeCab

#MeCab-Initialisierung
tagger = MeCab.Tagger()

def tokenize(text):
    '''Führen Sie eine morphologische Analyse mit MeCab durch''' 
    result = []
    word_s = tagger.parse(text)
    for n in word_s.split("\n"):
        if n == 'EOS' or n == '': continue
        p = n.split("\t")[1].split(",")
        h, h2, org = (p[0], p[1], p[6])
        if not (h in ['Substantiv', 'Verb', 'Adjektiv']): continue
        if h == 'Substantiv' and h2 == 'Nummer': continue
        result.append(org)
    return result

#Modul testen
if __name__ == '__main__':
    print(tokenize("Filme|Tetsuya Takeda|schmerzlich|Ich wünsche mir das Glück von jemandem, den ich nicht kenne"))

Wenn Sie es ausführen, sollte auf der Konsole Folgendes angezeigt werden:

['Filme', '*', 'Takeda', 'Tetsuya', '*', 'schmerzlich', '*', 'kennt', 'Wer', 'Glück', 'Wunsch']

Durch Wort getrennt. Das obige Beispiel ist nur ein Satz, Im eigentlichen Programm wird dieser Vorgang für die Anzahl der Sätze (Zeilen) in der Datei wiederholt.

Wenn Sie es separat schreiben können, berechnen Sie TF-IDF. In Bezug auf TF-IDF werde ich es zitieren, weil es eine leicht verständliche Erklärung gab. Quelle: TF-IDF

Mit diesem Wert werden die charakteristischen Wörter des Dokuments aus dem Dokument extrahiert. Wenn es mehrere Dokumente gibt, aus den darin enthaltenen Wörtern und ihrer Häufigkeit, Quantifizieren Sie, was ein wichtiges Wort für ein Dokument ist

TF-IDF wird durch die folgende Formel ausgedrückt.

\textrm{TF_IDF}(t) = \textrm{tf}(t,d) × \textrm{idf}(t)

Außerdem werden $ \ textrm {tf} (t, d) $ und $ \ textrm {idf} (t) $ durch die folgenden Formeln ausgedrückt.

\textrm{tf}(t,d) = \frac{n_{t,d}}{\sum_{s \in d}n_{s,d}}　\textrm{  , }　\textrm{idf}(t) = \log{\frac{N}{df(t)}} + 1

$ n_ {t, d} $: Anzahl der Vorkommen eines Wortes $ t $ im Dokument $ d $ $ \ sum_ {s \ in d} n_ {s, d} $: Summe der Anzahl der Vorkommen aller Wörter im Dokument $ d $ $ N $: Gesamtzahl der Dokumente $ df (t) $: Anzahl der Dokumente, in denen ein Wort $ t $ vorkommt

Die obige Formel kann wie folgt in ein Programm konvertiert werden.

TF-IDF-Berechnung(Auszug)

def calc_files():
    '''Berechnen Sie die hinzugefügte Datei'''
    global dt_dic
    result = []
    doc_count = len(files)
    dt_dic = {}
    #Zählen Sie die Häufigkeit des Auftretens von Wörtern
    for words in files:
        used_word = {}
        data = np.zeros(word_dic['_id'])
        for id in words:
            data[id] += 1
            used_word[id] = 1
        #Dt wenn das Wort t verwendet wird_Fügen Sie dic hinzu
        for id in used_word:
            if not(id in dt_dic): dt_dic[id] = 0
            dt_dic[id] += 1
        #Konvertieren Sie die Anzahl der Auftritte in einen Prozentsatz--- (*10)
        data = data / len(words) 
        result.append(data)
    # TF-IDF berechnen
    for i, doc in enumerate(result):
        for id, v in enumerate(doc):
            idf = np.log(doc_count / dt_dic[id]) + 1
            doc[id] = min([doc[id] * idf, 1.0])
        result[i] = doc
    return result

^{* Diese [Referenz](https://www.amazon.co.jp/%E3%81%99%E3%81%90%E3%81%AB%E4%BD%BF%E3%81 % 88% E3% 82% 8B-% E6% A5% AD% E5% 8B% 99% E3% 81% A7% E5% AE% 9F% E8% B7% B5% E3% 81% A7% E3% 81% 8D% E3% 82% 8B-Python% E3% 81% AB% E3% 82% 88% E3% 82% 8B-AI% E3% 83% BB% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 83% BB% E6% B7% B1% E5% B1% A4% E5% AD% A6% E7% BF% 92% E3% 82% A2% E3% 83% 97% E3% 83% AA% E3% 81% AE% E3% 81% A4% E3% 81% 8F% E3% 82% 8A% E6% 96% B9-% E3% 82% AF% E3% 82% B8 % E3% 83% A9% E9% A3% 9B% E8% A1% 8C% E6% 9C% BA / dp / 4802611641) Die Probenquelle [^ 1] ist fast umgeleitet, diesmal jedoch auf Github Ich gebe dir die Quelle. </ sup> (Quelle) </ sup> [^ 1]: [Umleitungsquelle: Gebrauchsfertig! Kann im Geschäftsleben geübt werden! Beispielcode zum Erstellen von Apps für KI / maschinelles Lernen / Deep Learning mit Python](https://github.com/kujirahand/book-mlearn- Gyomu)}

Die Quelle zum Berechnen und Ausgeben von TF-IDF aus dem Lesen der Lernquelldatei ist wie folgt. Da die Quelle für die Berechnung des essentiellen TF-IDF lang ist, wird sie modularisiert und lautet: Schweiß: Es liest auch die Lernquellendaten. Es ist unten gespeichert, also laden Sie es bitte hoch. tfidfWithIni.py ← Modul zur Berechnung des TF-IDF ans_studyInput_fork.txt ← Quelldatei lernen

Verfahren zur Erstellung von TF-IDF-Vektoren

Unten finden Sie den Code, den Sie als Referenz in Google Colaboratory einfügen können. $ \ tiny {* Starr es nicht an} $: no_good_tone1: Bitte einfügen und in der Reihenfolge von oben ausführen. ..

Schritt 1_Datei hochladen

#Datei hochladen ("tfidfWithIni".py」、「ans_studyInput_fork.txt」）
from google.colab import files
uploaded = files.upload()

Schritt 2_Installieren Sie die erforderlichen Bibliotheken

#Erstellen Sie ein Verzeichnis zum Speichern von Dateien
!mkdir text
#Installieren Sie die erforderlichen Bibliotheken
!apt-get install mecab libmecab-dev mecab-ipadic-utf8
!pip3 install mecab-python3

Schritt 3_TF-In IDF-Vektor konvertieren

import os, csv, glob, pickle
import tfidfWithIni
import importlib

#Modul neu laden (tfidfWithIni)
importlib.reload(tfidfWithIni)

#Variable Initialisierung
y = []
x = []

#Label Code Conversion Dictionary
labelToCode = {}

#CSV-Datei lesen
def read_file(path):
    '''Fügen Sie eine Textdatei zum Lernen hinzu''' # --- (*6)
    with open(path, "r", encoding="utf-8") as f:
        reader = csv.reader(f)   
        label_id = 0  
        for row in reader:
            #Erstellung des Etikettencodes
            if row[2] not in labelToCode:
                labelToCode[row[2]] = label_id
                label_id += 1
                
            y.append(labelToCode[row[2]])  #Bezeichnung setzen
            tfidfWithIni.add_text(row[3])  #Setze Sätze
           # print("Etikette: ", row[2], "(", labelToCode[row[2]], ")",  "Satz: ", row[3])

#Modul testen--- (*15)
if __name__ == '__main__':
    # TF-IDF-Vektor initialisieren(Dateien leeren)
    tfidfWithIni.iniForOri()
    
    #Lesen Sie die Dateiliste--- (*2)
    read_file("ans_studyInput_fork.txt")

    # TF-In IDF-Vektor konvertieren--- (*3)
    x = tfidfWithIni.calc_files()

    #sparen--- (*4)
    pickle.dump([y, x], open('text/genre.pickle', 'wb'))
    tfidfWithIni.save_dic('text/genre-tdidf.dic')
    pickle.dump(labelToCode, open('text/label_to_code.pickle', 'wb'))

Bei der Ausführung werden Ordner und Dateien wie unten gezeigt erstellt.

• /content/text/genre.pickle: Von TF-IDF vektorisiertes Wort
• /content/text/label_to_code.pickle: Ein Wörterbuch, das Songtitel basierend auf der Lernquelldatei beschriftet
• /content/text/genre-tdidf.dic: Wörterbuch für die TF-IDF-Berechnung

Das Wörterbuch für die TF-IDF-Berechnung ist die Umwandlung der in der Berechnung verwendeten Wörter in ID wie folgt.

Maschinelles Lernen (MLP)

Mit der Vorverarbeitung sind wir bereit für maschinelles Lernen. Basierend auf den oben genannten Lerndaten wird das Lernen durchgeführt, damit der Songtitel korrekt identifiziert werden kann. MLP (Multilayer Perceptron) wird als Lernmethode verwendet. MLP ist eine Art neuronales Netzwerk, das menschliche Nerven imitiert. Es scheint, dass es aus einer Schicht von drei oder mehr Knoten besteht. MLP verwendet eine bestimmte Methode, um basierend auf Lerndaten (korrekte Daten) zu lernen. Selbst wenn unbekannte Daten (die Atmosphäre des Songs in diesem Beispiel) eingehen, ist es möglich, den Songtitel in diesem Beispiel korrekt zu bestimmen. Dazu verwenden wir das Framework für maschinelles Lernen TensorFlow + Keras. Und dieses Mal erstellen wir ein neuronales Netzwerk mit der folgenden Struktur _{* Dies ist ein Bild </ sub>: Schweiß:}

Die Modellierung mit TensorFlow + Keras zur Erstellung dieses neuronalen Netzwerks sieht folgendermaßen aus [^ 1].

#Definieren Sie die MLP-Modellstruktur
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(in_size,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(nb_classes, activation='softmax'))

Die Ebene verwendet das, was von Keras als dicht bezeichnet wird. Damit befindet sich jedes Perceptron auf der nächsten Ebene Es scheint, dass alles mit Perceptron verbunden sein wird. Auch die Anzahl der Eingaben im Bilddiagramm reicht von x1 bis xt, dies wird jedoch durch das Argument input_shape definiert. Es sind nur ein paar Minuten eines Wortes, das durch Teilen des gesamten Satzes entsteht. In der Beispieltrainingsdatei befinden sich 144 (Abmessungen). Die Ausgabe lautet y1 bis yclass. Dies ist die Anzahl der Songtitel in der Lerndatei und wird durch das Argument nb_classes angegeben. Das Beispiel enthält 10 (Songs).

Legen Sie als Nächstes fest, wie das Training durchgeführt werden soll, damit es korrekt bestimmt werden kann (kompilieren). RMSprop als Optimierungsalgorithmus basierend auf Keras Documentation Multiclass Classification Problem Sagen wir kategoriale_kreuzentropie als Verlustfunktion. _{* (Bild der Wörter) Verlustfunktion: Index zur Messung der Lernabweichung, Optimierungsalgorithmus: Korrekturmethode, um der richtigen Antwort näher zu kommen </ sub>}

#Kompilieren Sie das Modell
model.compile(
    loss='categorical_crossentropy',
    optimizer=RMSprop(),
    metrics=['accuracy'])

Schließlich der Ausführungsteil des Lernens. Das Training wird nach der Fit-Methode durchgeführt. Eingabe (Songatmosphäre usw.) und Ausgabe (Songtitel) Sie können lernen, indem Sie das Numpy-Array der Anpassungsmethode des Sequenzmodells zuweisen.

hist = model.fit(x_train, y_train,
          batch_size=16, #Anzahl der gleichzeitig zu berechnenden Daten
          epochs=150,    #So etwas wie die Anzahl der Wiederholungen des Lernens
          verbose=1,
          validation_data=(x_test, y_test))

Durchführung des maschinellen Lernens

Unten finden Sie den Code, den Sie als Referenz in Google Colaboratory einfügen können.

Nach dem Ausführen von bis zu Schritt 3 von [der obigen TF-IDF-Vektorerstellungsprozedur](# tf-idf-Vektorerstellungsprozedur) Sie sollten in der Lage sein, maschinelles Lernen wie folgt durchzuführen:

Schritt 4_Durchführung des maschinellen Lernens (MLP)

import pickle
from sklearn.model_selection import train_test_split
import sklearn.metrics as metrics
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import matplotlib.pyplot as plt
import numpy as np
import h5py

#Anzahl der zu klassifizierenden Etiketten
labelToCode = pickle.load(open("text/label_to_code.pickle", "rb"))
nb_classes = len(labelToCode) 

#Datenbank lesen
data = pickle.load(open("text/genre.pickle", "rb"))
y = data[0] #Beschriftungscode
x = data[1] # TF-IDF
#Beschriften Sie die Daten eins-In heißen Vektor konvertieren
y = keras.utils.np_utils.to_categorical(y, nb_classes)
in_size = x[0].shape[0] #Eingabe x[0]Anzahl der Elemente von

#Zum Lernen und Testen getrennt
x_train, x_test, y_train, y_test = train_test_split(
        np.array(x), np.array(y), test_size=0.2)

#Definieren Sie die MLP-Modellstruktur
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(in_size,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(nb_classes, activation='softmax'))

#Kompilieren Sie das Modell
model.compile(
    loss='categorical_crossentropy',
    optimizer=RMSprop(),
    metrics=['accuracy'])

#Führen Sie das Lernen durch
hist = model.fit(x_train, y_train,
          batch_size=16, #Anzahl der gleichzeitig zu berechnenden Daten
          epochs=150,    #So etwas wie die Anzahl der Wiederholungen des Lernens
          verbose=1,
          validation_data=(x_test, y_test))

#bewerten
score = model.evaluate(x_test, y_test, verbose=1)
print("Richtige Antwortrate=", score[1], 'loss=', score[0])

#Gewichtsdaten speichern
model.save_weights('./text/genre-model.hdf5')

#Zeichnen Sie den Lernstatus in ein Diagramm
plt.plot(hist.history['val_accuracy'])
plt.title('Accuracy')
plt.legend(['train', 'test'], loc='upper left')
plt.show()

Nach Abschluss der Ausführung wird das folgende Diagramm angezeigt und die Datei (/content/text/genre-model.hdf5) angezeigt. Es sollte zusätzlich erstellt worden sein. Dies ist das Ende des maschinellen Lernens.

Errate den Songtitel anhand des trainierten Modells

Im Analogie-Teil definieren wir dasselbe Modell wie beim maschinellen Lernen. Laden Sie das trainierte Modell, das TF-IDF-Wörterbuch und das Ergebnisbeschriftungswörterbuch. Dann wird das unbekannte Dokument (die Atmosphäre des Liedes) in einen TF-IDF-Vektor umgewandelt. Wenn Sie den TF-IDF-Vektor der Vorhersagemethode von Sequencial geben, wird der Songtitel abgeleitet.

Unten finden Sie den Code, den Sie als Referenz in Google Colaboratory einfügen können.

Nach dem Ausführen von bis zu Schritt 4 von [Ausführung des maschinellen Lernens oben](# Ausführung des maschinellen Lernens) Sie sollten in der Lage sein, den Songtitel zu erraten, indem Sie die folgenden Schritte ausführen.

In Analogie zum Songtitel

import pickle, tfidfWithIni
import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
from keras.models import model_from_json
import importlib

#Modul neu laden (tfidfWithIni)
importlib.reload(tfidfWithIni)

def inverse_dict(d):
    return {v:k for k,v in d.items()}

#Beurteilung durch Angabe von Text
def getMusicName(text):
    # TF-In IDF-Vektor konvertieren
    data = tfidfWithIni.calc_text(text)
    #Vorausgesagt von MLP
    pre = model.predict(np.array([data]))[0]
    n = pre.argmax()
    print("Empfohlener Songname: " + label_dic[n], "(", pre[n], ")")
    

#Etikettendefinition
labelToCode = pickle.load(open("text/label_to_code.pickle", "rb"))
nb_classes = len(labelToCode) 
label_dic = inverse_dict(labelToCode)

#Suchen Sie die Anzahl der Eingabeelemente aus dem Wörterbuch.
in_size_hantei = pickle.load(open("text/genre-tdidf.dic", "rb"))[0]['_id']

# TF-IDF-Wörterbuch lesen
tfidfWithIni.load_dic("text/genre-tdidf.dic")

#Definieren Sie das Keras-Modell und lesen Sie die Gewichtsdaten
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(in_size_hantei,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(
    loss='categorical_crossentropy',
    optimizer=RMSprop(),
    metrics=['accuracy'])
model.load_weights('./text/genre-model.hdf5')
    
if __name__ == '__main__':
    requestParam = """
Ein Lied, das traurig ist und sich jemandes Glück wünscht
    """
    getMusicName(requestParam)

Sie kann sich je nach Lernergebnis ändern, wird jedoch wie folgt angezeigt.

Empfohlener Songname:Die Wolken ziehen( 0.99969995 )

Letztes Mal Ich mache ein bisschen Songtitel-Analogie mit der Web-API unter Verwendung von Flask, daher möchte ich es weglassen: Schweiß:

Über die Zukunft

Dieses Mal konnte ich mich ein wenig bis zum maschinellen Lernen organisieren. Außerdem hoffe ich, dass ich es nach und nach auffrischen und organisieren kann, wenn ich Zeit habe: schluchzen: Es ist unentschlossen, aber beim nächsten Mal möchte ich die Umgebungskonstruktion auf der Bildschirmseite organisieren.