def __init__(self, *, model: Module, optimizer: Optional[torch.optim.Adam],
loss_func: Callable):
self.loss_func = loss_func
self.optimizer = optimizer
self.model = model
tracker.set_histogram(".loss", is_print=True)
if self.optimizer is None:
tracker.set_tensor('.output')
def run(self):
pytorch_utils.add_model_indicators(self.model)
tracker.set_queue("train.loss", 20, True)
tracker.set_histogram("valid.loss", True)
tracker.set_scalar("valid.accuracy", True)
for _ in self.training_loop:
self.train()
self.test()
if self.is_log_parameters:
pytorch_utils.store_model_indicators(self.model)
def run(self):
# Training and testing
pytorch_utils.add_model_indicators(self.model)
tracker.set_queue("train.loss", 20, True)
tracker.set_histogram("valid.loss", True)
tracker.set_scalar("valid.accuracy", True)
tracker.set_indexed_scalar('valid.sample_loss')
tracker.set_indexed_scalar('valid.sample_pred')
test_data = np.array([d[0].numpy() for d in self.valid_dataset])
experiment.save_numpy("valid.data", test_data)
for _ in self.training_loop:
self.train()
self.valid()
if self.is_log_parameters:
pytorch_utils.store_model_indicators(self.model)
def __init__(self):
"""
Set tracking indicators
"""
tracker.set_histogram(f'strategy.*')
tracker.set_histogram(f'average_strategy.*')
tracker.set_histogram(f'regret.*')
def __init__(self, *, create_new_history, epochs,
is_online_update=False, n_players=2,
track_frequency=10,
save_frequency=10):
self.save_frequency = save_frequency
self.track_frequency = track_frequency
self.n_players = n_players
self.is_online_update = is_online_update
self.epochs = epochs
self.create_new_history = create_new_history
self.info_sets = {}
tracker.set_histogram(f'strategy.*')
tracker.set_histogram(f'average_strategy.*')
tracker.set_histogram(f'regret.*')
tracker.set_histogram(f'current_regret.*')
def main():
# set indicator types
tracker.set_queue("train_loss", 20, True)
tracker.set_histogram("valid_loss", True)
tracker.set_scalar("valid_accuracy", True)
epochs = 10
train_batch_size = 64
test_batch_size = 1000
use_cuda = True
cuda_device = 0
seed = 5
train_log_interval = 10
learning_rate = 0.01
# get device
is_cuda = use_cuda and torch.cuda.is_available()
if not is_cuda:
device = torch.device("cpu")
else:
if cuda_device < torch.cuda.device_count():
device = torch.device(f"cuda:{cuda_device}")
else:
print(f"Cuda device index {cuda_device} higher than "
f"device count {torch.cuda.device_count()}")
device = torch.device(f"cuda:{torch.cuda.device_count() - 1}")
# data transform
data_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
# train loader
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
str(lab.get_data_path()),
train=True,
download=True,
transform=data_transform),
batch_size=train_batch_size,
shuffle=True)
# test loader
test_loader = torch.utils.data.DataLoader(datasets.MNIST(
str(lab.get_data_path()),
train=False,
download=True,
transform=data_transform),
batch_size=test_batch_size,
shuffle=False)
# model
model = Net().to(device)
# optimizer
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# set seeds
torch.manual_seed(seed)
# only for logging purposes
configs = {
'epochs': epochs,
'train_batch_size': train_batch_size,
'test_batch_size': test_batch_size,
'use_cuda': use_cuda,
'cuda_device': cuda_device,
'seed': seed,
'train_log_interval': train_log_interval,
'learning_rate': learning_rate,
'device': device,
'train_loader': train_loader,
'test_loader': test_loader,
'model': model,
'optimizer': optimizer,
}
# create the experiment
experiment.create(name='tracker')
# experiment configs
experiment.calculate_configs(configs)
# pyTorch model
experiment.add_pytorch_models(dict(model=model))
experiment.start()
# training loop
for epoch in range(1, epochs + 1):
train(model, optimizer, train_loader, device, train_log_interval)
test(model, test_loader, device)
logger.log()
# save the model
experiment.save_checkpoint()
def add_model_indicators(model: torch.nn.Module, model_name: str = "model"):
for name, param in model.named_parameters():
if param.requires_grad:
tracker.set_histogram(f"{model_name}.{name}")
tracker.set_histogram(f"{model_name}.{name}.grad")
def startup(self):
pytorch_utils.add_model_indicators(self.model)
tracker.set_queue("train.loss", 20, True)
tracker.set_histogram("valid.loss", True)
tracker.set_scalar("valid.accuracy", True)
def main():
# ✨ Set the types of the stats/indicators.
# They default to scalars if not specified
tracker.set_queue('loss.train', 20, True)
tracker.set_histogram('loss.valid', True)
tracker.set_scalar('accuracy.valid', True)
# Configurations
configs = {
'epochs': 10,
'train_batch_size': 64,
'valid_batch_size': 100,
'use_cuda': True,
'seed': 5,
'train_log_interval': 10,
'learning_rate': 0.01,
}
is_cuda = configs['use_cuda'] and torch.cuda.is_available()
if not is_cuda:
device = torch.device("cpu")
else:
device = torch.device(f"cuda:0")
data_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_loader = torch.utils.data.DataLoader(
datasets.MNIST(str(lab.get_data_path()),
train=True,
download=True,
transform=data_transform),
batch_size=configs['train_batch_size'], shuffle=True)
valid_loader = torch.utils.data.DataLoader(
datasets.MNIST(str(lab.get_data_path()),
train=False,
download=True,
transform=data_transform),
batch_size=configs['valid_batch_size'], shuffle=False)
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=configs['learning_rate'])
torch.manual_seed(configs['seed'])
# ✨ Create the experiment
experiment.create(name='mnist_labml_tracker')
# ✨ Save configurations
experiment.configs(configs)
# ✨ Set PyTorch models for checkpoint saving and loading
experiment.add_pytorch_models(dict(model=model))
# ✨ Start and monitor the experiment
with experiment.start():
#
for epoch in range(1, configs['epochs'] + 1):
train(model, optimizer, train_loader, device, configs['train_log_interval'])
validate(model, valid_loader, device)
logger.log()
# ✨ Save the models
experiment.save_checkpoint()