Different output from Libtorch C++ and pytorch
I'm using the same traced model in pytorch and libtorch but I'm getting different outputs.
Python Code:
import cv2
import numpy as np 
import torch
import torchvision
from torchvision import transforms as trans


# device for pytorch
device = torch.device('cuda:0')

torch.set_default_tensor_type('torch.cuda.FloatTensor')

model = torch.jit.load(&quot;traced_facelearner_model_new.pt&quot;)
model.eval()

# read the example image used for tracing
image=cv2.imread(&quot;videos/example.jpg&quot;)

test_transform = trans.Compose([
        trans.ToTensor(),
        trans.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])       

resized_image = cv2.resize(image, (112, 112))

tens = test_transform(resized_image).to(device).unsqueeze(0)
output = model(tens)
print(output)

C++ Code:
#include &lt;iostream&gt;
#include &lt;algorithm&gt; 
#include &lt;opencv2/opencv.hpp&gt;
#include &lt;torch/script.h&gt;


int main()
{
    try
    {
        torch::jit::script::Module model = torch::jit::load(&quot;traced_facelearner_model_new.pt&quot;);
        model.to(torch::kCUDA);
        model.eval();

        cv::Mat visibleFrame = cv::imread(&quot;example.jpg&quot;);

        cv::resize(visibleFrame, visibleFrame, cv::Size(112, 112));
        at::Tensor tensor_image = torch::from_blob(visibleFrame.data, { 1, visibleFrame.rows, 
                                                    visibleFrame.cols, 3 }, at::kByte);
        tensor_image = tensor_image.permute({ 0, 3, 1, 2 });
        tensor_image = tensor_image.to(at::kFloat);

        tensor_image[0][0] = tensor_image[0][0].sub(0.5).div(0.5);
        tensor_image[0][1] = tensor_image[0][1].sub(0.5).div(0.5);
        tensor_image[0][2] = tensor_image[0][2].sub(0.5).div(0.5);

        tensor_image = tensor_image.to(torch::kCUDA);
        std::vector&lt;torch::jit::IValue&gt; input;
        input.emplace_back(tensor_image);
        // Execute the model and turn its output into a tensor.
        auto output = model.forward(input).toTensor();
        output = output.to(torch::kCPU);
        std::cout &lt;&lt; &quot;Embds: &quot; &lt;&lt; output &lt;&lt; std::endl;

        std::cout &lt;&lt; &quot;Done!\n&quot;;
    }
    catch (std::exception e)
    {
        std::cout &lt;&lt; &quot;exception&quot; &lt;&lt; e.what() &lt;&lt; std::endl;
    }
}

The model gives (1x512) size output tensor as shown below.
Python output
tensor([[-1.6270e+00, -7.8417e-02, -3.4403e-01, -1.5171e+00, -1.3259e+00,

-1.1877e+00, -2.0234e-01, -1.0677e+00, 8.8365e-01, 7.2514e-01,

2.3642e+00, -1.4473e+00, -1.6696e+00, -1.2191e+00, 6.7770e-01,

...

-7.1650e-01, 1.7661e-01]], device=‘cuda:0’,
grad_fn=)

C++ output
Embds: Columns 1 to 8 -84.6285 -14.7203 17.7419 47.0915 31.8170 57.6813 3.6089 -38.0543


Columns 9 to 16 3.3444 -95.5730 90.3788 -10.8355 2.8831 -14.3861 0.8706 -60.7844

...

Columns 505 to 512 36.8830 -31.1061 51.6818 8.2866 1.7214 -2.9263 -37.4330 48.5854

[ CPUFloatType{1,512} ]

Using

Pytorch 1.6.0
Libtorch 1.6.0
Visual studio 2019
Windows 10
Cuda 10.1


before the final normalization, you need to scale your input to the range 0-1 and then carry on the normalization you are doing. convert to float and then divide by 255 should get you there. Here is the snippet I wrote, there might be some syntaax errors, that should be visible.
Try this :
#include &lt;iostream&gt;
#include &lt;algorithm&gt; 
#include &lt;opencv2/opencv.hpp&gt;
#include &lt;torch/script.h&gt;


int main()
{
    try
    {
        torch::jit::script::Module model = torch::jit::load(&quot;traced_facelearner_model_new.pt&quot;);
        model.to(torch::kCUDA);
        
        cv::Mat visibleFrame = cv::imread(&quot;example.jpg&quot;);

        cv::resize(visibleFrame, visibleFrame, cv::Size(112, 112));
        at::Tensor tensor_image = torch::from_blob(visibleFrame.data, {  visibleFrame.rows, 
                                                    visibleFrame.cols, 3 }, at::kByte);
        
        tensor_image = tensor_image.to(at::kFloat).div(255).unsqueeze(0);
        tensor_image = tensor_image.permute({ 0, 3, 1, 2 });
        ensor_image.sub_(0.5).div_(0.5);

        tensor_image = tensor_image.to(torch::kCUDA);
        // Execute the model and turn its output into a tensor.
        auto output = model.forward({tensor_image}).toTensor();
        output = output.cpu();
        std::cout &lt;&lt; &quot;Embds: &quot; &lt;&lt; output &lt;&lt; std::endl;

        std::cout &lt;&lt; &quot;Done!\n&quot;;
    }
    catch (std::exception e)
    {
        std::cout &lt;&lt; &quot;exception&quot; &lt;&lt; e.what() &lt;&lt; std::endl;
    }
}

I don't have access to a system to run this so if you face anything comment below.
