knockknock
1.0.0
Uma pequena biblioteca para receber uma notificação quando seu treinamento estiver concluído ou quando trava durante o processo com duas linhas de código adicionais.
Ao treinar modelos de aprendizado profundo, é comum usar a parada precoce. Além de uma estimativa aproximada, é difícil prever quando o treinamento terminará. Assim, pode ser interessante configurar notificações automáticas para o seu treinamento. Também é interessante ser notificado quando seu treinamento falha no meio do processo por razões inesperadas.
Instale com pip ou equivalente.
pip install knockknockEste código foi testado apenas com Python> = 3.6.
A biblioteca foi projetada para ser usada de maneira perfeita, com modificação mínima de código: você só precisa adicionar um decorador no topo sua chamada de função principal. O valor de retorno (se houver um) também é relatado na notificação.
Atualmente, existem doze maneiras de configurar notificações:
| Plataforma | Colaboradores externos |
|---|---|
| - | |
| Folga | - |
| Telegrama | - |
| Equipes da Microsoft | @Noklam |
| Mensagem de texto | @abhishekkrthakur |
| Discórdia | @watkinsm |
| Desktop | @atakanyenel @eyalmazuz |
| Matriz | @jcklie |
| Amazon Chime | @Prabhakar267 |
| DingTalk | @wuutiing |
| Rocketchat | @Radao |
| Trabalho WeChat | @jcyk |
O serviço depende do Yagmail um cliente Gmail/SMTP. Você precisará de um endereço de e -mail do Gmail para usá -lo (você pode configurar um aqui, é gratuito). Eu recomendo a criação de um novo (em vez do habitual), pois você precisará modificar as configurações de segurança da conta para permitir que a biblioteca Python o acesse, ativando aplicativos menos seguros.
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 Se sender_email não for especificado, o primeiro email no recipient_emails será usado como email do remetente.
Observe que o lançamento disso solicitará a senha de email do remetente. Ele será armazenado com segurança no serviço de chaveiro do sistema através da biblioteca Python keyring .
Da mesma forma, você também pode usar o Slack para obter notificações. Você terá que obter o URL da Webhook da Slack Room e, opcionalmente, o seu ID de usuário (se você quiser marcar a si mesmo ou a outra pessoa).
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 Você também pode especificar um argumento opcional para marcar pessoas 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 Você também pode especificar um argumento opcional para marcar pessoas específicas: --user-mentions <your_slack_id>,<grandma's_slack_id> .
Você também pode usar o Telegram Messenger para obter notificações. Você primeiro precisará criar seu próprio bot de notificação seguindo as três etapas fornecidas pelo Telegram aqui e salvar seu TOKEN de acesso à API.
Os bots do telegrama são tímidos e não podem enviar a primeira mensagem, então você terá que dar a primeira etapa. Ao enviar a primeira mensagem, você poderá obter o chat_id necessário (identificação da sua sala de mensagens) visitando https://api.telegram.org/bot<YourBOTToken>/getUpdates e obtenha o int sob a 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 10Graças a @Noklam, você também pode usar as equipes da Microsoft para receber notificações. Você terá que obter o URL da Webhook do seu canal de equipe.
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 Você também pode especificar um argumento opcional para marcar pessoas específicas: user_mentions=[<your_teams_id>, <grandma's_teams_id>] .
Graças a @abhishekkrthakur, você pode usar o Twilio para enviar notificações de mensagens de texto. Você precisará configurar uma conta do Twilio aqui, que recebe serviço pago com preços competitivos: por exemplo, nos EUA, obtendo um novo número e enviando uma mensagem de texto por meio desse serviço, respectivamente, custa US $ 1,00 e US $ 0,0075. Você precisará obter (a) um número de telefone, (b) sua conta SID e (c) seu token de autenticação. Alguns detalhes aqui.
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 10Graças ao @watkinsm, você também pode usar o Discord para receber notificações. Você só terá que obter o URL da Webhook do seu canal Discord.
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 10Você também pode ser notificado de uma notificação de desktop. Atualmente, ele está disponível apenas para MacOS e Linux e Windows 10. Para o Linux, ele usa o comando Nofity-Send que usa libnotify, a fim de usar o libnotificar, você deve instalar um servidor de notificação. Canela, Deepin, Iluminismo, Gnome, Flashback Gnome e Plasma KDE usam suas próprias implementações para exibir notificações. Em outros ambientes de desktop, o servidor de notificação precisa ser iniciado usando a opção "AutoStart" do 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 Graças a @jcklie, você pode enviar notificações via Matrix. O HomeServer é o servidor no qual seu usuário enviará mensagens é registrado. Não se esqueça do esquema do URL ( http ou https ). Você terá que obter o token de acesso para um bot ou seu próprio usuário. A maneira mais fácil de obtê -lo é olhar para o revolto nas configurações de tumultos, Help & About , no fundo é: Access Token:<click to reveal> . Você também precisa especificar um alias de sala para quais mensagens são enviadas. Para obter o pseudônimo no tumulto, crie uma sala que você deseja usar, abra as configurações da sala sob Room Addresses e adicione um pseudônimo.
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 10Graças a @Prabhakar267, você também pode usar o Amazon Chime para receber notificações. Você terá que obter o URL da Webhook da sala de carroceria.
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 Você também pode especificar um argumento opcional para marcar pessoas específicas: user_mentions=[<your_alias>, <grandma's_alias>] .
O DingTalk agora é suportado graças a @wuutiing. Dadas a URL de webhook e as palavras -chave/chaves do robô do DingTalk Robot (pelo menos uma delas está definida ao criar um robô de sala de chat), suas notificações serão enviadas para alcançar qualquer uma nessa sala de bate -papo.
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 Você também pode especificar um argumento opcional para pessoas específicas: user_mentions=["<list_of_phonenumbers_who_you_want_to_tag>"] .
Você pode usar o Rocketchat para receber notificações. Você precisará do seguinte antes de postar notificações:
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 valueVocê também pode especificar dois argumentos opcionais:
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 10O trabalho do WeChat agora é suportado graças a @JCyk. Dado o URL da Webhook do WeChat Work Room Robot, suas notificações serão enviadas para chegar a qualquer pessoa naquela sala de bate -papo.
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 Você também pode especificar um argumento opcional para marcar pessoas específicas: user-mentions=["<list_of_userids_you_want_to_tag>"] e/ou user-mentions-mobile=["<list_of_phonenumbers_you_want_to_tag>"] .
Ao usar o treinamento distribuído, uma GPU está vinculada ao seu processo usando a variável de classificação local. Como Knockknock funciona no nível do processo, se você estiver usando 8 GPUs, receberá 8 notificações no início e 8 notificações no final ... para contornar isso, exceto por erros, apenas o processo mestre pode enviar notificações para que você receba apenas uma notificação no início e uma notificação no final.
NOTA: Em Pytorch, o lançamento do torch.distributed.launch configura uma variável de ambiente de classificação para cada processo (veja aqui). Isso é usado para detectar o processo mestre e, por enquanto, a única maneira simples de criar. Infelizmente, isso não se destina a ser geral para todas as plataformas, mas eu discutia com prazer maneiras mais inteligentes/melhores de lidar com o treinamento distribuído em um problema/relações públicas.
