def test_cputensor_dot():
Y = ng.make_axis(length=2)
M = ng.make_axis(length=1)
N = ng.make_axis(length=3)
np_a = np.array([[1, 2, 3]], dtype=np.float32)
np_b = np.array([[1, 2], [2, 3], [3, 4]], dtype=np.float32)
np_c = np.dot(np_a, np_b)
a = ng.constant(np_a, [M, N]).named('a')
b = ng.constant(np_b, [N, Y]).named('b')
c = ng.dot(a, b)
with executor(c) as ex:
result = ex()
assert np.array_equal(result, np_c)
python类array_equal()的实例源码
def test_cputensor_multiply_constant():
"""TODO."""
M = ng.make_axis(length=1)
N = ng.make_axis(length=3)
np_a = np.array([[1, 2, 3]], dtype=np.float32)
np_c = np.multiply(np_a, 2)
a = ng.constant(np_a, [M, N])
b = ng.constant(2)
c = ng.multiply(a, b)
with executor(c) as ex:
result = ex()
print(result)
assert np.array_equal(result, np_c)
def test_cputensor_mlp():
"""TODO."""
D = ng.make_axis(length=3)
H = ng.make_axis(length=2)
N = ng.make_axis(length=1)
np_x = np.array([[1, 2, 3]], dtype=np.float32)
np_w = np.array([[1, 1], [1, 1], [1, 1]], dtype=np.float32)
np_b = np.array([1, 2], dtype=np.float32)
np_c = np.dot(np_x, np_w) + np_b
x = ng.constant(np_x, [N, D])
w = ng.constant(np_w, [D, H])
b = ng.constant(np_b, [H])
wx = ng.dot(x, w)
c = wx + b
with executor(c) as ex:
result = ex()
print(result)
print(np_c)
assert np.array_equal(result, np_c)
def test_idempotent_axes_a():
"""
Test test axes transformations with autodiff, case a, reference test
"""
with ExecutorFactory() as ex:
axes = ng.make_axes([ng.make_axis(3), ng.make_axis(1)])
w = ng.variable(axes, initial_value=np.ones((3, 1)))
result = w + w
result = ng.cast_axes(result, axes)
cost = ng.sum(result, reduction_axes=axes)
grad = ng.deriv(cost, w)
grad_comp = ex.executor(grad)
cost_comp = ex.executor(cost)
cost_comp_val = cost_comp()
grad_comp_val = grad_comp()
grad_comp_np = np.ones((3, 1)) * 2.
assert cost_comp_val == 6.0
assert np.array_equal(grad_comp_val, grad_comp_np)
def test_idempotent_axes_b():
"""
Test test axes transformations with autodiff, case b, with broadcast applied
to the same tensor
"""
with ExecutorFactory() as ex:
axes = ng.make_axes([ng.make_axis(3), ng.make_axis(1)])
w = ng.variable(axes, initial_value=np.ones((3, 1)))
l = ng.broadcast(w, axes)
r = ng.broadcast(w, axes)
result = ng.add(l, r)
result = ng.cast_axes(result, axes)
cost = ng.sum(result, reduction_axes=axes)
grad = ng.deriv(cost, w)
grad_comp = ex.executor(grad)
cost_comp = ex.executor(cost)
assert cost_comp() == 6.0
assert np.array_equal(grad_comp(), np.ones((3, 1)) * 2.)
def test_rolling_window(input_seq, batch_size, seq_len, strides):
# This test checks if the rolling window works
# We check if the first two samples in each batch are strided by strides
# Truncate input sequence such that last section that doesn't fit in a batch
# is thrown away
input_seq = input_seq[:seq_len * batch_size * (len(input_seq) // seq_len // batch_size)]
data_array = {'X': input_seq,
'y': np.roll(input_seq, axis=0, shift=-1)}
time_steps = seq_len
it_array = SequentialArrayIterator(data_arrays=data_array, time_steps=time_steps,
stride=strides, batch_size=batch_size, tgt_key='y',
shuffle=False)
for idx, iter_val in enumerate(it_array):
# Start of the array needs to be time_steps * idx
assert np.array_equal(iter_val['X'][0, strides:time_steps],
iter_val['X'][1, :time_steps - strides])
assert np.array_equal(iter_val['y'][0, strides:time_steps],
iter_val['y'][1, :time_steps - strides])
def test_np_layout_shuffle():
# set up
bsz = 8
C, H, W, N = 3, 28, 28, bsz
C, R, S, K = 3, 5, 5, 32
# image dim-shuffle
np_tf_image = np.random.randn(N, H, W, C)
np_ng_image = np_layout_shuffle(np_tf_image, "NHWC", "CDHWN")
np_tf_image_reverse = np_layout_shuffle(np_ng_image, "CDHWN", "NHWC")
assert np.array_equal(np_tf_image, np_tf_image_reverse)
# filter dim-shuffle
np_tf_weight = np.random.randn(R, S, C, K)
np_ng_weight = np_layout_shuffle(np_tf_weight, "RSCK", "CTRSK")
np_tf_weight_reverse = np_layout_shuffle(np_ng_weight, "CTRSK", "RSCK")
assert np.array_equal(np_tf_weight, np_tf_weight_reverse)
def test_reduce_max_keepdims():
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ReduceMax', data), np.max(data, keepdims=True))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0,)),
np.max(data, keepdims=True, axis=(0,)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(1,)),
np.max(data, keepdims=True, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(2,)),
np.max(data, keepdims=True, axis=(2,)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 1)),
np.max(data, keepdims=True, axis=(0, 1)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 2)),
np.max(data, keepdims=True, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(1, 2)),
np.max(data, keepdims=True, axis=(1, 2)))
assert np.array_equal(import_and_compute('ReduceMax', data, axes=(0, 1, 2)),
np.max(data, keepdims=True, axis=(0, 1, 2)))
def test_reduce_min():
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ReduceMin', data), np.min(data, keepdims=True))
assert np.array_equal(import_and_compute('ReduceMin', data, keepdims=0),
np.min(data, keepdims=False))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(1,)),
np.min(data, keepdims=True, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(1,), keepdims=0),
np.min(data, keepdims=False, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 2)),
np.min(data, keepdims=True, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 2), keepdims=0),
np.min(data, keepdims=False, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 1, 2)),
np.min(data, keepdims=True, axis=(0, 1, 2)))
assert np.array_equal(import_and_compute('ReduceMin', data, axes=(0, 1, 2), keepdims=0),
np.min(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_mean():
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ReduceMean', data), np.mean(data, keepdims=True))
assert np.array_equal(import_and_compute('ReduceMean', data, keepdims=0),
np.mean(data, keepdims=False))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(1,)),
np.mean(data, keepdims=True, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(1,), keepdims=0),
np.mean(data, keepdims=False, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 2)),
np.mean(data, keepdims=True, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 2), keepdims=0),
np.mean(data, keepdims=False, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 1, 2)),
np.mean(data, keepdims=True, axis=(0, 1, 2)))
assert np.array_equal(import_and_compute('ReduceMean', data, axes=(0, 1, 2), keepdims=0),
np.mean(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_sum():
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ReduceSum', data), np.sum(data, keepdims=True))
assert np.array_equal(import_and_compute('ReduceSum', data, keepdims=0),
np.sum(data, keepdims=False))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(1,)),
np.sum(data, keepdims=True, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(1,), keepdims=0),
np.sum(data, keepdims=False, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 2)),
np.sum(data, keepdims=True, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 2), keepdims=0),
np.sum(data, keepdims=False, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 1, 2)),
np.sum(data, keepdims=True, axis=(0, 1, 2)))
assert np.array_equal(import_and_compute('ReduceSum', data, axes=(0, 1, 2), keepdims=0),
np.sum(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_prod():
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ReduceProd', data), np.prod(data, keepdims=True))
assert np.array_equal(import_and_compute('ReduceProd', data, keepdims=0),
np.prod(data, keepdims=False))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(1,)),
np.prod(data, keepdims=True, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(1,), keepdims=0),
np.prod(data, keepdims=False, axis=(1,)))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 2)),
np.prod(data, keepdims=True, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 2), keepdims=0),
np.prod(data, keepdims=False, axis=(0, 2)))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 1, 2)),
np.prod(data, keepdims=True, axis=(0, 1, 2)))
assert np.array_equal(import_and_compute('ReduceProd', data, axes=(0, 1, 2), keepdims=0),
np.prod(data, keepdims=False, axis=(0, 1, 2)))
def test_reduce_argmin():
def argmin(ndarray, axis, keepdims=False):
res = np.argmin(ndarray, axis=axis)
if keepdims:
res = np.expand_dims(res, axis=axis)
return res
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ArgMin', data, axis=0),
argmin(data, keepdims=True, axis=0))
assert np.array_equal(import_and_compute('ArgMin', data, axis=0, keepdims=0),
argmin(data, keepdims=False, axis=0))
assert np.array_equal(import_and_compute('ArgMin', data, axis=1),
argmin(data, keepdims=True, axis=1))
assert np.array_equal(import_and_compute('ArgMin', data, axis=1, keepdims=0),
argmin(data, keepdims=False, axis=1))
assert np.array_equal(import_and_compute('ArgMin', data, axis=2),
argmin(data, keepdims=True, axis=2))
assert np.array_equal(import_and_compute('ArgMin', data, axis=2, keepdims=0),
argmin(data, keepdims=False, axis=2))
def test_reduce_argmax():
def argmax(ndarray, axis, keepdims=False):
res = np.argmax(ndarray, axis=axis)
if keepdims:
res = np.expand_dims(res, axis=axis)
return res
data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32)
assert np.array_equal(import_and_compute('ArgMax', data, axis=0),
argmax(data, keepdims=True, axis=0))
assert np.array_equal(import_and_compute('ArgMax', data, axis=0, keepdims=0),
argmax(data, keepdims=False, axis=0))
assert np.array_equal(import_and_compute('ArgMax', data, axis=1),
argmax(data, keepdims=True, axis=1))
assert np.array_equal(import_and_compute('ArgMax', data, axis=1, keepdims=0),
argmax(data, keepdims=False, axis=1))
assert np.array_equal(import_and_compute('ArgMax', data, axis=2),
argmax(data, keepdims=True, axis=2))
assert np.array_equal(import_and_compute('ArgMax', data, axis=2, keepdims=0),
argmax(data, keepdims=False, axis=2))
def execute_calculation(operands, first_operand, const_executor):
iterations = len(operands) != 1
for i in operands:
_operands, expected_result, description = unpack_list(*i)
if description:
print("Description: ", description)
print("Operands: ", _operands)
print("Expected result: ", expected_result)
flex_result = const_executor(*_operands)
try:
print("flex_result: {0:.30}".format(float(flex_result)))
except TypeError:
# exception for arrays
np.set_printoptions(precision=30)
print("flex_result: {}".format(flex_result))
print("difference: ", flex_result - expected_result)
if iterations:
assert_allclose(flex_result, expected_result)
elif not isinstance(first_operand, np.ndarray):
assert flex_result == expected_result
else:
assert np.array_equal(flex_result, expected_result)
def _kshape(x, k, initial_clustering=None):
"""
>>> from numpy.random import seed; seed(0)
>>> _kshape(np.array([[1,2,3,4], [0,1,2,3], [-1,1,-1,1], [1,2,2,3]]), 2)
(array([0, 0, 1, 0]), array([[-1.2244258 , -0.35015476, 0.52411628, 1.05046429],
[-0.8660254 , 0.8660254 , -0.8660254 , 0.8660254 ]]))
"""
m = x.shape[0]
if initial_clustering is not None:
assert len(initial_clustering) == m, "Initial assigment does not match column length"
idx = initial_clustering
else:
idx = randint(0, k, size=m)
print(idx)
centroids = np.zeros((k,x.shape[1]))
distances = np.empty((m, k))
for _ in range(100):
old_idx = idx
for j in range(k):
centroids[j] = _extract_shape(idx, x, j, centroids[j])
for i in range(m):
for j in range(k):
distances[i,j] = 1 - max(_ncc_c(x[i], centroids[j]))
idx = distances.argmin(1)
if np.array_equal(old_idx, idx):
break
print(idx)
return idx, centroids
def _test_FileSourceType2000(self, format, subsize):
filename = self._tempfileName('source_2000_%s' % format)
complexData = format.startswith('C')
typecode = format[1]
dataFormat, dataType = self.TYPEMAP[typecode]
frames = 4
indata = [self._generateSourceData(format, subsize) for x in xrange(frames)]
hdr = bluefile.header(2000, format, subsize=subsize)
bluefile.write(filename, hdr, indata)
source = sb.FileSource(filename, midasFile=True, dataFormat=dataFormat)
sink = sb.DataSink()
source.connect(sink)
sb.start()
outdata = sink.getData(eos_block=True)
if complexData:
if format == 'CF':
outdata = numpy.array(outdata, dtype=numpy.float32).view(numpy.complex64)
outdata = numpy.reshape(outdata, (-1, subsize))
elif format == 'CD':
outdata = numpy.array(outdata, dtype=numpy.float64).view(numpy.complex128)
outdata = numpy.reshape(outdata, (-1, subsize))
else:
outdata = numpy.reshape(outdata, (-1, subsize, 2))
self.assertEqual(sink.sri().mode, 1)
else:
self.assertEqual(sink.sri().mode, 0)
self.assertTrue(numpy.array_equal(indata, outdata), msg="Format '%s' %s != %s" % (format, indata, outdata))
def merge_h5(in_filenames, out_filename):
""" Merge a list of h5 files """
out_h5 = h5.File(out_filename, 'a')
for filename in in_filenames:
if filename is None:
continue
in_h5 = h5.File(filename, 'r')
for name in in_h5.keys():
# If the dataset already exists,
# They must be equal or one must be all-zero.
if name in out_h5.keys():
src_data, dest_data = in_h5[name][()], out_h5[name][()]
if src_data.dtype.kind != 'S' and dest_data.dtype.kind != 'S':
# Both numeric
if not np.any(src_data):
# Source is all zero. Do nothing.
continue
elif not np.any(dest_data):
# Dest is all zero. Overwrite.
del out_h5[name]
h5.h5o.copy(in_h5.id, name, out_h5.id, name)
else:
# Both non-zero. Assert equality and do nothing.
assert np.array_equal(src_data, dest_data)
else:
# Either are non-numeric. Assert equality and do nothing.
assert np.array_equal(src_data, dest_data)
else:
# Only exists in src. Copy to dest.
h5.h5o.copy(in_h5.id, name, out_h5.id, name)
out_h5.flush()
out_h5.close()
def Verify(**kwargs):
msg, A, m, n, sd, q, eta, z, c, kappa = kwargs['msg'], kwargs['A'], kwargs['m'], kwargs['n'], kwargs['sd'], kwargs['q'], kwargs['eta'], kwargs['z'], kwargs['c'], kwargs['kappa']
B2 = eta*sd*np.sqrt(m)
reduced_prod = util.vector_to_Zq(np.matmul(A,z) + q*c, 2*q)
#print np.sqrt(z.dot(z)),B2
#print LA.norm(z,np.inf),float(q)/4
if np.sqrt(z.dot(z)) > B2 or LA.norm(z,np.inf) >= float(q)/4:
return False
if np.array_equal(c, hash_iterative(np.array_str(reduced_prod)+msg, n, kappa)):
return True
return False
def test_main(self):
# set up
mask = np.asarray([
[0, 0, 0, 1, 1],
[0, 0, 0, 1, 0],
[0, 1, 1, 1, 1],
[0, 0, 0, 0, 0]
])
mask2 = np.ones((4, 5))
masks = np.array([mask])
# test area
assert area(encode(mask)) == 7
assert area(encode(masks)[0]) == 7
assert np.array_equal(decode(encode(mask)), mask)
# test iou
assert isinstance(iou(encode(masks), encode(masks), [0]), np.ndarray)
assert iou(encode(mask), encode(mask), [0]) == 1
assert equal(iou(encode(np.array([mask, mask])), encode(mask2), [0]), 7.0/20).all()
# test toBbox
assert isinstance(toBbox(masks), np.ndarray)
assert np.equal(toBbox(encode(mask)), np.array([1, 0, 4, 3])).all()
assert np.equal(toBbox(encode(mask2)), np.array([0, 0, 5, 4])).all()
