def test_accuracy():
"""Test if accuracy drops too low.
"""
model = torch.nn.Sequential(
Flatten(),
torch.nn.Linear(28 * 28, 128),
torch.nn.ReLU(),
torch.nn.Linear(128, 64),
torch.nn.Linear(64, 10),
)
datasets = {
"train": MNIST("./data", transform=ToTensor(), download=True),
"valid": MNIST("./data", transform=ToTensor(), train=False),
}
dataloaders = {
k: torch.utils.data.DataLoader(d, batch_size=32)
for k, d in datasets.items()
}
optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
runner = SupervisedRunner()
runner.train(
model=model,
optimizer=optimizer,
loaders=dataloaders,
callbacks=[AccuracyCallback(target_key="targets", input_key="logits")],
num_epochs=1,
criterion=torch.nn.CrossEntropyLoss(),
valid_loader="valid",
valid_metric="accuracy01",
minimize_valid_metric=False,
)
accuracy_before = _evaluate_loader_accuracy(runner, dataloaders["valid"])
q_model = quantize_model(model)
runner.model = q_model
accuracy_after = _evaluate_loader_accuracy(runner, dataloaders["valid"])
assert abs(accuracy_before - accuracy_after) < 0.01
from catalyst.runners import SupervisedRunner
# experiment setup
num_epochs = 2
logdir = "./logs/segmentation_notebook"
# model, criterion, optimizer
model = Unet(num_classes=1, in_channels=1, num_channels=32, num_blocks=2)
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[10, 20, 40],
gamma=0.3)
# model runner
runner = SupervisedRunner()
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir=logdir,
num_epochs=num_epochs,
check=True,
load_best_on_end=True,
)
# # Inference
teacher = ExampleModel(num_layers=4)
student = ExampleModel(num_layers=3)
datasets = {
"train": Wrp(MNIST("./data", train=True, download=True)),
"valid": Wrp(MNIST("./data", train=False)),
}
loaders = {
dl_key: DataLoader(dataset, shuffle=dl_key == "train", batch_size=32)
for dl_key, dataset in datasets.item()
}
optimizer = torch.optim.Adam(teacher.parameters(), lr=1e-2)
runner = SupervisedRunner()
runner.train(
model=teacher,
loaders=loaders,
optimizer=optimizer,
criterion=nn.CrossEntropyLoss(),
callbacks=[AccuracyCallback(input_key="logits", target_key="targets")],
valid_metric="accuracy01",
minimize_valid_metric=False,
num_epochs=5,
)
mse_callback = MSEHiddenStatesCallback()
select_last_hidden_states = HiddenStatesSelectCallback(layers=[2, 3])
kl_callback = KLDivCallback()
# In[ ]:
from catalyst.runners import SupervisedRunner
# experiment setup
num_epochs = NUM_EPOCHS
logdir = "./logs/cifar_simple_notebook_1"
# model, criterion, optimizer
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
# model runner
runner = SupervisedRunner()
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir=logdir,
num_epochs=num_epochs,
check=True,
)
# In[ ]:
# you can use plotly and tensorboard to plot metrics inside jupyter
def main(args):
set_global_seed(args.seed)
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
datasets = {
"train":
Wrp(
CIFAR100(root=".",
train=True,
download=True,
transform=transform_train)),
"valid":
Wrp(CIFAR100(root=".", train=False, transform=transform_test)),
}
loaders = {
k: DataLoader(v,
batch_size=args.batch_size,
shuffle=k == "train",
num_workers=2)
for k, v in datasets.items()
}
model = NAME2MODEL[args.model](num_classes=100)
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
[150, 180, 210],
gamma=0.1)
runner = SupervisedRunner()
runner.train(model=model,
loaders=loaders,
optimizer=optimizer,
scheduler=scheduler,
valid_metric="accuracy",
minimize_valid_metric=False,
logdir=args.logdir,
callbacks=[
CriterionCallback(input_key="logits",
target_key="targets",
metric_key="loss"),
AccuracyCallback(input_key="logits",
target_key="targets"),
OptimizerCallback(metric_key="loss"),
SchedulerCallback(),
],
valid_loader="valid",
num_epochs=args.num_epochs,
criterion=torch.nn.CrossEntropyLoss(),
seed=args.seed)