Provide LightningModule for simple use cases
I think the project could benefit from having a set of "out-of-the-box" lightning modules to promote easy and fast experimentation with existing paradigms.
This idea is a bit inspired by ignite's create_supervised_trainer functionality.
In Lightning, this would go something like this:
import pytorch_lightning as pl


class SupervisedLightningModule(pl.LightningModule):

    def __init__(self,
                 model,
                 optimizer=None,
                 loss=None,
                 loader=None):

        super().__init__()

        self.model = model
        self.loader = loader
        self.loss = loss
        self.optimizer = optimizer

    def set_dataloader(self, loader):
        self.loader = loader

    def set_optimizer(self, optimizer):
        self.optimizer = optimizer

    def set_loss(self, loss):
        self.loss = loss

    def forward(self, x):
        return self.model.forward(x)

    def training_step(self, batch, batch_nb):
        x, y = batch
        y_hat = self.forward(x)
        return {'loss': self.loss(y_hat, y)}

    def configure_optimizers(self):
        return self.optimizer

    def tng_dataloader(self):
        return self.loader


if __name__ == '__main__':
    import os
    import torch
    from torch.utils.data import DataLoader
    from torchvision.datasets import MNIST
    import torchvision.transforms as transforms
    from pytorch_lightning import Trainer

    model = torch.nn.Linear(10, 10)
    loader = DataLoader(MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor()), batch_size=32)
    pl_model = SupervisedLightningModule(
        model=model,
        loader=loader,
        optimizer=torch.optim.SGD(model.parameters(), lr=0.01),
        loss=torch.nn.CrossEntropyLoss()
    )
    
    trainer = Trainer()
    trainer.fit(pl_model)
This is a very barebones idea/code but it could be expanded upon, making standard experiments effectively effortless.
Let me know what you think, and I can help.