def test_mnist_certification_conversion(art_warning, fix_get_mnist_data):
    """
    Assert that the re-convert method does not throw errors
    """

    class TestModel(torch.nn.Module):
        def __init__(self):
            super().__init__()

            self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
            self.conv1 = torch.nn.Conv2d(
                in_channels=1,
                out_channels=32,
                kernel_size=5,
                bias=True,
                stride=1,
            ).to(self.device)

            self.conv2 = torch.nn.Conv2d(
                in_channels=32,
                out_channels=32,
                kernel_size=5,
                bias=True,
                stride=1,
            ).to(self.device)

            self.fc1 = torch.nn.Linear(in_features=12800, out_features=100)
            self.fc2 = torch.nn.Linear(in_features=100, out_features=10)
            self.relu = torch.nn.ReLU()

        def forward(self, x):
            x = self.relu(self.conv1(x))
            x = self.relu(self.conv2(x))
            x = x.reshape(x.shape[0], -1)
            x = self.relu(self.fc1(x))

            return self.fc2(x)

    loss_fn = torch.nn.CrossEntropyLoss()
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    model = TestModel().to(device)

    box_model = PyTorchIBPClassifier(
        model=model, clip_values=(0, 1), loss=torch.nn.CrossEntropyLoss(), input_shape=(1, 28, 28), nb_classes=10
    )

    mnist_data = fix_get_mnist_data[0]
    mnist_labels = torch.tensor(fix_get_mnist_data[1]).to(device)
    box_model.model.set_forward_mode("concrete")
    for _ in range(5):
        preds = box_model.model.forward(mnist_data)
        loss = loss_fn(preds, mnist_labels)
        loss.backward()
        box_model.model.zero_grad()
        box_model.model.re_convert()

    Assert that the re-convert method does not throw errors
    
tests/estimators/certification/test_interval.py