load_from_checkpoint vs trainer.test(..., ckpt_path=...)

[tall-josh]

Hi I'm trying to test a model at a given checkpoint but when using:

trainer.test(model, val_loader, ckpt_path=ckpt_path)

I notice the weights of the model are different each time I run the code.

If I use

model = model.load_from_checkpoint(ckpt_path)
trainer.test(model, val_loader)

I get the expected behaviour?

[rohitgr7]

I notice the weights of the model are different each time I run the code.

where are you checking the model weights?

[tall-josh]

I am checking the weights in the test_step callback

[awaelchli]

Which version of Lightning are you using here?

[tall-josh]

In [1]: import pytorch_lightning as pl

In [2]: pl.__version__
Out[2]: '1.4.8'

[tall-josh]

I'll try to reproduce the issue in a self-contained script.

[tall-josh]

Hey, thanks for the prompt response. I'm guessing what I have described is not the expected behaviour which means;

a. There is a bug in Lightning (not likely), or
b. I'm doing something wrong (very likely)

I have a bit on my plate right now. I have a workaround that will get me out of trouble for now. When I get some overhead I'll try to reproduce in a simple example. And post here, or post what I am doing wrong if I find it.

[awaelchli]

Hey @tall-josh
Yes, what you describe is not the expected behavior. Try to take this script and make a runnable example showing us the sequence of calls you make:

import os

import torch
from torch.utils.data import DataLoader, Dataset

from pytorch_lightning import LightningModule, Trainer


class RandomDataset(Dataset):
    def __init__(self, size, length):
        self.len = length
        self.data = torch.randn(length, size)

    def __getitem__(self, index):
        return self.data[index]

    def __len__(self):
        return self.len


class BoringModel(LightningModule):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(32, 2)

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

    def training_step(self, batch, batch_idx):
        loss = self(batch).sum()
        self.log("train_loss", loss)
        return {"loss": loss}

    def validation_step(self, batch, batch_idx):
        loss = self(batch).sum()
        self.log("valid_loss", loss)

    def test_step(self, batch, batch_idx):
        loss = self(batch).sum()
        self.log("test_loss", loss)

    def configure_optimizers(self):
        return torch.optim.SGD(self.layer.parameters(), lr=0.1)


def run():
    train_data = DataLoader(RandomDataset(32, 64), batch_size=2)
    val_data = DataLoader(RandomDataset(32, 64), batch_size=2)
    test_data = DataLoader(RandomDataset(32, 64), batch_size=2)

    model = BoringModel()
    trainer = Trainer(
        default_root_dir=os.getcwd(),
        limit_train_batches=1,
        limit_val_batches=1,
        num_sanity_val_steps=0,
        max_epochs=1,
        enable_model_summary=False,
    )
    trainer.fit(model, train_dataloaders=train_data, val_dataloaders=val_data)
    trainer.test(model, dataloaders=test_data)


if __name__ == "__main__":
    run()