[](https://travis-ci.org/pytorch/ignite)
[](https://github.com/pytorch/ignite/actions)
[](https://circleci.com/gh/pytorch/ignite)[](https://circleci.com/gh/pytorch/ignite)
[](https://codecov.io/gh/pytorch/ignite)
[](https://pytorch.org/ignite/index.html)
 [](https://anaconda.org/pytorch/ignite)
[](https://anaconda.org/pytorch/ignite)
[](https://pypi.org/project/pytorch-ignite/)
[](https://pepy.tech/project/pytorch-ignite)
 [](https://anaconda.org/pytorch-nightly/ignite)
[](https://pypi.org/project/pytorch-ignite/#history)
 [](https://optuna.org)
[](https://github.com/psf/black)
[](https://twitter.com/pytorch_ignite)
 [](https://github.com/pytorch/ignite/actions?query=workflow%3A.github%2Fworkflows%2Fpytorch-version-tests.yml)
TL;DR
Ignite is a high-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.
*Click on the image to see complete code*
Features
-
Less code than pure PyTorch
while ensuring maximum control and simplicity
-
Library approach and no program's control inversion - Use ignite where and when you need
-
Extensible API for metrics, experiment managers, and other components
Table of Contents
Why Ignite?
Ignite is a library that provides three high-level features:
- Extremely simple engine and event system
- Out-of-the-box metrics to easily evaluate models
- Built-in handlers to compose training pipeline, save artifacts and log parameters and metrics
Simplified training and validation loop
No more coding for/while loops on epochs and iterations. Users instantiate engines and run them.
Example
```python
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
# E.g. 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)
```
Power of Events & Handlers
The cool thing with handlers is that they offer unparalleled flexibility (compared to say, callbacks). Handlers can be any function: e.g. lambda, simple function, class method etc. Thus, we do not require to inherit from an interface and override its abstract methods which could unnecessarily bulk up your code and its complexity.
Execute any number of functions whenever you wish
Examples
```python
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("Training is ended. mydata={}".format(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)
```
Built-in events filtering
Examples
```python
# 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():
# ...
```
Stack events to share some actions
Examples
Events can be stacked together to enable multiple calls:
```python
@trainer.on(Events.COMPLETED | Events.EPOCH_COMPLETED(every=10))
def run_validation():
# ...
```
Custom events to go beyond standard events
Examples
Custom events related to backward and optimizer step calls:
```python
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):
# ...
```
- Complete snippet can be found [here](https://pytorch.org/ignite/faq.html#creating-custom-events-based-on-forward-backward-pass).
- Another use-case of custom events: [trainer for Truncated Backprop Through Time](https://pytorch.org/ignite/contrib/engines.html#ignite.contrib.engines.create_supervised_tbptt_trainer).
Out-of-the-box metrics
Example
```python
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")
```
Installation
From pip:
pip install pytorch-ignite
From conda:
conda install ignite -c pytorch
From source:
pip install git+https://github.com/pytorch/ignite
Nightly releases
From pip:
pip install --pre pytorch-ignite
From conda (this suggests to install pytorch nightly release instead of stable
version as dependency):
conda install ignite -c pytorch-nightly
Getting Started
Few pointers to get you started:
Documentation
Additional Materials
Examples
Complete list of examples can be found here.
Tutorials
Reproducible Training Examples
Inspired by torchvision/references,
we provide several reproducible baselines for vision tasks:
- ImageNet - logs on Ignite Trains server coming soon ...
- Pascal VOC2012 - logs on Ignite Trains server coming soon ...
Features:
Communication
User feedback
We have created a form for "user feedback". We
appreciate any type of feedback and this is how we would like to see our
community:
- If you like the project and want to say thanks, this the right
place.
- If you do not like something, please, share it with us and we can
see how to improve it.
Thank you !
Contributing
Please see the contribution guidelines for more information.
As always, PRs are welcome :)
Projects using Ignite
Research papers
Blog articles, tutorials, books
Toolkits
Others
See other projects at "Used by"
If your project implements a paper, represents other use-cases not
covered in our official tutorials, Kaggle competition's code or just
your code presents interesting results and uses Ignite. We would like to
add your project in this list, so please send a PR with brief
description of the project.
About the team
Project is currently maintained by a team of volunteers.
See the "About us" page for a list of core contributors.
Text Classification using Convolutional Neural
Networks