Pour vous qui regardez soudainement le journal tout en apprenant avec l'apprentissage automatique ~ Entraînement musculaire avec LightGBM ~

Que faites-vous lorsque vous apprenez un modèle avec l'apprentissage automatique? Regardez-vous la sortie du journal vers la console? "Oh, c'est plus bas que ce à quoi je m'attendais!" "Oh, la précision empire, fais de ton mieux !!" En réfléchissant, c'est étonnamment amusant à voir.

Mais même si vous applaudissez, le modèle ne fait pas de son mieux et il n'y a pas de développement dramatique, c'est donc une perte de temps pour le voir. J'ai remarqué quand j'y pensais.

** "Oh, pourquoi tu ne t'entraînes pas cette fois?" **

C'est pourquoi j'ai pensé à un environnement où je pourrais entraîner des muscles entre l'apprentissage automatique.


Voici Hattori de NTT Docomo. Ceci est l'article sur le 23ème jour de AdventCalender2019, NTT Docomo Service Innovation Department.

Qui est la cible de cet article

Pourquoi entraînez-vous vos muscles?

Afin d'améliorer la précision du modèle, il est nécessaire de répéter plusieurs fois l'hypothèse et la vérification.

Cependant, lorsque la précision ne s'améliore pas du tout, je pense que la motivation peut diminuer.

** Dans un tel cas, l'entraînement musculaire est efficace. ** **

Lorsque vous faites de l'entraînement musculaire, la sécrétion d'une hormone appelée «testostérone» est activée. La testostérone est une hormone qui contrôle la motivation du cerveau et en la sécrétant Même lorsque la précision ne s'améliore pas et que vous êtes déprimé

"OK! Encore une fois!"

On a pensé que la précision était améliorée.

筋トレ効果.png

De plus, je pense que l'entraînement musculaire est devenu populaire récemment dans le monde. Une animation de lycéennes entraînant des muscles est diffusée et une application qui entraîne les muscles sur la ligne Yamate apparaît. Après tout, la demande de musculation semble élevée.

Entraînement musculaire sur la ligne Yamate ... "Application Train-only" introduite par JR East. Mais ne vous souciez-vous pas des yeux autour de vous?

Direction

Je ne peux pas vraiment forcer l'entraînement musculaire, alors

  1. Créez une situation qui vous fait penser "Je dois entraîner mes muscles!" → ** Menu d'entraînement musculaire ・ Lecture des signaux de départ, du rythme, etc. **
  2. Augmentez la motivation pour l'entraînement musculaire → ** En fonction de la situation d'apprentissage (précision), le nombre d'entraînements musculaires peut être modifié pour donner un jeu au jeu.

Concentrez-vous sur de tels endroits.

De plus, LightGBM est le modèle cible à implémenter.

Qu'est-ce que LightGBM

LightGBM est une bibliothèque d'amplification de gradient développée par Microsoft. Il est souvent utilisé dans Kaggle [^ 1], et il est intéressant pour sa grande précision et sa vitesse d'apprentissage rapide. XGBoost est également célèbre, mais j'ai l'impression que LightGBM est utilisé ces jours-ci.

À propos de LightGBM, l'article suivant est facile à comprendre.

Document officiel LightGBM (anglais) 7 raisons de faire "First Light GBM" Une introduction complète à LightGBM - comment utiliser LightGBM, comment il fonctionne et en quoi il diffère de XGBoost

Fonction de rappel LightGBM

Cette fois, nous utiliserons principalement la fonction Callback de LightGBM pour l'implémenter. La fonction de rappel de LightGBM est exécutée au moment de l'apprentissage en passant la fonction de rappel définie par vous-même au moment de l'apprentissage.

Fondamentalement, dans de nombreuses bibliothèques d'apprentissage automatique (à l'exclusion du framework NN), l'apprentissage est effectué du côté de la bibliothèque, il est donc difficile pour l'utilisateur de personnaliser pendant l'apprentissage, mais la fonction de rappel permet diverses personnalisations. Devenir.

