def _MaxPool3DGrad(op, grad):
return gen_nn_ops._max_pool3d_grad(op.inputs[0],
op.outputs[0],
grad,
ksize=op.get_attr("ksize"),
strides=op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def _MaxPool3DGrad(op, grad):
return gen_nn_ops._max_pool3d_grad(
op.inputs[0],
op.outputs[0],
grad,
ksize=op.get_attr("ksize"),
strides=op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format"))
def _MaxPool3DGradGradGrad(op, grad):
return (array_ops.zeros(shape=array_ops.shape(op.inputs[0]),
dtype=op.inputs[0].dtype),
array_ops.zeros(shape=array_ops.shape(op.inputs[1]),
dtype=op.inputs[1].dtype),
gen_nn_ops._max_pool3d_grad(op.inputs[0],
op.inputs[1],
grad,
op.get_attr("ksize"),
op.get_attr("strides"),
padding=op.get_attr("padding"),
data_format=op.get_attr("data_format")))
def _simple_lrp(self,R):
'''
LRP according to Eq(56) in DOI: 10.1371/journal.pone.0130140
'''
self.check_shape(R)
in_N, in_h, in_w, in_c, in_depth = self.input_tensor.get_shape().as_list()
Z = tf.nn.max_pool3d(self.input_tensor, ksize=self.pool_kernel, strides=self.pool_stride, padding='SAME') + 1e-9
S = self.R / Z
C = gen_nn_ops._max_pool3d_grad(self.input_tensor, Z, S, ksize=self.pool_kernel, strides=self.pool_stride, padding='SAME')
result = self.input_tensor*C
return result
def verifyValues(tensor_in_sizes,
stride,
rho_data=0.1,
padding='SAME',
dim=5,
max_density=1,
num_trials=3,
test_type=""):
if isinstance(stride, collections.Iterable):
strides = [1] + list(stride) + [1]
else:
strides = [1, stride, stride, stride, 1]
no_strides = [1, 1, 1, 1, 1]
[t1ind, t1val, t1sh] = sp.createRandomSparseTensor(rho_data,
tensor_in_sizes)
d1 = sp.sparse_to_dense(t1ind, t1val, t1sh)
print("strides: \n", strides)
print("input shape", tensor_in_sizes)
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.7
#reorder data and generate block index lookup table
with tf.device("/gpu:0"):
convd = sc_module.direct_sparse_data_conversion(t1ind, t1val, t1sh)
with tf.Session(config=config) as sess:
pd = sess.run(convd)
tf.reset_default_graph()
ts = 0
with tf.device("/gpu:0"):
approx_scskconv = sc_module.direct_sparse_max_pooling_kd(
pd.out_indices, pd.out_values, pd.out_shape,
pd.out_block_channel_mapping, strides, dim)
with tf.Session(config=config) as sess:
t6 = time.time()
sv3 = sess.run(approx_scskconv)
t5 = time.time()
for i in range(0, num_trials):
sess.run(approx_scskconv)
t6 = time.time()
ts = abs(t6 - t5) / max(num_trials, 1)
print("time approx sparse: ", ts)
tf.reset_default_graph()
td = 0
with tf.device("/gpu:0"):
pooling = tf.nn.max_pool3d(d1, strides, strides, "SAME")
with tf.Session(config=config) as sess:
t22 = time.time()
expected = sess.run(pooling)
t11 = time.time()
for i in range(0, num_trials):
sess.run(pooling)
t22 = time.time()
td = abs(t22 - t11) / max(num_trials, 1)
print("time dense gpu: ", td)
tf.reset_default_graph()
print("time ratio: ", ts / td)
[bp_ind, sv3_bp_val,
bp_sh] = sp.createRandomSparseTensor(1, [len(sv3.out_values)], 1, 9)
d3_ = sp.sparse1d_to_dense(sv3.out_indices, sv3_bp_val, sv3.out_shape,
sv3.out_block_channel_mapping[-1])
out_backprop_val = constant_op.constant(d3_)
t_bp1 = 0
with tf.Session(config=config) as sess:
with tf.device("/gpu:0"):
fbp = gen_nn_ops._max_pool3d_grad(d1, expected, out_backprop_val,
strides, strides, "SAME")
#fbp = nn_ops.conv3d_backprop_filter_v2(d1, filter_in_sizes, out_backprop_val, strides, padding)
res_bp1 = sess.run(fbp)
for i in range(num_trials):
t1 = time.time()
sess.run(fbp)
t2 = time.time()
t_bp1 = t_bp1 + t2 - t1
t_bp1 = t_bp1 / float(num_trials)
print("time bp1: ", t_bp1)
t_bp3 = 0
with tf.Session(config=config) as sess:
with tf.device("/gpu:0"):
fbp = sc_module.direct_sparse_max_pooling_kd_backprop(
pd.out_indices, pd.out_values, pd.out_shape,
pd.out_block_channel_mapping, sv3.out_indices, sv3.out_values,
sv3.out_shape, sv3.out_block_channel_mapping, sv3_bp_val,
strides, dim)
res_bp3 = sess.run(fbp)
for i in range(num_trials):
t1 = time.time()
sess.run(fbp)
t2 = time.time()
t_bp3 = t_bp3 + t2 - t1
t_bp3 = t_bp3 / float(num_trials)
print("time bp3: ", t_bp3)
print("bp ratio: ", t_bp1 / t_bp3)
return 0
bp_sig = sp.sparse1d_to_dense(pd.out_indices, res_bp3, pd.out_shape,
pd.out_block_channel_mapping[-1])
#print("dense bp ", res_bp1)
#print("sparse bp: ", bp_sig)
tsu = 0
with tf.device("/gpu:0"):
unpooling = sc_module.direct_sparse_unpooling_kd(
sv3.out_indices, sv3.out_values, sv3.out_shape,
sv3.out_block_channel_mapping, pd.out_indices, pd.out_shape,
pd.out_block_channel_mapping, strides, dim)
with tf.Session(config=config) as sess:
t6 = time.time()
sv4 = sess.run(unpooling)
t5 = time.time()
for i in range(0, num_trials):
sess.run(unpooling)
t6 = time.time()
tsu = abs(t6 - t5) / max(num_trials, 1)
print("time sparse unpooling: ", tsu)
tf.reset_default_graph()
'''print("sparse bp", bp_sig)
print("sv3 obcm", sv3.out_block_channel_mapping)
print("len", len(sv3.out_indices))
print("pd obcm", pd.out_block_channel_mapping)
print("len", len(pd.out_indices))
'''
t_bp4 = 0
with tf.Session(config=config) as sess:
with tf.device("/gpu:0"):
fbp = sc_module.direct_sparse_unpooling_kd_backprop(
sv3.out_indices, sv3.out_values, sv3.out_shape,
sv3.out_block_channel_mapping, pd.out_indices, pd.out_values,
pd.out_shape, pd.out_block_channel_mapping, res_bp3, strides,
dim)
res_bp4 = sess.run(fbp)
for i in range(num_trials):
t1 = time.time()
sess.run(fbp)
t2 = time.time()
t_bp4 = t_bp4 + t2 - t1
t_bp4 = t_bp4 / float(num_trials)
print("time bp3: ", t_bp4)
bp_unpool = sp.sparse1d_to_dense(sv3.out_indices, res_bp4, sv3.out_shape,
sv3.out_block_channel_mapping[-1])
#print("bp unpool", bp_unpool)
value3 = sp.sparse1d_to_dense(sv3.out_indices, sv3.out_values,
sv3.out_shape,
sv3.out_block_channel_mapping[-1])
#print("result sparse ", value3)
has_error = False
approx_cmp = expected.flatten()
approx = value3.flatten()
non_zero_count = 0
for i in range(len(approx_cmp)):
#if approx[i] == 0:
#approx_cmp[i] = 0
#else:
non_zero_count = non_zero_count + 1
print("entry count: ", non_zero_count)
error_cnt = 0
first_error = 0
correct_cnt = 0
for i in range(len(approx_cmp)):
if abs(approx_cmp[i] - approx[i]) > 1e-3:
#print("error: %d != %d " % (approx_cmp[i], approx[i]))
#print("at id ", i)
if has_error == False:
first_error = i
has_error = True
error_cnt = error_cnt + 1
elif approx[i] != 0:
correct_cnt = correct_cnt + 1
bp_sig_flat = bp_sig.flatten()
res_bp2_flat = res_bp1.flatten()
bp_i_error_cnt = 0
bp_i_correct_cnt = 0
for i in range(len(approx_cmp)):
if approx[i] != 0:
if bp_sig_flat[i] == res_bp2_flat[i]:
bp_i_correct_cnt = bp_i_correct_cnt + 1
else:
bp_i_error_cnt = bp_i_error_cnt + 1
p_flat = pd.out_values.flatten()
up_flat = sv4.flatten()
up_i_error_cnt = 0
up_i_correct_cnt = 0
for i in range(len(p_flat)):
if p_flat[i] <= up_flat[i]:
up_i_correct_cnt = up_i_correct_cnt + 1
else:
up_i_error_cnt = up_i_error_cnt + 1
if dim == 5:
up_bp_cor = 0
up_bp_err = 0
for batch in range(0, tensor_in_sizes[0]):
for channel in range(0, tensor_in_sizes[4]):
for x in range(
0,
int(ceil(
float(tensor_in_sizes[1]) / float(strides[1])))):
for y in range(
0,
int(
ceil(
float(tensor_in_sizes[2]) /
float(strides[2])))):
for z in range(
0,
int(
ceil(
float(tensor_in_sizes[3]) /
float(strides[3])))):
id_in = (batch, x, y, z, channel)
inval = value3.item(id_in)
max_out_val = -100000000000
for dx in range(0, strides[1]):
xout = x * strides[1] + dx
if xout >= d1.shape[1]:
continue
for dy in range(0, strides[2]):
yout = y * strides[2] + dy
if yout >= d1.shape[2]:
continue
for dz in range(0, strides[3]):
zout = z * strides[3] + dz
if zout >= d1.shape[3]:
continue
id_out = (batch, xout, yout, zout,
channel)
out_val = d1.item(id_out)
max_out_val = max(max_out_val, out_val)
if max_out_val == -100000000000 or max_out_val == inval:
up_bp_cor = up_bp_cor + 1
else:
up_bp_err = up_bp_err + 1
print("total number of pooling corrects: ", up_bp_cor)
print("total number of pooling errors: ", up_bp_err)
if dim == 5:
up_bp_cor = 0
up_bp_err = 0
tmp = np.copy(bp_unpool)
for batch in range(0, tensor_in_sizes[0]):
for channel in range(0, tensor_in_sizes[4]):
for x in range(
0,
int(ceil(
float(tensor_in_sizes[1]) / float(strides[1])))):
for y in range(
0,
int(
ceil(
float(tensor_in_sizes[2]) /
float(strides[2])))):
for z in range(
0,
int(
ceil(
float(tensor_in_sizes[3]) /
float(strides[3])))):
id_in = (batch, x, y, z, channel)
inval = bp_unpool.item(id_in)
sum_out_val = 0
for dx in range(0, strides[1]):
xout = x * strides[1] + dx
if xout >= bp_sig.shape[1]:
continue
for dy in range(0, strides[2]):
yout = y * strides[2] + dy
if yout >= bp_sig.shape[2]:
continue
for dz in range(0, strides[3]):
zout = z * strides[3] + dz
if zout >= bp_sig.shape[3]:
continue
id_out = (batch, xout, yout, zout,
channel)
out_val = bp_sig.item(id_out)
sum_out_val = sum_out_val + out_val
if sum_out_val == inval:
up_bp_cor = up_bp_cor + 1
else:
up_bp_err = up_bp_err + 1
tmp[id_in] = sum_out_val
#print("pbup: ", bp_unpool)
#print("epbup: ", tmp)
print("total number of unpooling bp corrects: ", up_bp_cor)
print("total number of unpooling bp errors: ", up_bp_err)
print("total number of non-zero corrects: ", correct_cnt)
print("total number of bpi corrects: ", bp_i_correct_cnt)
print("total number of unpooling corrects: ", up_i_correct_cnt)
if has_error:
print("total number of errors: ", error_cnt)
print("first error: ", first_error)
if bp_i_error_cnt > 0:
print("total number of bpi errors: ", bp_i_error_cnt)
if up_i_error_cnt > 0:
print("total number of up errors: ", up_i_error_cnt)
return 1
print("OK")
return 0
