Validation step isn't being ran 
❓ Questions and Help
What is your question?
I have been trying to get the trainer to call the validation_step function but it doesn't seem to ever get called.  I assume I am missing something obvious but have looking at the tutorials and docs I haven't been able to find the obvious.  The code for the model and trainer are below.  What might I be missing?  Thank you for the help!
Code
class SegModel(pl.LightningModule):
    def __init__(self, batch_size, lr):
        super(SegModel, self).__init__()
        self.batch_size = batch_size
        self.learning_rate = lr
        self.net = UNet(num_classes=1)
        self.transform = transforms.Compose([
            transforms.ToTensor()
        ])
        self.trainset = Stacker(input_images, truth_images, transform=self.transform)
        self.validset = Stacker(input_images, truth_images, transform=self.transform)
        self.testset = Stacker(input_images, truth_images, transform=self.transform)
    
    def forward(self, x):
        return self.net(x)
    
    def training_step(self, batch, batch_nb):
        img, mask = batch
        img = img.float()
        mask = mask.long()
        out = self.forward(img)
        loss_val = dice_loss(mask, out)
        return {'loss': loss_val, 'log': {'train_loss': loss_val}}
    
    def validation_step(self, batch, batch_nb):
        print("RUNNING VALIDATION")
        img, mask = batch
        img = img.float()
        mask = mask.long()
        out = self.forward(img)
        loss_val = dice_loss(mask, out)
        return {'val_loss': loss_val, 
                'val_dice': dice(out, mask),
                'val_iou': IoU(out, mask)
               }
    
    def test_step(self, batch, batch_nb):
        img, mask = batch
        img = img.float()
        mask = mask.long()
        out = self.forward(img)
        loss_val = dice_loss(mask, out)
        return {'test_loss': loss_val, 
                'test_dice': dice(out, mask),
                'test_iou': IoU(out, mask)
               }
    
    def validation_end(self, outputs):
        if len(outputs)==0: return {}
        val_loss_mean = torch.stack([x['val_loss'] for x in outputs]).mean()
        val_dice_mean = torch.stack([x['val_dice'] for x in outputs]).mean()
        val_iou_mean = torch.stack([x['val_iou'] for x in outputs]).mean()
        return {'val_loss': val_loss_mean,
                'log': {
                    'val_loss': val_loss_mean,
                    'val_dice': val_dice_mean,
                    'val_iou': val_iou_mean
                }}

    def test_end(self, outputs):
        if len(outputs)==0: return {}
        test_loss_mean = torch.stack([x['test_loss'] for x in outputs]).mean()
        test_dice_mean = torch.stack([x['test_dice'] for x in outputs]).mean()
        test_iou_mean = torch.stack([x['test_iou'] for x in outputs]).mean()
        print(test_dice_mean, test_iou_mean)
        return {'test_loss': test_loss_mean,
                'log': {
                    'test_loss': test_loss_mean,
                    'test_dice': test_dice_mean,
                    'test_iou': test_iou_mean
                }}
    
    def configure_optimizers(self):
        opt = torch.optim.Adam(self.net.parameters(), lr=self.learning_rate)
        sch = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=10)
        return [opt], [sch]

    @pl.data_loader
    def train_dataloader(self):
        return DataLoader(self.trainset, batch_size=self.batch_size, shuffle=True)

    @pl.data_loader
    def valid_dataloader(self):
        return DataLoader(self.validset, batch_size=self.batch_size, shuffle=False)
      
    @pl.data_loader
    def test_dataloader(self):
        return DataLoader(self.testset, batch_size=self.batch_size, shuffle=False)

model = SegModel(1, 0.001)

trainer = pl.Trainer(
    gpus=[0], 
    early_stop_callback=None, 
    max_epochs=40,
    check_val_every_n_epoch=1,
)

trainer.fit(model)

What's your environment?

OS: Windows
Packaging: conda
Version: 0.6.1