Par exemple

Il existe de nombreuses façons de l'utiliser, et il est utile pour les gros utilisateurs.

Fonctionnement de la fonction de rappel

La fonction de rappel est définie pour accepter les arguments de type nommés (env dans l'exemple de code ci-dessous). Puisqu'il contient une variable qui inclut l'état d'apprentissage, définissez le traitement qui l'utilise. Ce que vous pouvez recevoir

--Hyper paramètres --Nombre actuel d'itérations --Train / score valide dans l'itération actuelle --Modèle d'apprentissage (classe Booster)

Etc.

Lorsque la fonction de rappel définie est entraînée et exécutée comme lgb.train () et lgb.fit (), elle est passée au format liste avec les callbacks de nom d'argument. Voici un exemple de code simple.

import lightgbm as lgb

....

def callback_func(env):
    """
Fonction de rappel que vous définissez
Argument env(namedtuple)Vous pouvez obtenir le statut d'apprentissage de
    """
    if env.iteration + 1 % 100 == 0:
        print(f"maintenant,{env.iteration + 1}L'itération est terminée")


lgb.train(
    lgb_param,
    .....
    callbacks=[callback_func] #Passer la fonction définie dans les callbacks au format liste
)

Si vous regardez les liens ci-dessous, vous pouvez en savoir plus sur le contenu et les autres utilisations.

LightGBM/callback.py at master · Microsoft/LightGBM · GitHub Comment utiliser LightGBM (fonction de rappel) trop détaillé pour être transmis Sortie de l'historique d'apprentissage via un enregistreur à l'aide du rappel LightGBM

Fonction implémentée

Donner des conseils d'entraînement musculaire pendant l'apprentissage

--Au début de l'apprentissage: Guide de démarrage du menu d'entraînement musculaire --Exemple: "Commencer 30 fois les muscles abdominaux" -Faire un son de métronome (son de pion) à intervalles réguliers --Exemple: Pion toutes les 5 secondes --Fin des conseils en fin d'apprentissage / nombre maximum de fois

Idéal pour l'entraînement musculaire

--Un temps fixe (exemple: planche 30 secondes) --Le nombre de fois est fixe (exemple: muscle abdominal 30 fois)

Il existe deux types, et la synchronisation du son métronome dépend de quel type il s'agit.

Choses avec une heure fixe

Des sons sont produits à intervalles réguliers jusqu'à ce que l'heure cible soit atteinte. Cependant, au lieu de le régler à une heure normale, j'ai décidé de définir l'heure cible et l'intervalle auquel le son est émis par l'itération d'apprentissage automatique, car je voulais faire de mon mieux sur le même axe temporel que LightGBM pendant l'apprentissage.

Je pense que ** "300iteration plank" ** se lie mieux avec le modèle que "30 seconds plank".

Ceux avec un nombre fixe de fois

Si le nombre de fois est fixe, le rythme est important, il est donc difficile de faire correspondre le nombre d'itérations, alors réglez-le en secondes. Dans les premières itérations, le nombre d'itérations pour le nombre de secondes spécifié est calculé, et après cela, le son métronome est émis à chaque fois.

Le menu d'entraînement musculaire est spécifié ou aléatoire

Ce n'est pas bon de faire le même entraînement, j'ai donc rendu possible de le spécifier ou de le définir au hasard moi-même. La recommandation est de le définir au hasard et d'en profiter, y compris le type de formation que vous allez faire.

Si la précision est meilleure que la dernière fois, le son du métronome changera

Si vous découvrez que "Oh, la précision s'est améliorée!" Pendant l'entraînement musculaire douloureux, vous serez motivé pour l'entraînement musculaire. Cela vous empêche également de ne pas pouvoir vous concentrer sur l'entraînement musculaire en raison de problèmes de précision lors de l'apprentissage.

Pour implémenter cela, sortez le journal d'apprentissage dans un fichier journal à chaque fois Mis en œuvre pour lire et comparer le journal d'apprentissage précédent.

Si la précision est pire que la dernière fois, une pénalité (entraînement musculaire supplémentaire)

La précision du modèle affecte également l'entraînement musculaire en lui donnant une sensation de jeu. Cela peut également être géré en comparant avec le journal d'apprentissage précédent.

Pénalité (entraînement musculaire supplémentaire) même si l'apprentissage est arrêté au milieu

Arrêtez d'apprendre en cours de route ≒ la précision ne s'est pas améliorée Dans ce cas, il s'agit d'un entraînement musculaire de pénalité. Il est géré en interceptant l'exception d'interruption de clavier.

Je ne vous autorise pas à parcourir avec "Ctrl + C".

la mise en oeuvre

Environnement d'exécution / préparation

Installation

#Installation de VLC
brew cask install vlc
# Python-Installation de VLC
pip install python-vlc
#Installez LightGBM
pip install lightgbm

Préparation de la source sonore

Il est nécessaire de préparer la source sonore.

Pour la voix, créez avec la fonction de lecture vocale standard MacOS [^ 2], D'autres effets sonores sont disponibles sur le site de source sonore gratuit [^ 3].

Vous serez peut-être plus motivé en préparant la voix que vous aimez.

Code source

Configuration prédéfinie

Définissez le menu d'entraînement musculaire, le type, le nombre d'exécutions, le chemin de la source sonore, etc. Ce n'est pas indispensable, alors je vais le plier.

<détails>

Code de configuration du menu d'entraînement musculaire </ summary>

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 Itération
            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", #Nom de l'entraînement musculaire (ex:Bras enclin, muscles abdominaux,. .. .. )
            f"sound/{config['total_times']}times.mp3",  #N Itération
            "sound/start.mp3" #début
        ]
    return sound_dict

