Example #1
0
 def lr_find(self, files=None, bs=None, n_jobs=-1, verbose=1, **kwargs):
     bs = bs or self.bs
     files = files or self.files
     train_ds = RandomTileDataset(files,
                                  label_fn=self.label_fn,
                                  n_jobs=n_jobs,
                                  verbose=verbose,
                                  **self.mw_kwargs,
                                  **self.ds_kwargs)
     dls = DataLoaders.from_dsets(train_ds, train_ds, bs=bs)
     pre = None if self.pretrained == 'new' else self.pretrained
     model = torch.hub.load(self.repo,
                            self.arch,
                            pretrained=pre,
                            n_classes=dls.c,
                            in_channels=self.in_channels)
     if torch.cuda.is_available(): dls.cuda(), model.cuda()
     learn = Learner(dls,
                     model,
                     metrics=self.metrics,
                     wd=self.wd,
                     loss_func=self.loss_fn,
                     opt_func=_optim_dict[self.optim])
     if self.mpt: learn.to_fp16()
     sug_lrs = learn.lr_find(**kwargs)
     return sug_lrs, learn.recorder
Example #2
0
 def lr_find(self, files=None, **kwargs):
     files = files or self.files
     dls = self._get_dls(files)
     model = self._create_model()
     learn = Learner(dls,
                     model,
                     metrics=self.metrics,
                     wd=self.weight_decay,
                     loss_func=self.loss_fn,
                     opt_func=_optim_dict[self.optim])
     if self.mixed_precision_training: learn.to_fp16()
     sug_lrs = learn.lr_find(**kwargs)
     return sug_lrs, learn.recorder
Example #3
0
 def lr_find(self, files=None, **kwargs):
     files = files or self.files
     dls = self.get_dls(files)
     pre = None if self.pretrained == 'new' else self.pretrained
     model = self.get_model(pretrained=pre)
     learn = Learner(dls,
                     model,
                     metrics=self.metrics,
                     wd=self.wd,
                     loss_func=self.loss_fn,
                     opt_func=_optim_dict[self.optim])
     if self.mpt: learn.to_fp16()
     sug_lrs = learn.lr_find(**kwargs)
     return sug_lrs, learn.recorder
Example #4
0
# %%
mlp_model(torch.zeros((1, 1, 28, 28)).to(device))

# %%
print(summary(mlp_model, torch.zeros((1, 1, 28, 28)).to(device), show_input=True))
print(summary(mlp_model, torch.zeros((1, 1, 28, 28)).to(device), show_input=False))

# %%
mlp_learner = Learner(
    mnist_dls,
    mlp_model,
    metrics=[accuracy, Precision(average="macro"), Recall(average="macro")],
)

# %%
mlp_learner.lr_find()

# %%
with mlp_learner.no_bar():
    mlp_learner.fit(n_epoch=4)

# %%
conv_model = nn.Sequential(
    nn.Conv2d(1, 10, kernel_size=5, stride=(2, 2)),
    nn.ReLU(),
    nn.Conv2d(10, 20, kernel_size=5, stride=(2, 2)),
    nn.ReLU(),
    nn.Flatten(),
    nn.Linear(320, 60),
    nn.ReLU(),
    nn.Linear(60, 10),