[PYTHON] Für Sie, die beim Lernen mit maschinellem Lernen plötzlich auf das Protokoll schauen ~ Muskeltraining mit LightGBM ~

Was macht ihr, wenn ihr ein Modell mit maschinellem Lernen lernt? Betrachten Sie die Protokollausgabe an die Konsole? „Oh, es ist niedriger als ich erwartet hatte!" „Oh, die Genauigkeit wird immer schlechter, gib dein Bestes !!" Beim Nachdenken macht es überraschend Spaß zu sehen.

Aber selbst wenn Sie es anfeuern, gibt das Modell nicht sein Bestes und es gibt keine dramatische Entwicklung. Es ist also Zeitverschwendung, es zu sehen. Ich bemerkte, als ich darüber nachdachte.

** "Oh, warum trainierst du diesmal nicht?" **

Deshalb dachte ich an eine Umgebung, in der ich zwischen maschinellem Lernen Muskeln trainieren konnte.

Dies ist Hattori von NTT Docomo. Dies ist der Artikel am 23. Tag von AdventCalender2019, NTT Docomo Service Innovation Department.

Wer ist das Ziel dieses Artikels?

Ich mag Muskeltraining
Personen im Bereich des maschinellen Lernens, denen es an Bewegung mangelt
Personen, die häufig LightGBM verwenden, wie z. B. Kaggler

Warum trainierst du deine Muskeln?

Um die Genauigkeit des Modells zu verbessern, müssen die Hypothese und die Überprüfung viele Male wiederholt werden.

Wenn sich die Genauigkeit jedoch überhaupt nicht verbessert, kann die Motivation abnehmen.

** In einem solchen Fall ist Muskeltraining effektiv. ** **.

Wenn Sie Muskeltraining machen, wird die Sekretion eines Hormons namens "Testosteron" aktiviert. Testosteron ist ein Hormon, das die Motivation des Gehirns steuert und es absondert Auch wenn sich die Genauigkeit nicht verbessert und Sie depressiv sind

"OK! Noch einmal!"

Es wurde angenommen, dass die Genauigkeit verbessert wurde.

筋トレ効果.png

Ich habe auch das Gefühl, dass Muskeltraining in letzter Zeit in der Welt populär geworden ist. Eine Animation von Highschool-Mädchen, die Muskeln trainieren, wird ausgestrahlt, und eine App, die Muskeln auf der Yamate-Linie trainiert, wird angezeigt. Immerhin scheint die Nachfrage nach Muskeltraining hoch zu sein.

Muskeltraining auf der Yamate Line ... "Nur-Zug-App" von JR East eingeführt. Aber kümmern Sie sich nicht um die Augen um Sie herum?

Richtung

Ich kann Muskeltraining also nicht wirklich erzwingen

Erstellen Sie eine Situation, in der Sie denken: "Ich muss meine Muskeln trainieren!" → ** Muskeltrainingsmenü ・ Startsignale, Rhythmus usw. abspielen **
Steigern Sie die Motivation für das Muskeltraining → ** Abhängig von der Lernsituation (Genauigkeit) kann die Anzahl der Muskeltrainings usw. geändert werden, um einen spielerischen Charakter zu erhalten **

Konzentrieren Sie sich auf solche Orte.

Darüber hinaus ist LightGBM das zu implementierende Zielmodell.

Das "Deep Learning" -Modell braucht in der Regel viel Zeit zum Lernen, und es ist schwierig, das Training fortzusetzen, selbst wenn Sie es versuchen, also habe ich aufgegeben ... orz

Was ist LightGBM?

LightGBM ist eine von Microsoft entwickelte Bibliothek zur Steigerung des Gradienten. Es wird häufig in Kaggle [^ 1] verwendet und ist attraktiv für seine hohe Genauigkeit und schnelle Lerngeschwindigkeit. XGBoost ist auch berühmt, aber ich habe den Eindruck, dass LightGBM heutzutage verwendet wird.

Über LightGBM ist der folgende Artikel leicht zu verstehen.

Offizielles LightGBM-Dokument (Englisch) 7 Gründe für "First Light GBM" Eine gründliche Einführung in LightGBM - wie man LightGBM verwendet, wie es funktioniert und wie es sich von XGBoost unterscheidet