Cours de musculation avec fonction de rappel

C'est un peu long, mais c'est la partie principale, donc je vais le mettre tel quel.

class MuscleSound():
    """
Rappel pour l'entraînement musculaire avec LightGBM
    """
    def __init__(self, train_config, train_menu="planc"):
        if train_menu == "random":
            #En cas d'aléatoire, définir aléatoirement depuis le menu
            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):
        """
Médias spécifiés_Lisez les fichiers audio dans la liste dans l'ordre
        """
        p = vlc.MediaListPlayer()
        vlc_media_list = vlc.MediaList(media_list)
        p.set_media_list(vlc_media_list)
        p.play()

    def _setup_prev_log(self):
        """
Le journal d'apprentissage précédent est curr.C'est un journal
        prev.renommer en journal
        """
        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"):
        """
Lire le journal du dernier apprentissage
        """
        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):
        """
Comparez les scores et enregistrez les journaux
        """
        n_iter = env.iteration + 1
        is_better_score = False
        #Extraire le score de validation
        # valid_Utiliser le score du dernier ensemble de données dans les ensembles
        curr_score = env.evaluation_result_list[-1][2]
        #Si le nombre est élevé, meilleur est le score
        is_upper_metric = env.evaluation_result_list[-1][3]
        #Comparer si le journal précédent a le même score d'itération
        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
        #Enregistrer le journal
        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):
        """
Reproduction sonore au début de l'apprentissage
        """
        self.play_media_list(self.sound_dict["train_start"])
        #Un peu de sommeil pour que l'apprentissage (entraînement musculaire) ne commence pas avant la lecture
        time.sleep(5)

    def duration_sound(self, env):
        """
Pour l'entraînement musculaire avec un temps fixe
Fait un son à un certain nombre d'itérations
        """
        if (env.iteration + 1) > self.config["total_iteration"]:
            #Ne rien faire si le nombre maximum d'itératives pour entraîner les muscles est dépassé
            return
        elif env.iteration + 1 == self.config["total_iteration"]:
            #Signalé car le nombre d'extrémités a été atteint
            self.media_play(self.sound_dict["train_finish"])
        elif (env.iteration + 1) % 100 == 0:
            #Son toutes les 100 fois
            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:
            #Son toutes les 10 fois
            self.media_play(self.sound_dict["iteration_10"])

    def iter_sound(self, env):
        """
Lecture du son en fonction du temps (pour l'entraînement musculaire avec un nombre de fois fixe)
Faire un son toutes les secondes
        """
        if self.n_iter_1time is None:
            return
        if  (env.iteration + 1) > self.config["total_times"]*self.n_iter_1time:
            #Ne rien faire si le nombre maximum d'entraînement musculaire est dépassé
            return
        if  (env.iteration + 1) == self.config["total_times"]*self.n_iter_1time:
            #Lorsque le nombre maximum de fois est atteint, la fin sera annoncée
            self.media_play(self.sound_dict["train_finish"])
        if  (env.iteration + 1)%self.n_iter_1time != 0:
            #S'il n'est pas divisible par le nombre d'itérations, ne rien faire
            return
        if ((env.iteration + 1)//self.n_iter_1time) % 10 == 0:
            #Son toutes les 100 fois
            self.media_play(self.sound_dict["iteration_100"])
        else:
            #Son toutes les 10 fois
            self.media_play(self.sound_dict["iteration_10"])

    def __call__(self, env):
        if env.iteration == 0:
            #Au début de l'apprentissage
            self.media_play(self.sound_dict["train_start"])
        if self.config["train_type"] == "times":
            #Définissez le nombre approprié d'itérations par heure
            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("Nombre d'itérations par temps", self.n_iter_1time)
        if not env.evaluation_result_list:
            return
        #Reproduction sonore du métronome selon le type d'entraînement musculaire
        if self.config["train_type"] == "iter":
            self.iter_sound(env)
        elif self.config["train_type"] == "duration":
            self.duration_sound(env)

Traitement des pénalités au moment de l'interruption

Il s'agit d'un processus pour imposer une pénalité si vous arrêtez d'apprendre au milieu.

Ce n'est pas la fonction de rappel, mais l'exception de KeyboardInterrupt est interceptée et traitée.

En outre, il peut être utilisé comme décorateur afin qu'il puisse être facilement écrit pendant l'apprentissage.

def penalty_muscle(func):
    def play_media_list(media_list):
        """
Médias spécifiés_Lisez les fichiers audio dans la liste dans l'ordre
        """
        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+Depuis que j'ai fait du C, j'ai ajouté un entraînement musculaire!!!")
            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

Exemple de code d'apprentissage utilisant la fonction de rappel

Pour l'apprentissage normal de LightGBM

  • Ajoutez un décorateur penalty_muscle à la fonction à entraîner --Créez une instance de la classe MuscleSound et transmettez-la aux callbacks

seulement. Étant donné que le décorateur ne détecte que l'interruption du clavier, toute fonction fonctionnera tant que vous apprenez LightGBM à l'intérieur de la fonction. Avec cela, vous pouvez facilement créer une version d'entraînement musculaire de LightGBM à tout moment.

@penalty_muscle  #Ajouter un décorateur à la fonction à former
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,
        }
        #Instanciation de la classe MuscleSound(Fonction de rappel réel)
        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] #Spécifier la fonction de rappel
        )

