Remove (most) Python 2 support from Python code (pytorch#35615)

Summary:
Pull Request resolved: pytorch#35615

Python 2 has reached end-of-life and is no longer supported by PyTorch.
Now we can clean up a lot of cruft that we put in place to support it.
These changes were all done manually, and I skipped anything that seemed
like it would take more than a few seconds, so I think it makes sense to
review it manually as well (though using side-by-side view and ignoring
whitespace change might be helpful).

Test Plan: CI

Differential Revision: D20842886

Pulled By: dreiss

fbshipit-source-id: 8cad4e87c45895e7ce3938a88e61157a79504aed

Author: dreiss

benchmarks/fastrnns/profile.py

@@ -7,8 +7,6 @@
 
 from .runner import get_nn_runners
 
-PY3 = sys.version_info >= (3, 0)
-
 
 def run_rnn(name, rnn_creator, nloops=5,
             seqLength=100, numLayers=1, inputSize=512, hiddenSize=512,
@@ -60,9 +58,8 @@ def system(command):
                          stderr=subprocess.PIPE, shell=True)
     output, err = p.communicate()
     rc = p.returncode
-    if PY3:
-        output = output.decode("ascii")
-        err = err.decode("ascii")
+    output = output.decode("ascii")
+    err = err.decode("ascii")
     return rc, output, err
 
 

caffe2/python/ideep/conv_op_test.py

@@ -158,152 +158,6 @@ def test_depthwise_convolution(self, batch_size, gc, dc):
             print(np.max(np.abs(Y2 - Y0)))
             self.assertTrue(False)
 
-    @unittest.skipIf(sys.version_info.major > 2, "broken in python 3")
-    @given(stride=st.integers(1, 3),
-           pad=st.integers(0, 3),
-           kernel=st.integers(3, 5),
-           size=st.integers(8, 10),
-           input_channels=st.integers(1, 3),
-           output_channels=st.integers(1, 5),
-           batch_size=st.integers(1, 3),
-           use_bias=st.booleans(),
-           **mu.gcs)
-    def test_int8_convolution(self, stride, pad, kernel, size,
-                             input_channels, output_channels,
-                             batch_size, use_bias, gc, dc):
-        X = np.random.rand(
-            batch_size, input_channels, size, size).astype(np.float32) - 0.5
-        w = np.random.rand(
-                output_channels, input_channels, kernel, kernel) .astype(np.float32) - 0.5
-        b = np.random.rand(output_channels).astype(np.float32) - 0.5
-
-        old_ws_name = workspace.CurrentWorkspace()
-        workspace.SwitchWorkspace("_device_check_", True)
-        conv_fp32 = core.CreateOperator(
-            "Conv",
-            ["X_fp32", "w_fp32", "b_fp32"] if use_bias else ["X_fp32", "w_fp32"],
-            ["Y_fp32"],
-            stride=stride,
-            pad=pad,
-            kernel=kernel,
-            training_mode=0,
-            device_option=dc[0],
-        )
-        workspace.FeedBlob('X_fp32', X, dc[0])
-        workspace.FeedBlob('w_fp32', w, dc[0])
-        workspace.FeedBlob('b_fp32', b, dc[0])
-        workspace.RunOperatorOnce(conv_fp32)
-        Y = workspace.FetchBlob('Y_fp32')
-
-        workspace.ResetWorkspace()
-
-        Y_absmax = np.array([np.absolute(Y).max()]).astype(np.float32)
-        if Y.min() >= 0:
-            Y_scale = Y_absmax / 0xFF
-            Y_zero_point = 0
-        else:
-            Y_scale = Y_absmax / 0x7F
-            Y_zero_point = 128
-
-        X_absmax = np.array([np.absolute(X).max()]).astype(np.float32)
-        if X.min() >= 0:
-            X_scale = X_absmax / 0xFF
-            X_zero_point = 0
-        else:
-            X_scale = X_absmax / 0x7F
-            X_zero_point = 128
-
-        w_absmax = np.array([np.absolute(w[i, ...]).max() for i in range(w.shape[0])]).astype(np.float32)
-        w_scale = w_absmax / 0x7F
-        w_zero_point = 128
-        w = np.transpose(w, (0, 2, 3, 1)).astype(np.float32)
-        w_bytes = np.rint([w[i, ...] / w_scale[i] for i in range(w.shape[0])]).astype(np.int8) + w_zero_point
-
-        w_filler = core.CreateOperator(
-            "Int8GivenTensorFill",
-            [], ["w"],
-            shape=w.shape,
-            values=w_bytes.astype(np.uint8).tobytes(),
-            Y_zero_point=w_zero_point,
-            Y_scales=w_scale,
-            device_option=dc[1],
-        )
-
-        b_scale = w_scale * X_scale
-        b_zero_point = 0
-        b_bytes = np.rint([b[i] / b_scale[i] for i in range(b.shape[0])]).astype(np.int32)
-        b_filler = core.CreateOperator(
-            "Int8GivenIntTensorFill",
-            [], ["b"],
-            shape=b.shape,
-            values=b_bytes,
-            Y_zero_point=b_zero_point,
-            Y_scales=b_scale,
-            device_option=dc[1],
-        )
-
-        sw2nhwc = core.CreateOperator(
-            "NCHW2NHWC",
-            ["X"],
-            ["X_nhwc"],
-            device_option=dc[1]
-        )
-
-        quantize_X = core.CreateOperator(
-            "Int8Quantize",
-            ["X_nhwc"],
-            ["X_quantized"],
-            engine="DNNLOWP",
-            device_option=dc[1],
-            Y_zero_point=X_zero_point,
-            Y_scale=X_scale[0],
-        )
-
-        conv = core.CreateOperator(
-            "Int8Conv",
-            ["X_quantized", "w", "b"] if use_bias else ["X_quantized", "w"],
-            ["Y_quantized"],
-            stride=stride,
-            pad=pad,
-            kernel=kernel,
-            engine="DNNLOWP",
-            device_option=dc[1],
-            Y_zero_point=Y_zero_point,
-            Y_scale=Y_scale[0],
-        )
-
-        dequantize_Y = core.CreateOperator(
-            "Int8Dequantize",
-            ["Y_quantized"],
-            ["Y_nhwc"],
-            engine="DNNLOWP",
-            device_option=dc[1],
-        )
-
-        sw2nchw = core.CreateOperator(
-            "NHWC2NCHW",
-            ["Y_nhwc"],
-            ["Y_out"],
-            device_option=dc[1]
-        )
-
-        net = caffe2_pb2.NetDef()
-        net.op.extend([w_filler, b_filler, sw2nhwc, quantize_X, conv, dequantize_Y, sw2nchw])
-
-        workspace.FeedBlob("X", X, dc[1])
-        workspace.RunNetOnce(net)
-        Y_out = workspace.FetchBlob("Y_out")
-
-        MSE = np.square(np.subtract(Y, Y_out)).mean()
-        if MSE > 0.005:
-            print(Y.flatten())
-            print(Y_out.flatten())
-            print(np.max(np.abs(Y_out - Y)))
-            print("MSE", MSE)
-            self.assertTrue(False)
-
-        workspace.SwitchWorkspace(old_ws_name)
-
 
 
 if __name__ == "__main__":