ignite
New metrics and new features and bug fixes
| ・ ・ |
Ignite es una biblioteca de alto nivel que ayuda a entrenar y evaluar redes neuronales en PyTorch de forma flexible y transparente.
Haga clic en la imagen para ver el código completo
Menos código que PyTorch puro y al mismo tiempo garantiza el máximo control y simplicidad
Enfoque de biblioteca y sin inversión de control del programa: use ignite donde y cuando lo necesite
API extensible para métricas, administradores de experimentos y otros componentes
Ignite es una biblioteca que proporciona tres características de alto nivel:
No más codificación de bucles for/while en épocas e iteraciones. Los usuarios crean instancias de motores y los ejecutan.
from ignite . engine import Engine , Events , create_supervised_evaluator
from ignite . metrics import Accuracy
# Setup training engine:
def train_step ( engine , batch ):
# Users can do whatever they need on a single iteration
# Eg. forward/backward pass for any number of models, optimizers, etc
# ...
trainer = Engine ( train_step )
# Setup single model evaluation engine
evaluator = create_supervised_evaluator ( model , metrics = { "accuracy" : Accuracy ()})
def validation ():
state = evaluator . run ( validation_data_loader )
# print computed metrics
print ( trainer . state . epoch , state . metrics )
# Run model's validation at the end of each epoch
trainer . add_event_handler ( Events . EPOCH_COMPLETED , validation )
# Start the training
trainer . run ( training_data_loader , max_epochs = 100 )Lo bueno de los controladores es que ofrecen una flexibilidad incomparable (en comparación, por ejemplo, con las devoluciones de llamada). Los controladores pueden ser cualquier función: por ejemplo, lambda, función simple, método de clase, etc. Por lo tanto, no necesitamos heredar de una interfaz y anular sus métodos abstractos, lo que podría aumentar innecesariamente su código y su complejidad.
trainer . add_event_handler ( Events . STARTED , lambda _ : print ( "Start training" ))
# attach handler with args, kwargs
mydata = [ 1 , 2 , 3 , 4 ]
logger = ...
def on_training_ended ( data ):
print ( f"Training is ended. mydata= { data } " )
# User can use variables from another scope
logger . info ( "Training is ended" )
trainer . add_event_handler ( Events . COMPLETED , on_training_ended , mydata )
# call any number of functions on a single event
trainer . add_event_handler ( Events . COMPLETED , lambda engine : print ( engine . state . times ))
@ trainer . on ( Events . ITERATION_COMPLETED )
def log_something ( engine ):
print ( engine . state . output ) # run the validation every 5 epochs
@ trainer . on ( Events . EPOCH_COMPLETED ( every = 5 ))
def run_validation ():
# run validation
# change some training variable once on 20th epoch
@ trainer . on ( Events . EPOCH_STARTED ( once = 20 ))
def change_training_variable ():
# ...
# Trigger handler with customly defined frequency
@ trainer . on ( Events . ITERATION_COMPLETED ( event_filter = first_x_iters ))
def log_gradients ():
# ...Los eventos se pueden acumular para permitir múltiples llamadas:
@ trainer . on ( Events . COMPLETED | Events . EPOCH_COMPLETED ( every = 10 ))
def run_validation ():
# ...Eventos personalizados relacionados con llamadas a pasos hacia atrás y del optimizador:
from ignite . engine import EventEnum
class BackpropEvents ( EventEnum ):
BACKWARD_STARTED = 'backward_started'
BACKWARD_COMPLETED = 'backward_completed'
OPTIM_STEP_COMPLETED = 'optim_step_completed'
def update ( engine , batch ):
# ...
loss = criterion ( y_pred , y )
engine . fire_event ( BackpropEvents . BACKWARD_STARTED )
loss . backward ()
engine . fire_event ( BackpropEvents . BACKWARD_COMPLETED )
optimizer . step ()
engine . fire_event ( BackpropEvents . OPTIM_STEP_COMPLETED )
# ...
trainer = Engine ( update )
trainer . register_events ( * BackpropEvents )
@ trainer . on ( BackpropEvents . BACKWARD_STARTED )
def function_before_backprop ( engine ):
# ...Métricas para diversas tareas: precisión, recuperación, exactitud, matriz de confusión, IoU, etc., ~20 métricas de regresión.
Los usuarios también pueden componer sus métricas con facilidad a partir de las existentes utilizando operaciones aritméticas o métodos de antorcha.
precision = Precision ( average = False )
recall = Recall ( average = False )
F1_per_class = ( precision * recall * 2 / ( precision + recall ))
F1_mean = F1_per_class . mean () # torch mean method
F1_mean . attach ( engine , "F1" )De pipa:
pip install pytorch-igniteDe conda:
conda install ignite -c pytorchDe fuente:
pip install git+https://github.com/pytorch/igniteDe pipa:
pip install --pre pytorch-igniteDe conda (esto sugiere instalar la versión nocturna de pytorch en lugar de la versión estable como dependencia):
conda install ignite -c pytorch-nightlyExtraiga una imagen de Docker prediseñada de nuestro Docker Hub y ejecútela con Docker v19.03+.
docker run --gpus all -it -v $PWD :/workspace/project --network=host --shm-size 16G pytorchignite/base:latest /bin/bashBase
pytorchignite/base:latestpytorchignite/apex:latestpytorchignite/hvd-base:latestpytorchignite/hvd-apex:latestpytorchignite/msdp-apex:latestVisión:
pytorchignite/vision:latestpytorchignite/hvd-vision:latestpytorchignite/apex-vision:latestpytorchignite/hvd-apex-vision:latestpytorchignite/msdp-apex-vision:latestPNL:
pytorchignite/nlp:latestpytorchignite/hvd-nlp:latestpytorchignite/apex-nlp:latestpytorchignite/hvd-apex-nlp:latestpytorchignite/msdp-apex-nlp:latestPara más detalles, consulte aquí.
Algunos consejos para empezar:
Inspirándonos en torchvision/references, proporcionamos varias líneas de base reproducibles para tareas de visión:
Características:
La forma más sencilla de crear tus scripts de entrenamiento con PyTorch-Ignite:
Problemas de GitHub: preguntas, informes de errores, solicitudes de funciones, etc.
Discutir.PyTorch, categoría "Ignite".
PyTorch-Ignite Discord Server: para chatear con la comunidad
Discusiones de GitHub: discusiones generales relacionadas con la biblioteca, ideas, preguntas y respuestas, etc.
Hemos creado un formulario para "comentarios de los usuarios". Agradecemos cualquier tipo de comentario y así es como nos gustaría ver a nuestra comunidad:
¡Gracias!
Consulte las pautas de contribución para obtener más información.
Como siempre, las relaciones públicas son bienvenidas :)
Ver otros proyectos en "Usado por"
Si su proyecto implementa un artículo, representa otros casos de uso que no se tratan en nuestros tutoriales oficiales, el código de la competencia de Kaggle o simplemente su código presenta resultados interesantes y utiliza Ignite. Nos gustaría agregar su proyecto a esta lista, así que envíe un PR con una breve descripción del proyecto.
Si utiliza PyTorch-Ignite en una publicación científica, le agradeceríamos que citara nuestro proyecto.
@misc{pytorch-ignite,
author = {V. Fomin and J. Anmol and S. Desroziers and J. Kriss and A. Tejani},
title = {High-level library to help with training neural networks in PyTorch},
year = {2020},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {url{https://github.com/pytorch/ignite}},
}
PyTorch-Ignite es un proyecto afiliado a NumFOCUS, operado y mantenido por voluntarios de la comunidad PyTorch en su calidad de individuos (y no como representantes de sus empleadores). Consulte la página "Acerca de nosotros" para obtener una lista de los principales contribuyentes. Si tiene preguntas y problemas de uso, consulte los distintos canales aquí. Para todas las demás preguntas y consultas, envíe un correo electrónico a [email protected].