Je l'ai vraiment essayé

C'est un GIF animé pour diverses raisons. En fait, vous entendrez la voix et le son écrits dans les sous-titres, alors jouez-les dans votre cerveau.

training_anime.gif

Les défis que j'ai ressentis quand je l'ai essayé

En raison de l'entraînement musculaire moi-même, il y avait encore des problèmes.

Je vais sauter

Peu importe combien vous entendez le son, si vous le faites plusieurs fois, vous voudrez l'ignorer. C'est une chose étrange.

――Si vous le faites trop de fois, vous vous ennuierez, alors définissez le nombre maximum d'entraînements musculaires par jour. ――Il détecte que vous effectuez un entraînement musculaire avec un appareil IoT. Je donnerai le résultat à Twitter, etc.

Il semble que des mesures telles que celles-ci soient nécessaires. Ce dernier semble avoir un obstacle élevé, mais si vous le faites jusqu'à présent, tout le monde peut l'utiliser?

Le temps d'apprentissage est trop court pour être un entraînement musculaire

Quand il y avait peu de données d'entraînement, je n'avais pas le temps de m'entraîner. Je veux des centaines de milliers de cas. Et LightGBM est toujours rapide.

Les contre-mesures sont difficiles, mais il n'y a pas d'autre choix que de réduire le taux d'apprentissage ou de créer des fonctionnalités. (Hein? Êtes-vous en situation d'utiliser LightGBM pour l'entraînement musculaire?)

