def main(): model = ClassifyUnet(1, 28, 10) optimizer = torch.optim.Adam(model.parameters(), lr=0.02) loaders = { "train": DataLoader( MNIST( "./data", train=False, download=True, transform=ToTensor(), ), batch_size=32, ), "valid": DataLoader( MNIST( "./data", train=False, download=True, transform=ToTensor(), ), batch_size=32, ), } runner = CustomRunner() runner.train( model=model, optimizer=optimizer, loaders=loaders, verbose=True, check=True, )
def _get_loaders( *, root: str, batch_size: int = 1, num_workers: int = 1 ) -> Dict[str, DataLoader]: """ Function to get loaders just for testing. Args: root (str): Path to root of dataset. batch_size (int): Batch size. num_workers (int): Num of workers. Returns: Dict[str, DataLoader]: Dict of loaders. """ data_transform = ToTensor() trainset = MNIST( root=root, train=True, download=True, transform=data_transform ) trainloader = DataLoader( trainset, batch_size=batch_size, num_workers=num_workers ) testset = MNIST( root=root, train=False, download=True, transform=data_transform ) testloader = DataLoader( testset, batch_size=batch_size, num_workers=num_workers ) loaders = collections.OrderedDict(train=trainloader, valid=testloader) return loaders
def main(): generator = nn.Sequential( # We want to generate 128 coefficients to reshape into a 7x7x128 map nn.Linear(128, 128 * 7 * 7), nn.LeakyReLU(0.2, inplace=True), Lambda(lambda x: x.view(x.size(0), 128, 7, 7)), nn.ConvTranspose2d(128, 128, (4, 4), stride=(2, 2), padding=1), nn.LeakyReLU(0.2, inplace=True), nn.ConvTranspose2d(128, 128, (4, 4), stride=(2, 2), padding=1), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(128, 1, (7, 7), padding=3), nn.Sigmoid(), ) discriminator = nn.Sequential( nn.Conv2d(1, 64, (3, 3), stride=(2, 2), padding=1), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(64, 128, (3, 3), stride=(2, 2), padding=1), nn.LeakyReLU(0.2, inplace=True), GlobalMaxPool2d(), Flatten(), nn.Linear(128, 1), ) model = {"generator": generator, "discriminator": discriminator} optimizer = { "generator": torch.optim.Adam( generator.parameters(), lr=0.0003, betas=(0.5, 0.999) ), "discriminator": torch.optim.Adam( discriminator.parameters(), lr=0.0003, betas=(0.5, 0.999) ), } loaders = { "train": DataLoader( MNIST( os.getcwd(), train=True, download=True, transform=ToTensor(), ), batch_size=32, ), } runner = CustomRunner() runner.train( model=model, optimizer=optimizer, loaders=loaders, callbacks=[ dl.OptimizerCallback( optimizer_key="generator", metric_key="loss_generator" ), dl.OptimizerCallback( optimizer_key="discriminator", metric_key="loss_discriminator" ), ], main_metric="loss_generator", num_epochs=20, verbose=True, logdir="./logs_gan", check=True, )
def datasets_fn(): """ Docs. """ dataset = MNIST( os.getcwd(), train=False, download=True, transform=ToTensor(), ) return {"train": dataset, "valid": dataset}
def main(): """Run few epochs to check ``BatchTransformCallback`` callback.""" model = torch.nn.Linear(28 * 28, 10) optimizer = torch.optim.Adam(model.parameters(), lr=0.02) loaders = { "train": DataLoader( MNIST( os.getcwd(), train=True, download=True, transform=ToTensor() ), batch_size=32, ), "valid": DataLoader( MNIST( os.getcwd(), train=False, download=True, transform=ToTensor() ), batch_size=32, ), } transrorms = [ augmentation.RandomAffine(degrees=(-15, 20), scale=(0.75, 1.25)), ] runner = CustomRunner() # model training runner.train( model=model, optimizer=optimizer, loaders=loaders, logdir="./logs", num_epochs=5, verbose=True, load_best_on_end=True, check=True, callbacks=[BatchTransformCallback(transrorms, input_key=0)], ) # model inference for prediction in runner.predict_loader(loader=loaders["train"]): assert prediction.detach().cpu().numpy().shape[-1] == 10
def _get_loaders(*, root: str, batch_size: int = 1, num_workers: int = 1): data_transform = ToTensor() trainset = MNIST( root=root, train=True, download=True, transform=data_transform ) trainloader = DataLoader( trainset, batch_size=batch_size, num_workers=num_workers ) testset = MNIST( root=root, train=False, download=True, transform=data_transform ) testloader = DataLoader( testset, batch_size=batch_size, num_workers=num_workers ) loaders = collections.OrderedDict(train=trainloader, valid=testloader) return loaders
sys.exit() # # Data # In[ ]: import collections import torch from catalyst.contrib.datasets import MNIST from catalyst.contrib.data.transforms import ToTensor, Compose, Normalize bs = 32 num_workers = 0 data_transform = Compose([ToTensor(), Normalize((0.1307, ), (0.3081, ))]) loaders = collections.OrderedDict() trainset = MNIST("./data", train=False, download=True, transform=data_transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=bs, shuffle=True, num_workers=num_workers) testset = MNIST("./data", train=False, download=True, transform=data_transform) testloader = torch.utils.data.DataLoader(testset, batch_size=bs,
def get_transforms(stage: str = None, mode: str = None): """ @TODO: Docs. Contribution is welcome """ return Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
import torch from torch.nn import functional as F from torch.utils.data import DataLoader from catalyst import dl from catalyst.contrib.data.transforms import ToTensor from catalyst.contrib.datasets import MNIST from catalyst.utils import metrics model = torch.nn.Linear(28 * 28, 10) optimizer = torch.optim.Adam(model.parameters(), lr=0.02) loaders = { "train": DataLoader( MNIST(os.getcwd(), train=True, download=True, transform=ToTensor()), batch_size=32, ), } class CustomRunner(dl.Runner): def predict_batch(self, batch): # model inference step return self.model(batch[0].to(self.device).view(batch[0].size(0), -1)) def _handle_batch(self, batch): # model train/valid step x, y = batch y_hat = self.model(x.view(x.size(0), -1))
import torch from torch.nn import functional as F from torch.utils.data import DataLoader from catalyst import dl from catalyst.contrib.data.transforms import ToTensor from catalyst.contrib.datasets import MNIST from catalyst.utils import metrics model = torch.nn.Linear(28 * 28, 10) optimizer = torch.optim.Adam(model.parameters(), lr=0.02) loaders = { "train": DataLoader( MNIST("./data", train=True, download=True, transform=ToTensor()), batch_size=32, ), } class CustomRunner(dl.Runner): def predict_batch(self, batch): # model inference step return self.model(batch[0].to(self.device).view(batch[0].size(0), -1)) def _handle_batch(self, batch): # model train/valid step x, y = batch y_hat = self.model(x.view(x.size(0), -1))
import os, torch from torch.nn import functional as F from catalyst import dl from catalyst.contrib.data.transforms import ToTensor from catalyst.contrib.datasets import MNIST from catalyst.utils import metrics model = torch.nn.Linear(28 * 28, 10) optimizer = torch.optim.Adam(model.parameters(), lr=0.02) loaders = { "train": DataLoader(MNIST(os.getcwd(), train=True, download=True, transform=ToTensor()), batch_size=32), "valid": DataLoader(MNIST(os.getcwd(), train=False, download=True, transform=ToTensor()), batch_size=32), } class CustomRunner(dl.Runner): def predict_batch(self, batch): return self.model(batch[0].to(self.device).view(batch[0].size(0), -1)) def _handle_batch(self, batch):