Cannot reproduce the results from the paper - Problem with InPlaceABNSync?

[alexandrewillame]

I cannot reproduce the results from the paper. I suspect it is a problem with the InPlaceABNSync function.

The code as-is does not work on my computer (either on Windows 11 or WSL = Linux), some problem with Ninja / C++ compiling. I want to get rid of the code that uses Ninja which is the code of the InPlaceABNSync function.

I thus modified the AugmentCE2P to bypass InPlaceABNSync which is the module that uses Ninja/cpp functions.. I modified networks/AugmentCE2P.py, line 21 and 23:

from modules import InPlaceABNSync

BatchNorm2d = functools.partial(InPlaceABNSync, activation='none')

I deleted these lines and replaced them by the following:

from torch.nn import BatchNorm2d
def InPlaceABNSync(input):
    return BatchNorm2d(input)

Thus supposedly using the standard torch BatchNorm2d instead of the InPlaceABNSync version, assuming InPlaceABNSync is just a BatchNorm2d function with no activation layer.

The code run without error, but if we take the demo example (demo/demo.jpg) using the lip dataset using the latest checkpoint (exp-schp-201908261155-lip.pth)t, it is far from what is expected:

Instead of:

The source image is indeed exactly the same, there is thus a difference somewhere in the code.

Can somebody help / show how to make the code work properly without the use of InPlaceABNSync?

Thank you,

[madanmanit]

Did you find a solution? I too am using a windows 11 env

[maxlegrec1]

You can define a custom module that combines BatchNorm2d with LeakyReLU like this:

from torch.nn import BatchNorm2d
from torch.nn import functional as F


def InPlaceABNSync(input):
    return LeakyReLUBatchNorm2d(input)


class LeakyReLUBatchNorm2d(nn.BatchNorm2d):
    def __init__(self, num_features, negative_slope=0.01, **kwargs):
        super(LeakyReLUBatchNorm2d, self).__init__(num_features, **kwargs)
        self.negative_slope = negative_slope

    def forward(self, input):
        # Apply BatchNorm2d as usual
        normalized = super().forward(input)
        # Apply LeakyReLU
        return F.leaky_relu(normalized, negative_slope=self.negative_slope)