!! Please note that this library may be recently changed its name and repository address!!
The project is currently under heavy development, and focusing on PyTorch and the recommendation scenario.
About
Veloce is an instant distributed computing library based on the Ray Train and Ray Data, which is scalable, efficient, and easy-to-use. It accelerates the development of any ML/DL training workload, on any cloud or local, at any parallelism size. Previously named Enscale.
Goals
- Launch any interactive ML/DL workloads instantly on your laptop or to any cloud
- Scale your own single-machine neural network modules to a native distributed manner
- Apply heterogeneous architecture
- Data scientist-friendly API
- Sparse and dense feature definitions
Non-Goals
- Not a neural network library, there are only some benchmark modules provided.
Getting Started
Prerequisites
- Python version >=
3.7.1 - Packages
- requests >=
2.26.0 - ray >=
1.9.2and <=1.10 - torch >=
1.9.1 - pandas >=
1.3.5 - pyarrow >=
6.0.1
- requests >=
Installation
Using Pre-compiled Wheels
pip install veloce
From Source
cd veloce
pip install -e .
Runtime environment
The library can launch locally or on any cloud provider with Ray set up.
- If you want to launch on the cloud, go through this doc to set up your Ray Cluster. And then you can use
environ_validate(n_cpus=N, cluster_endpoint="ray://to connect your cluster.: ") - Or just use
environ_validate(n_cpus=N)to have a local experience.
You can add more native ray.init arguments, just put them into environ_validate call. Like environ_validate(n_cpus=N, ignore_reinit_error=True) to make Ray suppresses errors from calling ray.init() a second time.
Lightning example
See more hands-on and advanced examples here, like heterogeneous support and sparsity definition.
The following example requires sklearn to be installed. And tqdm is optional, which enables progress reporting.
import torch.nn as nn
from sklearn.metrics import roc_auc_score
from veloce.util import pprint_results, load_benchmark_dataset
from veloce.model.ctr import DeepFM
from veloce import NeuralNetTrainer, environ_validate
N_WORKERS = 2
N_DATA_PROCESSOR = 1
# ray environment setup
environ_validate(n_cpus=N_DATA_PROCESSOR + N_WORKERS)
# load dataset and sparsity definition pre-defined
datasets, feature_defs, dataset_options = load_benchmark_dataset(
# set your own dataset by `data_path="criteo_mini.txt"`
separate_valid_dataset=False
)
# trainer setup
trainer = NeuralNetTrainer(
# module and dataset configs
module=DeepFM, # your own nn.Module or built in modules
module_params={
"dense_feature_defs": feature_defs["dense"],
"sparse_feature_defs": feature_defs["sparse"],
},
dataset=datasets,
dataset_options=dataset_options,
# trainer configs
epochs=5,
batch_size=512,
loss_fn=nn.BCELoss(),
optimizer=torch.optim.Adam,
metric_fns=[roc_auc_score],
# logger callbacks
callbacks=["json"],
# computation abstract on distributed
num_workers=N_WORKERS,
)
# run and print results
results = trainer.run()
pprint_results(results)
Architecture
Roadmap
- Heterogeneous Strategy on Distributed Training
- Sync Parameter Server
- Aync Parameter Server
- Hybird Phase 1: use sync or async for the dense or sparse component as you like, under homogeneous architecture
- Hybird Phase 2: you can choose async PS for the sparse component, and sync Ring Allreduce (like PyTorch's DDP) for the dense component
- Framework Support
- PyTorch: no specific plan to support other frameworks
- Advanced Parallel Mechanism
- Heavy integrated torchrec
- Accelerator Support
- GPU: complete inspection required
Reference
- Ray and Ray Train: Ray Train is a lightweight library for distributed deep learning, allowing you to scale up and speed up training for your deep learning models. Docs here.
- DeepCTR-Torch: Easy-to-use, modular and extendible package of deep-learning based CTR models.
License
Veloce is MIT licensed, as found in the LICENSE file.