L'entraînement musculaire est-il une pénalité en premier lieu?

Je n'aime pas trop l'entraînement musculaire, mais pour les amateurs d'entraînement musculaire, augmenter le nombre d'entraînement musculaire n'est peut-être pas une pénalité. .. ?? Certaines personnes peuvent n'oser pas améliorer la précision ou appuyer sur Ctrl + C. .. ??

L'entraînement musculaire est profond, que vous l'aimiez ou que vous le fassiez avec une pénalité.

Résumé

Passons un moment significatif à faire de l'entraînement musculaire tout en apprenant le modèle! !!

[^ 1]: la plate-forme d'analyse de données la plus célèbre au monde (https://www.kaggle.com/) [^ 2]: Source sonore de narration audio synthétique qui peut être créée avec le logiciel standard macOS [^ 3]: Sound effect lab (site de la source sonore)

Recommended Posts

Pour vous qui regardez soudainement le journal tout en apprenant avec l'apprentissage automatique ~ Entraînement musculaire avec LightGBM ~
La première étape de l'apprentissage automatique ~ Pour ceux qui veulent essayer l'implémentation avec python ~
Pour ceux qui souhaitent démarrer l'apprentissage automatique avec TensorFlow2
100 coups de traitement du langage pour ceux qui ne comprennent pas la signification des phrases à problèmes
Alignez le nombre d'échantillons entre les classes de données pour l'apprentissage automatique avec Python
Prédire le sexe des utilisateurs de Twitter grâce à l'apprentissage automatique
La première étape pour ceux qui sont amateurs de statistiques mais qui souhaitent implémenter des modèles d'apprentissage automatique en Python
Résumé du flux de base de l'apprentissage automatique avec Python
Bilan du premier défi du machine learning avec Keras
Une histoire coincée avec l'installation de la bibliothèque de machine learning JAX
[Apprentissage automatique] Vérifiez les performances du classificateur à l'aide de données de caractères manuscrites
Comment utiliser l'apprentissage automatique pour le travail? 01_ Comprendre l'objectif de l'apprentissage automatique
Ingénierie des fonctionnalités pour l'apprentissage automatique à partir de la partie 1 Google Colaboratory - Validation et discrimination des données de comptage
[Livre d'images sur l'apprentissage automatique] Mémo lorsque l'exercice Python à la fin du livre a été effectué lors de la vérification des données
Résumé des sites et des procédures d'apprentissage qui seront utiles pour ceux qui essaient de créer des jeux avec pygame pour la première fois
Signifie mémo lorsque vous essayez de faire de l'apprentissage automatique avec 50 images
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer jusqu'à la fin du chapitre 2
J'ai mesuré la vitesse de la notation d'inclusion de liste, pendant et pendant avec python2.7.
Mots qui peuvent prêter à confusion à première vue ~ Principalement dans le domaine du Web / apprentissage automatique ~
Amplifiez les images pour l'apprentissage automatique avec Python
[Shakyo] Rencontre avec Python pour l'apprentissage automatique
La troisième nuit de la boucle avec pour
La deuxième nuit de la boucle avec pour
Ingénierie des fonctionnalités pour l'apprentissage automatique à partir du 4e Google Colaboratory - Fonctionnalités interactives