LightGBM-Rückruffunktion

Dieses Mal werden wir hauptsächlich die Rückruffunktion von LightGBM verwenden, um sie zu implementieren. Die Rückruffunktion von LightGBM wird während des Trainings ausgeführt, indem eine Rückruffunktion übergeben wird, die Sie während des Trainings definiert haben.

Grundsätzlich wird in vielen Bibliotheken für maschinelles Lernen (mit Ausnahme des NN-Frameworks) das Lernen auf der Bibliotheksseite durchgeführt, sodass es für den Benutzer schwierig ist, es während des Lernens anzupassen, aber die Rückruffunktion ermöglicht verschiedene Anpassungen. Werden.

Zum Beispiel

--Senden Sie den Lernfortschritt an den Logger (und senden Sie ihn an Slack / LINE).

Implementierung Ihres eigenen frühen Stopps
Dynamische Änderung von Hyperparametern

Es gibt viele Möglichkeiten, es zu verwenden, und es ist nützlich für schwere Benutzer.

So funktioniert die Rückruffunktion

Die Rückruffunktion ist so definiert, dass sie Argumente vom Typ namedtuple akzeptiert (env im folgenden Beispielcode). Da es eine Variable enthält, die den Lernstatus enthält, definieren Sie die Verarbeitung, die es verwendet. Was Sie erhalten können

Hyperparameter
Aktuelle Anzahl von Iterationen
Zug / gültige Punktzahl in der aktuellen Iteration
Lernmodell (Booster-Klasse)

Etc.

Wenn die definierte Rückruffunktion trainiert und ausgeführt wird, z. B. "lgb.train ()" und "lgb.fit ()", wird sie im Listenformat mit dem Argumentnamen callbacks übergeben. Unten finden Sie einen einfachen Beispielcode.

import lightgbm as lgb

....

def callback_func(env):
    """
Rückruffunktion, die Sie definieren
Argument env(namedtuple)Sie können den Lernstatus von erhalten
    """
    if env.iteration + 1 % 100 == 0:
        print(f"jetzt,{env.iteration + 1}Die Iteration ist beendet")


lgb.train(
    lgb_param,
    .....
    callbacks=[callback_func] #Übergeben Sie die in Rückrufen definierte Funktion im Listenformat
)

Wenn Sie sich die unten stehenden Links ansehen, können Sie mehr über den Inhalt und andere Verwendungszwecke erfahren.

LightGBM/callback.py at master · Microsoft/LightGBM · GitHub Verwendung von LightGBM (Rückruffunktion), das zu detailliert ist, um es zu vermitteln Lernverlauf über Logger mit LightGBM-Rückruf ausgeben

Implementierte Funktion

Geben Sie während des Lernens eine Anleitung zum Muskeltraining

Zu Beginn des Lernens: Anleitung zum Starten des Muskeltrainingsmenüs --Beispiel: "30-mal Bauchmuskeln starten"
Machen Sie in regelmäßigen Abständen einen Metronom-Sound (Bauern-Sound)
Beispiel: Bauer alle 5 Sekunden
Endanleitung am Ende des Lernens / maximale Anzahl von Malen
Beispiel: „Danke für Ihre harte Arbeit." „Ich habe mein Bestes gegeben."

Ideal für Muskeltraining

Eine feste Zeit (Beispiel: Planke 30 Sekunden)
Die Anzahl der Male ist festgelegt (Beispiel: Bauchmuskel 30 Mal)

Es gibt zwei Arten, und das Timing des Metronom-Sounds hängt davon ab, um welchen Typ es sich handelt.

Dinge mit einer festen Zeit

In regelmäßigen Abständen werden Töne erzeugt, bis die Zielzeit erreicht ist. Anstatt es auf eine normale Zeit einzustellen, entschied ich mich jedoch, die Zielzeit und das Intervall festzulegen, in dem der Ton durch maschinelles Lernen ertönt, da ich während des Lernens mein Bestes auf derselben Zeitachse wie LightGBM geben wollte.

Ich habe das Gefühl, dass ** "300iteration plank" ** sich mit dem Modell besser anfreundet als "30 second plank".

Die mit einer festen Anzahl von Malen

