[PYTHON] 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
- J'aime l'entraînement musculaire
- Les personnes dans le domaine de l'apprentissage automatique qui manquent d'exercice
- Les personnes qui utilisent souvent LightGBM comme kaggler
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.
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.
Direction
Je ne peux pas vraiment forcer l'entraînement musculaire, alors
- 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. **
- 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.
- Le modèle "deep learning" a tendance à prendre beaucoup de temps à apprendre, et il est difficile de continuer à s'entraîner même si vous l'essayez, alors j'ai abandonné ... orz
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
- Envoyez la progression de l'apprentissage à l'enregistreur (et envoyez-la à Slack / LINE)
- Mettre en œuvre votre propre arrêt anticipé
- Changement dynamique des hyper paramètres
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
- Exemple: "Merci pour votre travail acharné." "J'ai fait de mon mieux."
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
- MacOS 10.14.5
- Python 3.6.8
- lightgbm 2.3.0
- VLC media player 3.0.8
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> C'est un peu long, mais c'est la partie principale, donc je vais le mettre tel quel. 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. Pour l'apprentissage normal de LightGBM 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. 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. En raison de l'entraînement musculaire moi-même, il y avait encore des problèmes. 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? 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?) 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é. 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
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
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
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
@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é
Les défis que j'ai ressentis quand je l'ai essayé
Je vais sauter
Le temps d'apprentissage est trop court pour être un entraînement musculaire
L'entraînement musculaire est-il une pénalité en premier lieu?
Résumé