<p>As <strong>vijay m</strong> points out correctly, by changing the <code>dct_method</code> to "INTEGER_ACCURATE" you will get the same uint8 image using cv2 or tf. The problem indeed seems to be the resizing method. I also tried to force Tensorflow to use the same interpolation method than cv2 uses by default (bilinear) but the results are still different. This might be the case, because cv2 does the interpolation on integer values and TensorFlow converts to float before interpolating. But this is only a guess. If you plot the pixel-wise difference between the resized image by TF and cv2 you'll get the following historgram:</p>

<p><a href="https://i.stack.imgur.com/aUUXK.png" rel="noreferrer">Histrogramm of pixel-wise difference</a></p>

<p>As you can see, this looks pretty normal distributed. (Also I was surprised amount of pixel-wise difference). The problem of your accuracy drop could lie exactly here. In <a href="https://arxiv.org/pdf/1412.6572.pdf" rel="noreferrer">this paper</a> Goodfellow et al. describe the effect of adversarial examples and classification systems. This problem here is something similar I think. If the original weights you use for your network were trained using some input pipeline which gives the results of the cv2 functions, the image from the TF input pipeline is something like an adversarial example. </p>

<p>(See the image on page 3 at the top for an example...I can't post more than two links.)</p>

<p>So in the end I think if you want to use the original network weights for the same data they trained the network on, you should stay with a similar/same input pipeline. If you use the weights to finetune the network on your own data, this should not be of a big concern, because you retrain the classification layer to work with the new input images (from the TF pipeline).</p>

<p>And @ <strong>Ishant Mrinal</strong>: Please have a look at the code the OP provided in the GIST. He is aware of the difference of BGR (cv2) and RGB (TF) and is converting the images to the same color space.</p>
Differences between OpenCV image processing and tf.image processing
<p>I recently switched out using OpenCV for Tensorflow's <a href="https://www.tensorflow.org/api_docs/python/tf/image" rel="nofollow noreferrer">tf.image</a> module for image processing. However, my validation accuracy dropped around 10%.</p>
<p>I believe the issue is related to</p>
<ol>
<li>cv2.imread() vs. tf.image.decode_jpeg()</li>
<li>cv2.resize() vs. tf.image.resize_images()</li>
</ol>
<p>While these differences result in worse accuracy, the images seem to be human-indistinguishable when using plt.imshow(). For example, take Image #1 of the ImageNet Validation Dataset:</p>
<p><a href="https://i.stack.imgur.com/cJQAQ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/cJQAQ.png" alt="CV2 Image" /></a> <a href="https://i.stack.imgur.com/NyCsj.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/NyCsj.png" alt="enter image description here" /></a></p>
<p>First issue:</p>
<ul>
<li>cv2.imread() takes in a string and outputs a BGR 3-channel uint8 matrix</li>
<li>tf.image_decode_jpeg() takes in a string tensor and outputs an RGB 3-channel uint8 tensor.</li>
</ul>
<p>However, after converting the tf tensor to BGR format, there are very slight differences at many pixels in the image.</p>
<p>Using tf.image.decode_jpeg and then converting to BGR</p>
<pre><code>[[ 26  41  24 ...,  57  48  46]
 [ 36  39  36 ...,  24  24  29]
 [ 41  26  34 ...,  11  17  27]
 ..., 
 [ 71  67  61 ..., 106 105 100]
 [ 66  63  59 ..., 106 105 101]
 [ 64  66  58 ..., 106 105 101]]```
</code></pre>
<p>Using cv.imread</p>
<pre><code>[[ 26  42  24 ...,  57  48  48]
 [ 38  40  38 ...,  26  27  31]
 [ 41  28  36 ...,  14  20  31]
 ..., 
 [ 72  67  60 ..., 108 105 102]
 [ 65  63  58 ..., 107 107 103]
 [ 65  67  60 ..., 108 106 102]]```
</code></pre>
<p>Second issue:</p>
<ul>
<li>tf.image.resize_images() automatically converts a uint8 tensor to a float32 tensor, and seems to exacerbate the differences in pixel values.</li>
<li>I believe that tf.image.resize_images() and cv2.resize() are both</li>
</ul>
<p>tf.image.resize_images</p>
<pre><code>[[  26.           25.41850281   35.73127747 ...,   81.85855103
    59.45834351   49.82373047]
 [  38.33480072   32.90485001   50.90826797 ...,   86.28446198
    74.88543701   20.16353798]
 [  51.27312469   26.86172867   39.52401352 ...,   66.86851501
    81.12111664   33.37636185]
 ..., 
 [  70.59472656   75.78851318 
 45.48100662 ...,   70.18637085
    88.56777191   97.19295502]
 [  70.66964722   59.77249908   48.16699219 ...,   74.25527954
    97.58244324  105.20263672]
 [  64.93395996   59.72298431   55.17600632 ...,   77.28720856
    98.95108032  105.20263672]]```
</code></pre>
<p>cv2.resize</p>
<pre><code>[[ 36  30  34 ..., 102  59  43]
 [ 35  28  51 ...,  85  61  26]
 [ 28  39  50 ...,  59  62  52]
 ..., 
 [ 75  67  34 ...,  74  98 101]
 [ 67  59  43 ...,  86 102 104]
 [ 66  65  48 ...,  86 103 105]]```
</code></pre>
<p>Here's a <a href="https://gist.github.com/txizzle/0c1b5665a3cbad4bd4fc8a3afa424a86" rel="nofollow noreferrer">gist</a> demonstrating the behavior just mentioned. It includes the full code for how I am processing the image.</p>
<p>So my main questions are:</p>
<ul>
<li><strong>Why is the output of cv2.imread() and tf.image.decode_jpeg() different?</strong></li>
<li><strong>How are cv2.resize() and tf.image.resize_images() different if they use the same interpolation scheme?</strong></li>
</ul>
<p>Thank you!</p>