def test_no_biases(self):
cases = [
# N, K, C, H, W, kH, kW
(1, 4, 5, 7, 8, 3, 3),
(4, 8, 1, 7, 8, 3, 2),
(1, 1, 2, 3, 5, 1, 4),
]
for case in cases:
N, K, C, H, W, kH, kW = case
input = np.random.rand(N, C, H, W).astype(np.float32)
filters = np.random.rand(C, K, kH, kW).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.deconvolution_2d(h, filters)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = self._deconvolution_2d(input, filters,
np.zeros(K, dtype=np.float32),
(1, 1), (0, 0))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_tanh_default_output(self):
cases = [
ParameterSet(2, 10, 3, 20, 15)
]
for case in cases:
input = self._make_input(case)
hidden = self._make_hidden(case)
weights = self._make_weights(case)
bias = self._make_bias(case)
def build_network(network):
h = network.add_input(
"input", turret.DataType.FLOAT,
turret.Dimensions.CHW(
case.batch_size, case.seq_len, case.data_size))
h_hidden = network.add_input(
"hidden", turret.DataType.FLOAT,
turret.Dimensions.CHW(
case.batch_size, case.num_layers, case.hidden_size))
h, _ = L.rnn_tanh_v2(h, case.seq_len, weights, bias,
hidden_state=h_hidden)
network.mark_output("output", h)
actual = execute_inference(
{"input": input, "hidden": hidden}, build_network)
expect = unidirection_rnn(
input, hidden, weights, bias, lambda x: np.tanh(x))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_min_ternary(self):
N, C, H, W = 3, 5, 7, 11
input0 = np.random.rand(N, C, H, W).astype(np.float32)
input1 = np.random.rand(N, C, H, W).astype(np.float32)
input2 = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h2 = network.add_input("input2", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.min(h0, h1, h2)
network.mark_output("output", h)
actual = execute_inference(
{
"input0": input0,
"input1": input1,
"input2": input2
}, build_network)
expect = np.minimum(np.minimum(input0, input1), input2)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_stride_and_padding(self):
cases = [
# N, K, C, H, W, kH, kW, sH, sW, pH, pW
(1, 4, 5, 7, 8, 3, 3, 3, 1, 0, 0),
# ( 4, 8, 1, 7, 8, 3, 2, 1, 1, 2, 4),
(1, 1, 2, 3, 5, 1, 4, 2, 2, 1, 2),
]
for case in cases:
N, K, C, H, W, kH, kW, sH, sW, pH, pW = case
input = np.random.rand(N, C, H, W).astype(np.float32)
filters = np.random.rand(C, K, kH, kW).astype(np.float32)
biases = np.random.rand(K).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.deconvolution_2d(h,
filters,
biases,
stride=(sH, sW),
padding=(pH, pW))
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = self._deconvolution_2d(input, filters, biases, (sH, sW),
(pH, pW))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_gamma_beta(self):
N, C, H, W = 9, 3, 20, 30
eps = 2e-5
input = np.random.rand(N, C, H, W).astype(np.float32)
input = np.ones((N, C, H, W), dtype=np.float32)
mean = np.random.rand(C).astype(np.float32)
var = np.random.rand(C).astype(np.float32)
gamma = np.random.rand(C).astype(np.float32)
beta = np.random.rand(C).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.batch_normalization(h,
mean,
var,
gamma=gamma,
beta=beta,
eps=eps)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
bcast_mean = np.broadcast_to(mean, (W, H, C)).transpose()
bcast_std = np.broadcast_to(var, (W, H, C)).transpose()**0.5
bcast_gamma = np.broadcast_to(gamma, (W, H, C)).transpose()
bcast_beta = np.broadcast_to(beta, (W, H, C)).transpose()
expect = bcast_gamma * (input - bcast_mean) / (bcast_std +
eps) + bcast_beta
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default_output(self):
cases = [ParameterSet(2, 10, 3, 20, 15)]
for case in cases:
input = self._make_input(case)
hidden = self._make_hidden(case)
cell = self._make_cell(case)
fwd_weights = self._make_weights(case)
bwd_weights = self._make_weights(case)
fwd_bias = self._make_bias(case)
bwd_bias = self._make_bias(case)
def build_network(network):
h = network.add_input(
"input", turret.DataType.FLOAT,
turret.Dimensions.CHW(case.seq_len, case.batch_size,
case.data_size))
h_hidden = network.add_input(
"hidden", turret.DataType.FLOAT,
turret.Dimensions.CHW(case.num_layers, case.batch_size,
case.hidden_size * 2))
h_cell = network.add_input(
"cell", turret.DataType.FLOAT,
turret.Dimensions.CHW(case.num_layers, case.batch_size,
case.hidden_size * 2))
h, _, _ = L.blstm(h,
case.seq_len,
fwd_weights,
bwd_weights,
fwd_bias,
bwd_bias,
hidden_state=h_hidden,
cell_state=h_cell)
network.mark_output("output", h)
actual = execute_inference(
{
"input": input,
"hidden": hidden,
"cell": cell
},
build_network,
max_batch_size=1)
t_input = input.transpose(0, 2, 1, 3)
t_hidden = hidden.transpose(0, 2, 1, 3)
t_cell = cell.transpose(0, 2, 1, 3)
t_expect = bidirection_lstm(t_input, t_hidden, t_cell, fwd_weights,
bwd_weights, fwd_bias, bwd_bias)
expect = t_expect.transpose(0, 2, 1, 3)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_sum(self):
N, C, H, W = 3, 5, 7, 11
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.reduce(h, turret.ReduceOperation.SUM, axes=(0, 1))
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.sum(input, axis=(1, 2), keepdims=False)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_neg(self):
N, C, H, W = 3, 5, 7, 11
input0 = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.neg(h)
network.mark_output("output", h)
actual = execute_inference({"input0": input0}, build_network)
expect = -input0
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_axis(self):
N, C, H, W = 3, 4, 7, 9
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.concat([h, h], axis=1)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.concatenate((input, input), axis=2)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_repeat(self):
N, C, H, W = 10, 13, 11, 17
repeats, axis = 4, 1
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.repeat(h, repeats, axis=axis)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.repeat(input, repeats, axis=axis + 1)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N = 5
C, H, W = 3, 20, 30
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.shuffle(h, (1, 2, 0))
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.transpose(input, (0, 2, 3, 1))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_shift_uniform(self):
N, C, H, W = 3, 4, 7, 9
input = np.random.rand(N, C, H, W).astype(np.float32)
shift = np.random.rand(1).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.scale(h, turret.ScaleMode.UNIFORM, shift=shift)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = input + shift
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N, C, H, W = 5, 13, 17, 19
k = 3
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.top_k(h, turret.TopKOperation.MIN, k, 1)
network.mark_output("output", h[0])
actual = execute_inference({"input": input}, build_network)
expect = self._topk(input, k, 1)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N = 5
C_in, H_in, W_in = 3, 20, 30
C_out, H_out, W_out = 6, 5, 60
input = np.random.rand(N, C_in, H_in, W_in).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C_in, H_in, W_in))
h = L.reshape(h, turret.Dimensions.CHW(C_out, H_out, W_out))
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.reshape(input, (N, C_out, H_out, W_out))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N = 5
C, H, W = 3, 20, 30
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.leaky_relu(h, slope=0.5)
network.mark_output("output", h)
actual = execute_inference({"input": input.reshape((N, C, H, W))},
build_network)
expect = np.zeros((N, C, H, W), dtype=np.float32)
expect = np.maximum(input, input * 0.5)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_constant(self):
N, C, K, H, W = 5, 13, 17, 19, 23
data = np.random.rand(C, H, W).astype(np.float32)
indices = np.random.randint(0, C - 1, (N, K), dtype=np.int32)
def build_network(network):
d = network.add_constant(data, turret.Dimensions.CHW(C, H, W))
i = network.add_input(
"indices", turret.DataType.INT32,
turret.Dimensions(((K, turret.DimensionType.INDEX), )))
h = L.gather(d, i, 0)
network.mark_output("output", h)
actual = execute_inference({"indices": indices}, build_network)
expect = self._gather(np.broadcast_to(data, (N, C, H, W)), indices, 0)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_shift_elementwise(self):
N, C, H, W = 3, 4, 7, 9
input = np.random.rand(N, C, H, W).astype(np.float32)
shift = np.random.rand(C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.scale(h, turret.ScaleMode.ELEMENTWISE, shift=shift)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = np.copy(input)
for i in range(N):
expect[i] += shift
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N, C, H, W = 5, 3, 20, 30
window_size = (3, 2)
stride = (2, 3)
padding = (0, 1)
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.average_pooling_2d(h, window_size, stride, padding)
network.mark_output("output", h)
actual = execute_inference({"input": input.reshape((N, C, H, W))},
build_network)
expect = average_pooling_2d(input, window_size, stride, padding)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_negative(self):
N, C, H, W = 3, 5, 20, 30
pad_width = (-1, -2)
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.pad(h, pad_width)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
Hp = H + 2 * pad_width[0]
Wp = W + 2 * pad_width[1]
top, left = -pad_width[0], -pad_width[1]
expect = input[:, :, top:top + Hp, left:left + Wp]
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_different(self):
N, C0, C1, H, W = 3, 4, 7, 7, 9
input0 = np.random.rand(N, C0, H, W).astype(np.float32)
input1 = np.random.rand(N, C1, H, W).astype(np.float32)
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.CHW(C0, H, W))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.CHW(C1, H, W))
h = L.concat([h0, h1])
network.mark_output("output", h)
actual = execute_inference({
"input0": input0,
"input1": input1
}, build_network)
expect = np.concatenate((input0, input1), axis=1)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_split_c(self):
N, C, H, W = 3, 10, 13, 11
sections = [2, 5, 6, 8]
input = np.random.rand(N, C, H, W).astype(np.float32)
for i in range(len(sections) + 1):
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.split(h, sections, axis=0)
network.mark_output("output", h[i])
actual = execute_inference({"input": input}, build_network)
expect = np.split(input, sections, axis=1)[i]
self.assertEqual(expect.shape, actual.shape)
if not np.allclose(expect, actual):
print(expect)
print(actual)
self.assertTrue(np.allclose(expect, actual))
def test_sum(self):
N, C, H, W = 3, 4, 7, 9
input0 = np.random.rand(N, C, H, W).astype(np.float32)
input1 = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.elementwise(h0, h1, turret.ElementWiseOperation.SUM)
network.mark_output("output", h)
actual = execute_inference({
"input0": input0,
"input1": input1
}, build_network)
expect = input0 + input1
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_div(self):
N, C, H, W = 3, 5, 7, 11
input0 = np.random.rand(N, C, H, W).astype(np.float32)
input1 = np.random.rand(N, C, H, W).astype(np.float32) + 0.5
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.div(h0, h1)
network.mark_output("output", h)
actual = execute_inference({
"input0": input0,
"input1": input1
}, build_network)
expect = input0 / input1
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_positive(self):
N, C, H, W = 3, 5, 20, 30
pad_width = (1, 2)
input = np.random.rand(N, C, H, W).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
h = L.pad(h, pad_width)
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
Hp = H + 2 * pad_width[0]
Wp = W + 2 * pad_width[1]
top, left = pad_width
expect = np.zeros((N, C, Hp, Wp), dtype=np.float32)
expect[:, :, top:H + top, left:W + left] = input
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_no_biases(self):
N, K, C = 5, 10, 100
input = np.random.rand(N, C).astype(np.float32)
weights = np.random.rand(K, C).astype(np.float32)
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.CHW(1, 1, C))
h = L.fully_connected(h, weights)
network.mark_output("output", h)
actual = execute_inference({"input": input.reshape((N, 1, 1, C))},
build_network)
expect = np.zeros((N, K), dtype=np.float32)
for i in range(N):
for k in range(K):
for c in range(C):
expect[i, k] += input[i, c] * weights[k, c]
expect = expect.reshape((N, K, 1, 1))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
N, C, K = 5, 3, 20
input = np.random.rand(N, C, K).astype(np.float32)
bounds = np.broadcast_to(
np.asarray([[[10], [15], [20]]], dtype=np.int32), (N, C, 1))
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT,
turret.Dimensions.HW(C, K))
b = network.add_input("bounds", turret.DataType.INT32,
turret.Dimensions.HW(C, 1))
h = L.ragged_softmax(h, b)
network.mark_output("output", h)
actual = execute_inference({
"input": input,
"bounds": bounds
}, build_network)
expect = self._ragged_softmax(input, bounds)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_default(self):
# AxB * BxC => AxC
N, A, B, C = 5, 31, 23, 37
input0 = np.random.rand(N, A, B).astype(np.float32)
input1 = np.random.rand(N, B, C).astype(np.float32)
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.HW(A, B))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.HW(B, C))
h = L.matrix_multiply(h0, False, h1, False)
network.mark_output("output", h)
actual = execute_inference({
"input0": input0,
"input1": input1
}, build_network)
expect = self._matrix_multiply(input0, input1)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_2d_indices(self):
N, C, K1, K2, H, W = 5, 13, 17, 19, 23, 29
data = np.random.rand(N, C, H, W).astype(np.float32)
indices = np.random.randint(0, H - 1, (N, K1, K2), dtype=np.int32)
def build_network(network):
d = network.add_input("data", turret.DataType.FLOAT,
turret.Dimensions.CHW(C, H, W))
i = network.add_input(
"indices", turret.DataType.INT32,
turret.Dimensions(((K1, turret.DimensionType.INDEX),
(K2, turret.DimensionType.INDEX))))
h = L.gather(d, i, 1)
network.mark_output("output", h)
actual = execute_inference({
"data": data,
"indices": indices
}, build_network)
expect = self._gather(data, indices, 1)
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_transposed(self):
# BxA^T * CxB^T => AxC
N, A, B, C = 5, 31, 23, 37
input0 = np.random.rand(N, B, A).astype(np.float32)
input1 = np.random.rand(N, C, B).astype(np.float32)
def build_network(network):
h0 = network.add_input("input0", turret.DataType.FLOAT,
turret.Dimensions.HW(B, A))
h1 = network.add_input("input1", turret.DataType.FLOAT,
turret.Dimensions.HW(C, B))
h = L.matrix_multiply(h0, True, h1, True)
network.mark_output("output", h)
actual = execute_inference({
"input0": input0,
"input1": input1
}, build_network)
expect = self._matrix_multiply(input0.transpose((0, 2, 1)),
input1.transpose((0, 2, 1)))
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))
def test_thru(self):
N, C, H, W = 5, 10, 30, 40
io_dims = turret.Dimensions.CHW(C, H, W)
input = np.random.rand(N, C, H, W).astype(np.float32)
test = self
class ThruPlugin(turret.PluginBase):
@classmethod
def module_name(cls):
return "thru"
def serialize(self, stream):
pass
@classmethod
def deserialize(cls, stream):
return cls()
def get_num_outputs(self):
return 1
def get_output_dimensions(self, in_dims):
test.assertEqual(1, len(in_dims))
test.assertEqual(io_dims, in_dims[0])
return [io_dims]
def configure(self, in_dims, out_dims, max_batch_size):
test.assertEqual(1, len(in_dims))
test.assertEqual(io_dims, in_dims[0])
test.assertEqual(1, len(out_dims))
test.assertEqual(io_dims, out_dims[0])
def initialize(self):
return 0
def terminate(self):
pass
def get_workspace_size(self, max_batch_size):
return 0
def enqueue(self, batch_size, inputs, outputs, workspace, stream):
test.assertEqual(N, batch_size)
n = batch_size * io_dims.size
func = _THRU_MODULE.get_function("thru")
func(outputs[0],
inputs[0],
block=(1, 1, 1),
grid=(n, 1, 1),
stream=stream)
return 0
def build_network(network):
h = network.add_input("input", turret.DataType.FLOAT, io_dims)
h = L.plugin(h, ThruPlugin())
network.mark_output("output", h)
actual = execute_inference({"input": input}, build_network)
expect = input
self.assertEqual(expect.shape, actual.shape)
self.assertTrue(np.allclose(expect, actual))