knockknock
1.0.0
Una pequeña biblioteca para recibir una notificación cuando su entrenamiento está completo o cuando se bloquea durante el proceso con dos líneas de código adicionales.
Al entrenar modelos de aprendizaje profundo, es común usar la parada temprana. Además de una estimación aproximada, es difícil predecir cuándo terminará el entrenamiento. Por lo tanto, puede ser interesante establecer notificaciones automáticas para su entrenamiento. También es interesante ser notificado cuando su entrenamiento se bloquea en el medio del proceso por razones inesperadas.
Instalar con pip o equivalente.
pip install knockknockEste código solo se ha probado con Python> = 3.6.
La biblioteca está diseñada para usarse de manera perfecta, con una modificación mínima del código: solo necesita agregar un decorador en la parte superior de su llamada de función principal. El valor de retorno (si hay uno) también se informa en la notificación.
Actualmente hay doce formas de configurar notificaciones:
| Plataforma | Contribuyentes externos |
|---|---|
| correo electrónico | - |
| Flojo | - |
| Telegrama | - |
| Equipos de Microsoft | @Noklam |
| Mensaje de texto | @abhishekkrthakur |
| Discordia | @watkinsm |
| De oficina | @atakanyenel @eyalmazuz |
| Matriz | @jcklie |
| Chime de Amazon | @prabhakar267 |
| Dingtalk | @wuutiing |
| Rocketchat | @radao |
| Trabajo de WeChat | @JCYK |
El servicio se basa en Yagmail un cliente Gmail/SMTP. Necesitará una dirección de correo electrónico de Gmail para usarla (puede configurar una aquí, es gratis). Recomiendo crear uno nuevo (en lugar de su habitual) ya que tendrá que modificar la configuración de seguridad de la cuenta para permitir que la biblioteca de Python acceda a ella activando aplicaciones menos seguras.
from knockknock import email_sender
@ email_sender ( recipient_emails = [ "<[email protected]>" , "<[email protected]>" ], sender_email = "<grandma'[email protected]>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock email
--recipient-emails < [email protected] > , < [email protected] >
--sender-email < grandma ' [email protected]>
sleep 10 Si no se especifica sender_email , entonces el primer correo electrónico en recipient_emails se utilizará como correo electrónico del remitente.
Tenga en cuenta que lanzar esto le solicitará la contraseña de correo electrónico del remitente. Se almacenará de forma segura en el servicio de llavero del sistema a través de la biblioteca de Python keyring .
Del mismo modo, también puede usar Slack para recibir notificaciones. Tendrá que obtener su URL de webhook de Slack Room y, opcionalmente, su ID de usuario (si desea etiquetarse a usted o a alguien más).
from knockknock import slack_sender
webhook_url = "<webhook_url_to_your_slack_room>"
@ slack_sender ( webhook_url = webhook_url , channel = "<your_favorite_slack_channel>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value También puede especificar un argumento opcional para etiquetar a personas específicas: user_mentions=[<your_slack_id>, <grandma's_slack_id>] .
knockknock slack
--webhook-url < webhook_url_to_your_slack_room >
--channel < your_favorite_slack_channel >
sleep 10 También puede especificar un argumento opcional para etiquetar personas específicas: --user-mentions <your_slack_id>,<grandma's_slack_id> .
También puede usar Telegram Messenger para recibir notificaciones. Primero tendrá que crear su propio bot de notificación siguiendo los tres pasos proporcionados por Telegram aquí y guardar su TOKEN de acceso API.
Los bots de telegrama son tímidos y no pueden enviar el primer mensaje, por lo que tendrá que hacer el primer paso. Al enviar el primer mensaje, podrá obtener el chat_id requerido (identificación de su sala de mensajería) visitando https://api.telegram.org/bot<YourBOTToken>/getUpdates y obtenga el int debajo del message['chat']['id'] .
from knockknock import telegram_sender
CHAT_ID : int = < your_messaging_room_id >
@ telegram_sender ( token = "<your_api_token>" , chat_id = CHAT_ID )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock telegram
--token < your_api_token >
--chat-id < your_messaging_room_id >
sleep 10Gracias a @noklam, también puedes usar equipos de Microsoft para recibir notificaciones. Tendrás que obtener la URL de tu equipo de tu canal de equipo.
from knockknock import teams_sender
@ teams_sender ( token = "<webhook_url_to_your_teams_channel>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10 )
return { 'loss' : 0.9 } # Optional return value knockknock teams
--webhook-url < webhook_url_to_your_teams_channel >
sleep 10 También puede especificar un argumento opcional para etiquetar a personas específicas: user_mentions=[<your_teams_id>, <grandma's_teams_id>] .
Gracias a @abhishekkrthakur, puede usar Twilio para enviar notificaciones de mensajes de texto. Tendrá que configurar una cuenta de Twilio aquí, que se paga el servicio con precios competitivos: por ejemplo, en los EE. UU., Obtener un nuevo número y enviar un mensaje de texto a través de este servicio, cuesta $ 1.00 y $ 0.0075. Deberá obtener (a) un número de teléfono, (b) su cuenta SID y (c) su token de autentificación. Algunos detalles aquí.
from knockknock import sms_sender
ACCOUNT_SID : str = "<your_account_sid>"
AUTH_TOKEN : str = "<your_auth_token>"
@ sms_sender ( account_sid = ACCOUNT_SID , auth_token = AUTH_TOKEN , recipient_number = "<recipient's_number>" , sender_number = "<sender's_number>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10 )
return { 'loss' : 0.9 } # Optional return value knockknock sms
--account-sid < your_account_sid >
--auth-token < your_account_auth_token >
--recipient-number < recipient_number >
--sender-number < sender_number >
sleep 10Gracias a @watkinsm, también puedes usar Discord para recibir notificaciones. Solo tendrá que obtener la URL webhook de su canal de discordia.
from knockknock import discord_sender
webhook_url = "<webhook_url_to_your_discord_channel>"
@ discord_sender ( webhook_url = webhook_url )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock discord
--webhook-url < webhook_url_to_your_discord_channel >
sleep 10También puede recibir una notificación de una notificación de escritorio. Actualmente solo está disponible para MacOS y Linux y Windows 10. Para Linux utiliza el comando NOFITY-SEND que usa libnotify, para usar libnotify, debe instalar un servidor de notificaciones. Canela, profundo, iluminación, gnomo, flashback gnome y plasma KDE usan sus propias implementaciones para mostrar notificaciones. En otros entornos de escritorio, el servidor de notificaciones debe iniciarse utilizando la opción "AutoStart" de WM/DE.
from knockknock import desktop_sender
@ desktop_sender ( title = "Knockknock Desktop Notifier" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { "loss" : 0.9 }knockknock desktop
--title ' Knockknock Desktop Notifier '
sleep 2 Gracias a @jcklie, puedes enviar notificaciones a través de Matrix. El HomeRerver es el servidor en el que se registra su usuario que enviará mensajes. No olvide el esquema para la URL ( http o https ). Tendrá que obtener el token de acceso para un bot o su propio usuario. La forma más fácil de obtenerlo es mirar a los disturbios en la configuración antidisturbios, Help & About , en la parte inferior, es: Access Token:<click to reveal> . También debe especificar un alias de habitación a los que se envían los mensajes. Para obtener el alias en Riot, cree una habitación que desee usar, luego abra la configuración de la habitación debajo de Room Addresses y agregue un alias.
from knockknock import matrix_sender
HOMESERVER = "<url_to_your_home_server>" # e.g. https://matrix.org
TOKEN = "<your_auth_token>" # e.g. WiTyGizlr8ntvBXdFfZLctyY
ROOM = "<room_alias" # e.g. #knockknock:matrix.org
@ matrix_sender ( homeserver = HOMESERVER , token = TOKEN , room = ROOM )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock matrix
--homeserver < homeserver >
--token < token >
--room < room >
sleep 10Gracias a @Prabhakar267, también puedes usar Amazon Chime para recibir notificaciones. Tendrás que obtener tu URL de webhook en la sala de chime.
from knockknock import chime_sender
@ chime_sender ( webhook_url = "<webhook_url_to_your_chime_room>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10 )
return { 'loss' : 0.9 } # Optional return value knockknock chime
--webhook-url < webhook_url_to_your_chime_room >
sleep 10 También puede especificar un argumento opcional para etiquetar a las personas específicas: user_mentions=[<your_alias>, <grandma's_alias>] .
Dingtalk ahora es compatible gracias a @wuutiing. Dada la URL del webhook de la sala de chat de Dingtalk y las palabras secretas/clave (al menos una de ellas se establece al crear un robot en la sala de chat), sus notificaciones se enviarán para llegar a cualquiera en esa sala de chat.
from knockknock import dingtalk_sender
webhook_url = "<webhook_url_to_your_dingtalk_chatroom_robot>"
@ dingtalk_sender ( webhook_url = webhook_url , secret = "<your_robot_secret_if_set>" , keywords = [ "<list_of_keywords_if_set>" ])
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock dingtalk
--webhook-url < webhook_url_to_your_dingtalk_chatroom_robot >
--secret < your_robot_secret_if_set >
sleep 10 También puede especificar un argumento opcional en personas específicas: user_mentions=["<list_of_phonenumbers_who_you_want_to_tag>"] .
Puedes usar Rocketchat para recibir notificaciones. Necesitará lo siguiente antes de poder publicar notificaciones:
from knockknock import rocketchat_sender
@ rocketchat_sender (
rocketchat_server_url = "<url_to_your_rocketchat_server>" ,
rocketchat_user_id = "<your_rocketchat_user_id>" ,
rocketchat_auth_token = "<your_rocketchat_auth_token>" ,
channel = "<channel_name>" )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return valueTambién puede especificar dos argumentos opcionales:
user_mentions=[<your_user_name>, <grandma's_user_name>]alias="My Alias" knockknock rocketchat
--rocketchat-server-url < url_to_your_rocketchat_server >
--rocketchat-user-id < your_rocketchat_user_id >
--rocketchat-auth-token < your_rocketchat_auth_token >
--channel < channel_name >
sleep 10WeChat Work ahora es compatible gracias a @JCyk. Dada la URL del webhook de la sala de chat de Wechat Work, sus notificaciones se enviarán para llegar a cualquiera en esa sala de chat.
from knockknock import wechat_sender
webhook_url = "<webhook_url_to_your_wechat_work_chatroom_robot>"
@ wechat_sender ( webhook_url = webhook_url )
def train_your_nicest_model ( your_nicest_parameters ):
import time
time . sleep ( 10000 )
return { 'loss' : 0.9 } # Optional return value knockknock wechat
--webhook-url < webhook_url_to_your_wechat_work_chatroom_robot >
sleep 10 También puede especificar un argumento opcional para etiquetar personas específicas: user-mentions=["<list_of_userids_you_want_to_tag>"] y/o user-mentions-mobile=["<list_of_phonenumbers_you_want_to_tag>"] .
Cuando se usa capacitación distribuida, una GPU está vinculada a su proceso utilizando la variable de rango local. Dado que Knockknock funciona a nivel de proceso, si está utilizando 8 GPU, recibiría 8 notificaciones al principio y 8 notificaciones al final ... para eludir eso, excepto los errores, solo el proceso maestro puede enviar notificaciones para que solo reciba una notificación al principio y una notificación al final.
Nota: En Pytorch, el lanzamiento de torch.distributed.launch establece una variable de entorno de rango para cada proceso (ver aquí). Esto se usa para detectar el proceso maestro, y por ahora, la única forma simple que se me ocurrió. Desafortunadamente, esto no pretende ser general para todas las plataformas, pero felizmente discutiría formas más inteligentes/mejores de manejar la capacitación distribuida en un tema/PR.
