Trainer got an unexpected keyword argument 'save_best_only'
When I tried to run the following code:
import os
import argparse

import torch
import torch.nn as nn

from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
import torchvision.transforms as transforms

import pytorch_lightning as pl
from pytorch_lightning import Trainer


def parse_args():
    parser = argparse.ArgumentParser()

    parser.add_argument('--input', dest='input_dim', type=int, default=28*28)
    parser.add_argument('--output', dest='output_dim', type=int, default=10)

    return parser.parse_args()


class Net(pl.LightningModule):
    def __init__(self, input_dim, output_dim):
        super(Net, self).__init__()
        self.__dict__.update(locals())

        self.layers = nn.Sequential(
            nn.Linear(input_dim, input_dim),
            nn.ReLU(inplace=True),
            nn.Linear(input_dim, output_dim),
            nn.ReLU(inplace=True)
        )

        self.criterion = nn.CrossEntropyLoss()

    def forward(self, x):
        out = self.layers(x.view(x.size(0), -1))

        return out

    def training_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self.forward(x)
        loss = self.criterion(y_hat, y)

        return {'loss': loss}

    def validation_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self.forward(x)
        loss = self.criterion(y_hat, y)

        return {'val_loss': loss}

    def validation_end(self, outputs):
        avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()
        tensorboard_logs = {'val_loss': avg_loss}

        return {'avg_val_loss': avg_loss, 'log': tensorboard_logs}

    def test_step(self, batch, batch_idx):
        x, y = batch
        y_hat = self.forward(x)
        loss = self.criterion(y_hat, y)

        return {'test_loss': loss}

    def test_end(self, outputs):
        avg_loss = torch.stack([x['test_loss'] for x in outputs]).mean()
        tensorboard_logs = {'test_loss': avg_loss}

        return {'avg_test_loss': avg_loss, 'log': tensorboard_logs}

    def configure_optimizers(self):
        return torch.optim.Adam(self.parameters(), lr=0.02)

    @pl.data_loader
    def train_dataloader(self):
        dataset = MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor())
        sampler = torch.utils.data.distributed.DistributedSampler(dataset)
        loader = DataLoader(dataset, sampler=sampler, batch_size=32)
        return loader

    @pl.data_loader
    def val_dataloader(self):
        dataset = MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor())
        sampler = torch.utils.data.distributed.DistributedSampler(dataset)
        loader = DataLoader(dataset, sampler=sampler, batch_size=32)
        return loader

    @pl.data_loader
    def test_dataloader(self):
        dataset = MNIST(os.getcwd(), train=False, download=True, transform=transforms.ToTensor())
        sampler = torch.utils.data.distributed.DistributedSampler(dataset)
        loader = DataLoader(dataset, sampler=sampler, batch_size=32)
        return loader

if __name__ == '__main__':
    args = parse_args()

    model = Net(input_dim=args.input_dim, output_dim=args.output_dim)

    trainer = Trainer(gpus=[2,3,4,5], distributed_backend='ddp')
    trainer.fit(model)
    trainer.test()
I got an error:
Traceback (most recent call last):
  File "example.py", line 68, in <module>
    mode='min'
TypeError: __init__() got an unexpected keyword argument 'save_best_only'
I try to set checkpoint_callback as False or pass a custom checkpoint callback, but the problem still exists.
from pytorch_lightning.callbacks import ModelCheckpoint

    checkpoint_callback = ModelCheckpoint(
        filepath='./cache/weights.ckpt',
        verbose=True,
        monitor='val_loss',
        mode='min'
    )

    trainer = Trainer(gpus=[2,3,4,5], checkpoint_callback=checkpoint_callback, distributed_backend='ddp')
Here are versions of my packages:

torch                         1.3.1
torchvision                   0.4.2
scikit-learn                  0.20.2
scipy                         1.2.1
numpy                         1.16.4
pytorch-ignite                0.4.0
pytorch-lightning             0.6.0

Thank you! 🙏