Olympus

Decades of machine learning research at your fingertips.

Features

  • Deterministic Blocks
  • Reproducible baselines for a variety of tasks
  • Integrated Hyperparameter Optimizer (Orion)
  • Experiment Tracking
  • Model Zoo
  • Pretrained Models
  • Multi GPU training
  • Automatic Checkpointing
  • Mixed precision Available

Baselines

Run any baselines in a few lines of code

$ pip install olympus
$ export OLYMPUS_DATA_PATH=/fast
$ olympus --devices 0 classification --batch-size 32 --epochs 10 --dataset mnist --model resnet18
{
  "train_accuracy": 0.6458333333333334,
  "train_loss": 2.109870990117391,
  "elapsed_time": 9,
  "sample_count": 960,
  "epoch": 9,
  "adversary_accuracy": 0.3020833333333333,
  "adversary_loss": 2.234758218129476,
  "adversary_distortion": 0.2575291295846303,
  "validation_accuracy": 0.5986421725239617,
  "validation_loss": 2.108673614815782
}
{
  "temperature.gpu": 34.083333333333336,
  "utilization.gpu": 10.333333333333334,
  "utilization.memory": 0.0,
  "memory.total": 32480.0,
  "memory.free": 31672.833333333332,
  "memory.used": 807.1666666666666
}

Deterministic Blocks

Writing a full pipeline has never been easier, even when optimizing over hyper parameters !

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
from argparse import ArgumentParser

from olympus import fetch_device, StateStorage
from olympus.hpo import HPOptimizer, Fidelity
from olympus.datasets import Dataset, SplitDataset, DataLoader
from olympus.metrics import Accuracy
from olympus.models import Model
from olympus.optimizers import Optimizer, LRSchedule
from olympus.tasks import Classification
from olympus.tasks.hpo import HPO
from olympus.utils import option, show_dict


parser = ArgumentParser()
parser.add_argument('--epochs', type=int, default=3)
args = parser.parse_args()
device = fetch_device()
base = option('base_path', '/tmp/olympus')


def make_task():
    model = Model(
        'logreg',
        input_size=(1, 28, 28),
        output_size=(10,)
    )

    optimizer = Optimizer('sgd')

    lr_schedule = LRSchedule('exponential')

    data = Dataset('test-mnist', path=f'{base}/data')

    splits = SplitDataset(data, split_method='original')

    loader = DataLoader(
        splits,
        sampler_seed=1,
        batch_size=32
    )

    main_task = Classification(
        classifier=model,
        optimizer=optimizer,
        lr_scheduler=lr_schedule,
        dataloader=loader.train(),
        device=device,
        storage=StateStorage(folder=f'{base}/hpo_simple'))

    main_task.metrics.append(
        Accuracy(name='validation', loader=loader.valid(batch_size=64))
    )

    return main_task


space = make_task().get_space()

hp_optimizer = HPOptimizer(
    'hyperband',
    fidelity=Fidelity(1, 30).to_dict(),
    space=space)

hpo_task = HPO(hp_optimizer, make_task)

result = hpo_task.fit(objective='validation_accuracy')

print('Best Params:')
print('-' * 40)
print(f'validation_accuracy: {result.objective}')
show_dict(result.params)