Wenn die Anzahl der Male festgelegt ist, ist das Tempo wichtig, sodass es schwierig ist, die Anzahl der Iterationen anzupassen. Stellen Sie es daher in Sekunden ein. In den ersten Iterationen wird die Anzahl der Iterationen für die angegebene Anzahl von Sekunden berechnet, und danach wird jedes Mal der Metronomklang ausgegeben.

Das Muskeltrainingsmenü ist angegeben oder zufällig

Es ist nicht gut, nur das gleiche Training zu machen, deshalb habe ich es möglich gemacht, es selbst zu spezifizieren oder zufällig festzulegen. Wir empfehlen zufällige Einstellungen und geben gerne an, welche Art von Training Sie durchführen werden.

Wenn die Genauigkeit besser als beim letzten Mal ist, ändert sich der Metronomklang

Wenn Sie herausfinden, dass "Oh, die Genauigkeit hat sich verbessert!" Während des schmerzhaften Muskeltrainings werden Sie für das Muskeltraining motiviert. Es verhindert auch, dass Sie sich aufgrund von Bedenken hinsichtlich der Genauigkeit beim Lernen nicht auf das Muskeltraining konzentrieren können.

Um dies zu implementieren, geben Sie das Lernprotokoll jedes Mal in eine Protokolldatei aus Implementiert, um das vorherige Lernprotokoll zu lesen und zu vergleichen.

Wenn die Genauigkeit schlechter ist als beim letzten Mal, eine Strafe (zusätzliches Muskeltraining)

Die Genauigkeit des Modells beeinflusst auch das Muskeltraining, indem es ihm ein spielerisches Gefühl verleiht. Dies kann auch durch Vergleich mit dem vorherigen Lernprotokoll erreicht werden.

Strafe (zusätzliches Muskeltraining), auch wenn das Lernen in der Mitte gestoppt wird

Unterwegs aufhören zu lernen ≒ Die Genauigkeit hat sich nicht verbessert In diesem Fall handelt es sich um ein Strafmuskeltraining. Dies wird durch Abfangen der Tastaturunterbrechungsausnahme behandelt.

Ich erlaube dir nicht, mit "Strg + C" durchzulaufen.

Implementierung

Ausführungsumgebung / Vorbereitung

MacOS 10.14.5
Python 3.6.8
lightgbm 2.3.0
VLC media player 3.0.8

Installation

#VLC-Installation
brew cask install vlc
# Python-VLC-Installation
pip install python-vlc
#Installieren Sie LightGBM
pip install lightgbm

Vorbereitung der Schallquelle

Es ist notwendig, die Schallquelle vorzubereiten.

Erstellen Sie für Sprache mit MacOS die Standard-Sprachlesefunktion [^ 2]. Weitere Soundeffekte sind auf der kostenlosen Soundquellenseite verfügbar [^ 3].

Sie können motivierter sein, wenn Sie die Stimme vorbereiten, die Sie mögen.

Quellcode

Vordefinierte Konfiguration

Stellen Sie das Muskeltrainingsmenü, den Typ, die Anzahl der Ausführungen, den Pfad der Schallquelle usw. ein. Es ist nicht wesentlich, also werde ich es falten.

Konfigurationscode für das Muskeltrainingsmenü

train_config = {
    "planc":{
        "train_menu": "planc",
        "train_type": "duration",
        "total_iteration": 500,
    },
    "abs":{
        "train_menu": "abs",
        "train_type": "iter",
        "total_times": 50,
        "seconds_1time": 3
    },
    "pushup":{
        "train_menu": "pushup",
        "train_type": "iter",
        "total_times": 50,
        "seconds_1time": 2
    },  
    "squat":{
        "train_menu": "squat",
        "train_type": "iter",
        "total_times": 50,
        "seconds_1time": 2
    },
}

