def __init__(self,
detector,
optimizer,
lr_scheduler,
dataloader,
criterion=None,
device=None,
storage=None):
super(ObjectDetection, self).__init__(device=device)
self._first_epoch = 0
self.current_epoch = 0
self.detector = detector
self.optimizer = optimizer
self.lr_scheduler = lr_scheduler
self.dataloader = dataloader
self.criterion = criterion
self.storage = storage
self.metrics.append(ElapsedRealTime().every(batch=1))
self.metrics.append(SampleCount().every(batch=1, epoch=1))
speed = Speed()
self.metrics.append(speed)
self.metrics.append(ProgressView(speed))
self.metrics.append(OnlineLoss())
if storage:
self.metrics.append(CheckPointer(storage=storage))
def __init__(self, classifier, optimizer, lr_scheduler, dataloader, criterion=None, device=None,
storage=None, preprocessor=None, metrics=None):
super(Classification, self).__init__(device=device)
criterion = select(criterion, CrossEntropyLoss())
self._first_epoch = 0
self.current_epoch = 0
self.classifier = classifier
self.optimizer = optimizer
self.lr_scheduler = lr_scheduler
self.dataloader = dataloader
self.criterion = criterion
self.preprocessor = Preprocessor()
# ------------------------------------------------------------------
self.metrics.append(ElapsedRealTime().every(batch=1))
self.metrics.append(SampleCount().every(batch=1, epoch=1))
self.metrics.append(OnlineTrainAccuracy())
self.metrics.append(Speed())
# All metrics must be before ProgressView and CheckPointer
if metrics:
for metric in metrics:
self.metrics.append(metric)
self.metrics.append(ProgressView(self.metrics.get('Speed')))
if storage:
self.metrics.append(CheckPointer(storage=storage))
# ------------------------------------------------------------------
if preprocessor is not None:
self.preprocessor = preprocessor
self.hyper_parameters = {}
def __init__(self,
dataset,
oracle,
model,
optimizer,
device,
criterion=SharpeRatioCriterion()):
super(Finance, self).__init__(device=device)
self.dataset = dataset
self.oracle = oracle
self.criterion = criterion
self.model = model
self.optimizer = optimizer
self.metrics.append(ElapsedRealTime().every(batch=1))
self.metrics.append(SampleCount().every(batch=1, epoch=1))
speed = Speed()
self.metrics.append(speed)
self.metrics.append(ProgressView(speed))
self.metrics.append(OnlineLoss())
self.metrics.append(NamedMetric(name='mean_returns'))
self.metrics.append(NamedMetric(name='std_returns'))
self.current_epoch = 0
self.hyper_parameters = {}
def test_speed_5():
# Speed drop the first 5 observations
speed = Speed()
progress = ProgressView(speed)
task = TaskMock(callback=stop_after(None, 10, sleep_time=1))
task.metrics.append(speed)
task.metrics.append(progress)
with pytest.raises(StopIteration):
task.fit()
assert speed.step_time.avg - 1 <= 0.1
assert speed.step_time.sd <= 0.1
assert speed.step_time.count == 5
assert speed.value()['batch_speed'] - 4 <= 0.1
def __init__(self,
model: AbstractActorCritic,
dataloader,
optimizer,
lr_scheduler,
device,
ppo_epoch=5,
ppo_batch_size=32,
ppo_clip_param=10,
ppo_max_grad_norm=1000,
criterion=None,
storage=None,
logger=None):
super(PPO, self).__init__(device=device)
if criterion is None:
criterion = lambda x: x.sum()
self.actor_critic = model
self.lr_scheduler = lr_scheduler
self.optimizer: Optimizer = optimizer
self.criterion: Module = criterion
self.gamma: float = 0.99
self.eps = np.finfo(np.float32).eps.item()
self.action_sampler: Callable[[], Distribution] = Categorical
self.tensor_shape = None
self.frame_count: int = 0
self.dataloader = dataloader
self.storage = storage
self._first_epoch = 0
self.current_epoch = 0
self.ppo_epoch = ppo_epoch
self.ppo_batch_size = ppo_batch_size
self.ppo_clip_param = ppo_clip_param
self.ppo_max_grad_norm = ppo_max_grad_norm
self.metrics.append(NamedMetric(name='loss'))
self.metrics.append(ElapsedRealTime())
self.metrics.append(Speed())
self.metrics.append(ProgressView(self.metrics.get('Speed')))
if storage:
self.metrics.append(CheckPointer(storage=storage))
self.hyper_parameters = {}
self.batch_size = None
# Schedule
lr_schedule = LRSchedule('exponential', optimizer=optimizer, gamma=0.99)
data = Dataset('fake_mnist', path=f'{base}/data')
splits = SplitDataset(data, split_method='original')
# Dataloader
loader = DataLoader(splits, sampler_seed=1, batch_size=32)
# event handler
event_handler = ObserverList()
speed = Speed()
event_handler.append(
ProgressView(speed, max_epochs=epochs,
max_steps=len(loader.train())).every(epoch=1, batch=1))
model = model.to(device=device)
loss = 0
event_handler.start_train()
for e in range(epochs):
losses = []
event_handler.new_epoch(e + 1)
for step, ((batch, ), target) in enumerate(loader.train()):
event_handler.new_batch(step)
optimizer.zero_grad()
predict = model(batch.to(device=device))
def show_progress():
epochs = 4
steps = 12
# Speed drop the first 5 observations
speed = Speed()
progress_default = ProgressView(speed)
progress_epoch_guess = ProgressView(speed, max_epochs=epochs)
progress_epoch = ProgressView(speed, max_epochs=epochs, max_steps=steps)
progress_steps = ProgressView(speed, max_steps=epochs * steps)
progress_default.print_fun = named_print('default')
progress_epoch_guess.print_fun = named_print(' guess')
progress_epoch.print_fun = named_print(' epoch')
progress_steps.print_fun = named_print(' step')
task = TaskMock(callback=stop_after(None, None, sleep_time=1),
epochs=epochs,
steps=steps)
task.metrics.append(speed)
task.metrics.append(ElapsedRealTime())
task.metrics.append(progress_default)
task.metrics.append(progress_epoch_guess)
task.metrics.append(progress_epoch)
task.metrics.append(progress_steps)
task.fit()