Merge pull request #743 from chrishkchris/precision
Fix some GPU test cases by precision setting
diff --git a/python/singa/autograd.py b/python/singa/autograd.py
index 0a24984..08cce9a 100644
--- a/python/singa/autograd.py
+++ b/python/singa/autograd.py
@@ -4427,7 +4427,7 @@
def backward(self, dy):
"""
backward of Cast
- Args:f
+ Args:
dy (CTensor), gradient tensor.
Raises:
AssertionError: no backward function for this operator
@@ -4698,6 +4698,80 @@
return CosSim()(a, b)[0]
+class UpSample(Operator):
+ """
+ UpSample operator following ONNX Operator Schemas
+ https://github.com/onnx/onnx/blob/master/docs/Operators.md#upsample
+
+ Example usage::
+ data = [[[[1, 2],
+ [3, 4],]]]
+
+ # nearest
+ scales = [1.0, 1.0, 2.0, 3.0]
+ output = [[[[1, 1, 1, 2, 2, 2],
+ [1, 1, 1, 2, 2, 2],
+ [3, 3, 3, 4, 4, 4],
+ [3, 3, 3, 4, 4, 4],]]]
+ """
+
+ def __init__(self, mode, scales):
+ """
+ Args:
+ scales (list[int]): The scale array along each dimension. It takes
+ value greater than or equal to 1.
+ """
+ super(UpSample, self).__init__()
+ self.scales = scales
+ self.mode = mode.lower()
+ if self.mode != "nearest":
+ assert False, "only support nearest mode."
+
+ def forward(self, x):
+ if isinstance(self.scales, np.ndarray):
+ self.scales = self.scales.tolist()
+ else:
+ self.scales = list(self.scales)
+ self.x_shape = list(x.shape())
+ for axis, s in zip(range(len(self.scales)), self.scales):
+ s = int(s)
+ if s == 1:
+ continue
+ x = x.Repeat([s, ], axis)
+ return x
+
+ def backward(self, dy):
+ x_shape = self.x_shape.copy()
+ for axis, s_1, s_2 in zip(range(len(self.scales))[::-1], self.scales[::-1], x_shape[::-1]):
+ s_1 = int(s_1)
+ if s_1 != 1:
+ duplic = s_1
+ dxs = []
+ for i in range(s_2):
+ tmp_tensor = None
+ for j in range(duplic):
+ if not tmp_tensor:
+ tmp_tensor = singa.SliceOn(dy, i*duplic+j, i*duplic+j+1, axis)
+ else:
+ tmp_tensor += singa.SliceOn(dy, i*duplic+j, i*duplic+j+1, axis)
+ dxs.append(tmp_tensor)
+ dxs = singa.VecTensor(dxs)
+ dy = singa.ConcatOn(dxs, axis)
+ dy = singa.Reshape(dy, self.x_shape)
+ return dy
+
+def upsample(x, mode, scales):
+ """
+ Produces a upsample operator
+ Args:
+ x (Tensor): input tensor.
+ scales (list[int]): The scale array along each dimension. It takes
+ value greater than or equal to 1.
+ Returns:
+ the output Tensor.
+ """
+ return UpSample(mode, scales)(x)[0]
+
''' alias for Operator and Layers
'''
Operation = Operator
diff --git a/python/singa/sonnx.py b/python/singa/sonnx.py
index b3ca899..9c68fdd 100755
--- a/python/singa/sonnx.py
+++ b/python/singa/sonnx.py
@@ -1110,6 +1110,7 @@
'Reshape': 'Reshape',
'Slice': 'Slice',
'Clip': 'Clip',
+ 'Upsample': 'UpSample',
'Gemm': 'layer.Gemm', # layer
'BatchNormalization': 'layer.BatchNorm2d', # layer
'Conv': 'layer.Conv2d', # layer
@@ -1148,9 +1149,25 @@
'Conv': '_create_conv',
'MaxPool': '_create_max_avg_pool',
'AveragePool': '_create_max_avg_pool',
+ 'Upsample': '_create_upsample',
}
@classmethod
+ def _create_upsample(cls, onnx_node, operator, opset_version=_opset_version):
+ """
+ get the UpSample operator from onnx node
+ Args:
+ onnx_node (OnnxNode): a given onnx node
+ operator (Operator Class): a singa operator class
+ opset_version (int): the opset version
+ Returns:
+ singa operator instance
+ """
+ mode = utils.force_unicode(onnx_node.getattr("mode", None))
+ onnx_node.set_attr_inputs(onnx_node.inputs[1], 'scales')
+ return operator(mode, None)
+
+ @classmethod
def _create_cast(cls, onnx_node, operator, opset_version=_opset_version):
"""
get the Cast operator from onnx node
diff --git a/test/python/test_operation.py b/test/python/test_operation.py
index 41d7034..b1604ea 100755
--- a/test/python/test_operation.py
+++ b/test/python/test_operation.py
@@ -3083,6 +3083,36 @@
def test_cossim_gpu(self):
self.cossim_helper(gpu_dev)
+ def upsample_helper(self, dev):
+ X = np.array([[[
+ [1, 2],
+ [3, 4],
+ ]]], dtype=np.float32)
+ x = tensor.from_numpy(X)
+ x.to_device(dev)
+
+ scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+ y_t = np.array([[[
+ [1, 1, 1, 2, 2, 2],
+ [1, 1, 1, 2, 2, 2],
+ [3, 3, 3, 4, 4, 4],
+ [3, 3, 3, 4, 4, 4],
+ ]]],dtype=np.float32)
+ dy = tensor.from_numpy(y_t)
+ dy.to_device(dev)
+
+ y = autograd.upsample(x, "nearest", scales)
+ dx = y.creator.backward(dy.data)
+ np.testing.assert_array_almost_equal(tensor.to_numpy(y), y_t)
+ self.check_shape(dx.shape(), tuple(X.shape))
+
+ def test_upsample_cpu(self):
+ self.upsample_helper(cpu_dev)
+
+ @unittest.skipIf(not singa_wrap.USE_CUDA, 'CUDA is not enabled')
+ def test_upsample_gpu(self):
+ self.upsample_helper(gpu_dev)
+
if __name__ == '__main__':
unittest.main()