def make_sound_dict(config):
    sound_dict = {
        "iteration_10":[
            'sound/iter_sound_1.mp3'
        ],
        "iteration_100":[
            'sound/iter_sound_2.mp3'
        ],
        "iteration_100_better":[
            'sound/iter_sound_3.mp3'
        ],
        "train_finish":[
            'sound/finish.mp3'
        ]
    }
    if config["train_type"] == "duration":
        sound_dict["train_start"] = [
            f"sound/{config['total_iteration']}iter.mp3", #N Iteration
            f"sound/{config['train_menu']}_train.mp3",
            "sound/start.mp3"
        ]
    elif config["train_type"] == "iter":
        sound_dict["train_start"] = [
            f"sound/{config['train_menu']}_train.mp3", #Name des Muskeltrainings (z:Arm anfällig, Bauchmuskeln ,. .. .. )
            f"sound/{config['total_times']}times.mp3",  #N Iteration
            "sound/start.mp3" #Start
        ]
    return sound_dict

Muskeltrainingskurs inklusive Rückruffunktion

Es ist ein bisschen lang, aber es ist der Hauptteil, also werde ich es so ausdrücken, wie es ist.

class MuscleSound():
    """
Rückruf zum Muskeltraining mit LightGBM
    """
    def __init__(self, train_config, train_menu="planc"):
        if train_menu == "random":
            #Im Falle eines Zufalls zufällig aus dem Menü einstellen
            train_menu = random.choice(train_config.keys())
        assert(train_menu in train_config.keys())
        self.train_menu = train_menu
        self.config = train_config[train_menu]
        self.sound_dict = make_sound_dict(self.config)
        self.log_dir = "./muscle"
        self.start_time = None
        self.n_iter_1time = None
        # setup
        os.makedirs(self.log_dir, exist_ok=True)
        self._setup_prev_log()
        self._load_prev_log()

    def media_play(self, media_list):
        """
Spezifizierte Medien_Spielen Sie die Audiodateien in der angegebenen Reihenfolge ab
        """
        p = vlc.MediaListPlayer()
        vlc_media_list = vlc.MediaList(media_list)
        p.set_media_list(vlc_media_list)
        p.play()

    def _setup_prev_log(self):
        """
Das vorherige Lernprotokoll ist curr.Es ist ein Protokoll
        prev.Umbenennen, um zu protokollieren
        """
        log_filepath = os.path.join(self.log_dir, "curr.log")
        if os.path.exists(log_filepath):
            os.rename(
                log_filepath,
                os.path.join(self.log_dir, "prev.log")
            )

    def _load_prev_log(self, log_filepath="muscle/prev.log"):
        """
Lesen Sie das Protokoll vom letzten Lernen
        """
        if os.path.exists(log_filepath):
            self.prev_log = pd.read_csv(
                log_filepath, names=["iter","score"]
            ).set_index("iter")["score"]
        else:
            self.prev_log = None

    def _check_score(self, env):
        """
Vergleichen Sie die Ergebnisse und speichern Sie die Protokolle
        """
        n_iter = env.iteration + 1
        is_better_score = False
        #Validierungsbewertung extrahieren
        # valid_Verwenden Sie die Punktzahl des letzten Datensatzes in Sätzen
        curr_score = env.evaluation_result_list[-1][2]
        #Ob je höher die Zahl, desto besser die Punktzahl
        is_upper_metric = env.evaluation_result_list[-1][3]
        #Vergleichen Sie, ob das vorherige Protokoll dieselbe Iterationsbewertung aufweist
        if self.prev_log is not None and n_iter in self.prev_log.index:
            prev_score = self.prev_log.loc[n_iter]
            is_better_score = curr_score > prev_score \
                if is_upper_metric else curr_score < prev_score
        #Protokoll speichern
        with open(os.path.join(self.log_dir, "curr.log"), "a") as f:
            f.write(f"{n_iter},{curr_score}\n")
        return is_better_score

    def play_train_start(self, train_menu):
        """
Tonwiedergabe zu Beginn des Lernens
        """
        self.play_media_list(self.sound_dict["train_start"])
        #Ein wenig Schlaf, damit das Lernen (Muskeltraining) nicht vor dem Lesen beginnt
        time.sleep(5)

    def duration_sound(self, env):
        """
Für Muskeltraining mit fester Zeit
Machen Sie einen Ton bei einer bestimmten Anzahl von Iterationen
        """
        if (env.iteration + 1) > self.config["total_iteration"]:
            #Tun Sie nichts, wenn die maximale Anzahl von Iterationen zum Trainieren von Muskeln überschritten wird
            return
        elif env.iteration + 1 == self.config["total_iteration"]:
            #Signalisiert, weil die Anzahl der Enden erreicht wurde
            self.media_play(self.sound_dict["train_finish"])
        elif (env.iteration + 1) % 100 == 0:
            #Ton alle 100 Mal
            is_better_score = self._check_score(env)
            if is_better_score:
                self.media_play(self.sound_dict["iteration_100_better"])
            else:
                self.media_play(self.sound_dict["iteration_100"])
        elif (env.iteration + 1) % 10 == 0:
            #Ton alle 10 mal
            self.media_play(self.sound_dict["iteration_10"])

    def iter_sound(self, env):
        """
Tonwiedergabe nach Zeit (für Muskeltraining mit einer festgelegten Anzahl von Malen)
Machen Sie alle paar Sekunden einen Ton
        """
        if self.n_iter_1time is None:
            return
        if  (env.iteration + 1) > self.config["total_times"]*self.n_iter_1time:
            #Tun Sie nichts, wenn die maximale Anzahl an Muskeltraining überschritten wird
            return
        if  (env.iteration + 1) == self.config["total_times"]*self.n_iter_1time:
            #Wenn die maximale Anzahl von Malen erreicht ist, wird das Ende bekannt gegeben
            self.media_play(self.sound_dict["train_finish"])
        if  (env.iteration + 1)%self.n_iter_1time != 0:
            #Wenn es nicht durch die Anzahl der Iterationen teilbar ist, tun Sie nichts
            return
        if ((env.iteration + 1)//self.n_iter_1time) % 10 == 0:
            #Ton alle 100 Mal
            self.media_play(self.sound_dict["iteration_100"])
        else:
            #Ton alle 10 mal
            self.media_play(self.sound_dict["iteration_10"])

    def __call__(self, env):
        if env.iteration == 0:
            #Zu Beginn des Lernens
            self.media_play(self.sound_dict["train_start"])
        if self.config["train_type"] == "times":
            #Stellen Sie die entsprechende Anzahl von Iterationen pro Zeit ein
            if env.iteration == 1:
                self.start_time = time.time()
            elif env.iteration == 11:
                time_10iter = time.time() - self.start_time
                self.n_iter_1time = int(self.config["seconds_1time"] / time_10iter * 10)
                print("Anzahl der Iterationen pro Zeit", self.n_iter_1time)
        if not env.evaluation_result_list:
            return
        #Metronom-Klangwiedergabe nach Muskeltrainingstyp
        if self.config["train_type"] == "iter":
            self.iter_sound(env)
        elif self.config["train_type"] == "duration":
            self.duration_sound(env)

Strafabwicklung zum Zeitpunkt der Unterbrechung

Dies ist ein Prozess, um eine Strafe zu verhängen, wenn Sie in der Mitte aufhören zu lernen.

Dies ist nicht die Rückruffunktion, aber die Ausnahme von KeyboardInterrupt wird abgefangen und verarbeitet.

Es kann auch als Dekorateur verwendet werden, so dass es während des Lernens leicht geschrieben werden kann.

def penalty_muscle(func):
    def play_media_list(media_list):
        """
Spezifizierte Medien_Spielen Sie die Audiodateien in der angegebenen Reihenfolge ab
        """
        p = vlc.MediaListPlayer()
        vlc_media_list = vlc.MediaList(media_list)
        p.set_media_list(vlc_media_list)
        p.play()

    def wrapper_func(*args, **kwargs):
        try:
            func(*args, **kwargs)
        except KeyboardInterrupt:
            interrupt_list = [
                'sound/keyboard_interrupt.mp3',
                'sound/1000iter.mp3',
                'sound/planc_train.mp3',
                'sound/add.mp3'
            ]
            print("Ctrl+Seit ich C gemacht habe, habe ich Muskeltraining hinzugefügt!!!")
            play_media_list(interrupt_list)
            time.sleep(5)
            for i in range(100):
                if i % 10 == 0 and i > 0:
                    play_media_list([ 'sound/iter_sound_2.mp3'])
                else:
                    play_media_list([ 'sound/iter_sound_1.mp3'])
                time.sleep(1)
            raise Exception(KeyboardInterrupt)
    return wrapper_func

Codebeispiel mit Rückruffunktion lernen

Für normales LightGBM-Lernen

Fügen Sie der zu trainierenden Funktion einen Strafmuskeldekorateur hinzu --Erstellen Sie eine Instanz der MuscleSound-Klasse und übergeben Sie sie an Rückrufe

nur. Da der Dekorateur nur Keyboard Interrupt abfängt, funktioniert jede Funktion, solange Sie LightGBM innerhalb der Funktion lernen. Mit dieser Funktion können Sie jederzeit problemlos eine Muskeltrainingsversion von LightGBM erstellen.

@penalty_muscle  #Fügen Sie der zu trainierenden Funktion einen Dekorateur hinzu
def train_muscle_lgb(train_df, target_col, use_cols):
    folds = KFold(n_splits=2, shuffle=True, random_state=2019)
    for i, (trn_, val_) in enumerate(folds.split(train_df, train_df[target_col])):
        print(f"============fold{i}============")
        trn_data = lgb.Dataset(
            train_df.loc[trn_, use_cols],
            label=train_df.loc[trn_, target_col]
        )
        val_data = lgb.Dataset(
            train_df.loc[val_, use_cols],
            label=train_df.loc[val_, target_col]
        )
        lgb_param = {
            "objective": "binary",
            "metric": "auc",
            "learning_rate": 0.01,
            "verbosity": -1,
        }
        #Instanziierung der MuscleSound-Klasse(Echte Rückruffunktion)
        callback_func = MuscleSound(train_config, train_menu="random")
        model = lgb.train(
            lgb_param,
            trn_data,
            num_boost_round=10000,
            valid_sets=[trn_data, val_data],
            verbose_eval=100,
            early_stopping_rounds=500,
            callbacks=[callback_func] #Rückruffunktion angeben
        )

Ich habe es tatsächlich versucht

Es ist aus verschiedenen Gründen ein animiertes GIF. Tatsächlich hören Sie die Stimme und den Ton in den Untertiteln. Spielen Sie sie also bitte in Ihrem Gehirn ab.

Herausforderungen, die ich fühlte, als ich es tatsächlich versuchte

Als Ergebnis des tatsächlichen Muskeltrainings gab es immer noch Probleme.

Ich werde überspringen

Egal wie oft Sie den Ton hören, wenn Sie ihn mehrmals machen, möchten Sie ihn überspringen. Es ist eine seltsame Sache.

――Wenn Sie es zu oft tun, wird es Ihnen langweilig. Stellen Sie daher die maximale Anzahl von Muskeltrainings pro Tag ein. ――Es wird festgestellt, dass Sie mit einem IoT-Gerät Muskeltraining durchführen. Ich werde das Ergebnis an Twitter usw. weitergeben.

Es scheint notwendig, Maßnahmen wie zu ergreifen. Letzteres scheint eine hohe Hürde zu haben, aber wenn Sie dies bisher tun, kann es jeder nutzen?

Die Lernzeit ist zu kurz, um ein Muskeltraining zu sein

Wenn es wenig Trainingsdaten gab, hatte ich keine Zeit zum Trainieren. Ich möchte Hunderttausende von Fällen. Und LightGBM ist immer noch schnell.

Gegenmaßnahmen sind schwierig, aber es bleibt keine andere Wahl, als die Lernrate zu senken oder Funktionen zu erstellen. (Huh? Sind Sie in der Lage, LightGBM für das Muskeltraining zu verwenden?)

Ist Muskeltraining überhaupt eine Strafe?

Ich mag Muskeltraining nicht so sehr, aber für Liebhaber des Muskeltrainings ist es möglicherweise keine Strafe, die Anzahl der Muskeltrainings zu erhöhen. .. ?? Einige Leute wagen es möglicherweise nicht, die Genauigkeit zu verbessern oder Strg + C zu drücken. .. ??

Muskeltraining ist tief, ob Sie es mögen oder es mit einer Strafe tun.

Zusammenfassung

Lassen Sie uns eine sinnvolle Zeit mit Muskeltraining verbringen, während wir das Modell lernen! !!

[^ 1]: Die weltweit bekannteste Datenanalyseplattform (https://www.kaggle.com/) [^ 2]: Klangquelle für synthetische Audiokommentare, die mit der MacOS-Standardsoftware erstellt werden kann [^ 3]: Soundeffektlabor (Soundquellenseite)