A look at pytorch/ignite: 4.8k stars on GitHub, written primarily in Python, tracked under the AI Tools category. High-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
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
Table of Contents
Why Ignite?
Simplified training and validation loop
Power of Events & Handlers
Execute any number of functions whenever you wish
Built-in events filtering
Stack events to share some actions
Custom events to go beyond standard events
Out-of-the-box metrics
Installation
Nightly releases
Docker Images
Using pre-built images
Getting Started
Documentation
Additional Materials
Examples
Tutorials
Reproducible Training Examples
Communication
User feedback
Contributing
Projects using Ignite
Citing Ignite
About the team & Disclaimer
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
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)
Power of Events & Handlers
The cool thing with handlers is that they offer unparalleled flexibility (compared to, for example, 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
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)
Built-in events filtering
Examples
# 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:
CNN-CASS: CNN for Classification of Coronary Artery Stenosis Score in MPR Images
Bridging Text and Video: A Universal Multimodal Transformer for Video-Audio Scene-Aware Dialog
Adversarial Decomposition of Text Representation
Uncertainty Estimation Using a Single Deep Deterministic Neural Network
DeepSphere: a graph-based spherical CNN
Norm-in-Norm Loss with Faster Convergence and Better Performance for Image Quality Assessment
Unified Quality Assessment of In-the-Wild Videos with Mixed Datasets Training
Deep Signature Transforms
Neural CDEs for Long Time-Series via the Log-ODE Method
Volumetric Grasping Network
Mood Classification using Listening Data
Deterministic Uncertainty Estimation (DUE)
PyTorch-Hebbian: facilitating local learning in a deep learning framework
Stochastic Weight Matrix-Based Regularization Methods for Deep Neural Networks
Learning explanations that are hard to vary
The role of disentanglement in generalisation
A Probabilistic Programming Approach to Protein Structure Superposition
PadChest: A large chest x-ray image dataset with multi-label annotated reports
Blog articles, tutorials, books
State-of-the-Art Conversational AI with Transfer Learning
Tutorial on Transfer Learning in NLP held at NAACL 2019
Deep-Reinforcement-Learning-Hands-On-Second-Edition, published by Packt
Once Upon a Repository: How to Write Readable, Maintainable Code with PyTorch
The Hero Rises: Build Your Own SSD
Using Optuna to Optimize PyTorch Ignite Hyperparameters
PyTorch Ignite - Classifying Tiny ImageNet with EfficientNet
Toolkits
Project MONAI - AI Toolkit for Healthcare Imaging
DeepSeismic - Deep Learning for Seismic Imaging and Interpretation
Nussl - a flexible, object-oriented Python audio source separation library
PyTorch Adapt - A fully featured and modular domain adaptation library
gnina-torch: PyTorch implementation of GNINA scoring function
Others
Implementation of "Attention is All You Need" paper
Implementation of DropBlock: A regularization method for convolutional networks in PyTorch
Kaggle Kuzushiji Recognition: 2nd place solution
Unsupervised Data Augmentation experiments in PyTorch
Hyperparameters tuning with Optuna
Logging with ChainerUI
FixMatch experiments in PyTorch and Ignite (CTA dataaug policy)
Kaggle Birdcall Identification Competition: 1st place solution
Logging with Aim - An open-source experiment tracker
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 to this list, so please send a PR with brief
description of the project.
Citing Ignite
If you use PyTorch-Ignite in a scientific publication, we would appreciate citations to our project.
@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}},
}
About the team & Disclaimer
PyTorch-Ignite is a NumFOCUS Affiliated Project, operated and maintained by volunteers in the PyTorch community in their capacities as individuals
(and not as representatives of their employers). See the "About us"
page for a list of core contributors. For usage questions and issues, please see the various channels
here. For all other questions and inquiries, please send an email
to [email protected].
The most recent commit recorded on pytorch/ignite was 3 months ago, based on the GitHub push timestamp. The repository has 771 forks — one of the better signals of community interest.
How does pytorch/ignite compare to other AI Tools projects?
pytorch/ignite is tracked by TopGit in the AI Tools category, with 4.8k GitHub stars and written in Python. Browse the AI Tools topic page on TopGit to compare it against similar projects by stars and activity.
How many stars does pytorch/ignite have?
pytorch/ignite has 4.8k GitHub stars — refresh the page for the live number, or check github.com/pytorch/ignite. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
Is pytorch/ignite open source?
Yes — pytorch/ignite ships under the BSD-3-Clause license, which makes its source code freely readable (and, depending on license terms, forkable and reusable). Source: github.com/pytorch/ignite.
What is pytorch/ignite?
pytorch/ignite (pytorch/ignite) is a Python project on GitHub. From the project's own README: High-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.
Where do I read more about pytorch/ignite?
This TopGit page is a snapshot — the READ ME tab shows the project's own README content (links stripped, images preserved). The GitHub repository at github.com/pytorch/ignite is the definitive source.
Read full README in the tab above.
Want a second opinion on ignite?
Ask an AI that can read this page — one click and you get its take on ignite.