def call(self, inputs):
self.grid = ops.convert_to_tensor(self.grid, dtype=self.dtype)
self.bounds = ops.convert_to_tensor(self.bounds, dtype=self.dtype)
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
queryPoints_ind = ((cast(shape(self.grid)[1:3], dtype=self.dtype)) -
constant(1.0)) * (inputs - self.bounds[0]) / (
self.bounds[1] - self.bounds[0])
if common_shapes.rank(inputs) == 2:
queryPoints_ind = expand_dims(queryPoints_ind, 0)
output = interpolate(self.grid, queryPoints_ind)
if common_shapes.rank(inputs) == 2:
output = array_ops.reshape(output, (array_ops.shape(output)[1], ) +
(array_ops.shape(output)[2], ))
return output
def call(self, inputs, params=None):
if params[self.name + '/kernel:0'] is None:
return super(layers.Dense, self).call(inputs)
else:
kernel = params.get(self.name + '/kernel:0')
bias = params.get(self.name + '/bias:0')
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.shape.as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
# Cast the inputs to self.dtype, which is the variable dtype. We do not
# cast if `should_cast_variables` is True, as in that case the variable
# will be automatically casted to inputs.dtype.
if not self._mixed_precision_policy.should_cast_variables:
inputs = math_ops.cast(inputs, self.dtype)
outputs = gen_math_ops.mat_mul(inputs, kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
raise ValueError(
'mpusim_fc_base only supports tensors of rank <= 2')
else:
outputs = mpu_sim_mat_mul_lib.mpu_sim_mat_mul(
inputs,
self.kernel,
activations_datatype_size_byte=self.
activations_datatype_size_byte,
weights_datatype_size_byte=self.weights_datatype_size_byte,
results_datatype_size_byte=self.results_datatype_size_byte,
systolic_array_height=self.systolic_array_height,
systolic_array_width=self.systolic_array_width,
activation_fifo_depth=self.activation_fifo_depth,
accumulator_array_height=self.accumulator_array_height,
log_file_output_dir=self.log_file_output_dir,
model_name=self.model_name)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs)
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
if rank is not 2:
raise ValueError('`ParisLaw` only takes "rank 2" inputs.')
output = self.kernel[0] * (inputs**self.kernel[1])
return output
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
w_norm = 0.5 * tf.linalg.norm(self.kernel, axis=0)**2
x_norm = tf.expand_dims(0.5 * tf.linalg.norm(inputs, axis=-1)**2,
axis=-1)
outputs = gen_math_ops.add(outputs, -w_norm)
outputs = gen_math_ops.add(outputs, -x_norm)
outputs /= (self.sigma**2)
return self.activation(outputs)
def sn_fully_connected(inputs,
num_outputs,
scope,
activation_fn=tf.nn.relu,
weights_regularizer=None):
with tf.variable_scope(scope):
input_dim = inputs.shape[-1].value
assert input_dim
kernel = sn_kernel(shape=(input_dim, num_outputs), scope='kernel')
bias = tf.get_variable(name='bias',
shape=(num_outputs, ),
initializer=tf.initializers.zeros)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = tf.tensordot(inputs, kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
# if not context.executing_eagerly():
# shape = inputs.get_shape().as_list()
# output_shape = shape[:-1] + [self.units]
# outputs.set_shape(output_shape)
else:
# Cast the inputs to self.dtype, which is the variable dtype. We do not
# cast if `should_cast_variables` is True, as in that case the variable
# will be automatically casted to inputs.dtype.
outputs = tf.matmul(inputs, kernel)
outputs = tf.nn.bias_add(outputs, bias)
if activation_fn is not None:
return activation_fn(outputs) # pylint: disable=not-callable
else:
return outputs
def call(self, inputs, reverse=False):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
kernel = self.kernel if not reverse else self.kernel_inverse
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, kernel, [[rank - 1], [0]])
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, kernel)
if reverse:
return outputs
batch_size = tf.cast(tf.shape(inputs)[0], tf.float32)
sequence_length = tf.cast(tf.shape(inputs)[1], tf.float32)
# tf.logdet only works on Hermitian positive def matrices, maybe try tf.slogdet?
log_det_W = batch_size * sequence_length * tf.log(
tf.linalg.det(self.kernel))
return outputs, log_det_W
def call(self, inputs, params=None):
if params[self.name + '/kernel:0'] is None:
return super(layers.Dense, self).call(inputs)
else:
kernel = params.get(self.name + '/kernel:0')
bias = params.get(self.name + '/bias:0')
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
"""
Apply a clipped matrix multiplication and sign activation function.
Backpropagation is made on non-clipped and without sign expression.
:param inputs:
:return:
"""
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = _clippedTensorDot(self.deviceName, inputs, self.kernel,
rank)
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = _clippedMatMul(self.deviceName, inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation == tf.nn.softmax:
outputs = self.activation(outputs) # pylint: disable=not-callable
#We must not clip the activation on either -1 or 1, because the activation is the softmax!!
return outputs
#We must clip the activation on either -1 or 1, use of sign function:
with tf.device(self.deviceName):
with ops.name_scope("signOp", [outputs]) as scope:
return tf.add(
tf.stop_gradient(tf.sign(outputs) - outputs),
outputs,
name=scope
) #Use of stop_gradient enable rigorous backpropagation here
def call(self, inputs):
quant_kernel = tf.quantization.fake_quant_with_min_max_vars(
self.kernel,
min=tf.math.reduce_min(self.kernel),
max=tf.math.reduce_max(self.kernel),
num_bits=8,
narrow_range=False,
name=None)
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, quant_kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, quant_kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = tf.convert_to_tensor(inputs, dtype=self.dtype)
with tf.name_scope("actQ"):
tf.compat.v1.summary.histogram('prebinary_activations', inputs)
if self.bits is not None:
inputs = self.actQ(inputs, float(self.bits))
else:
inputs = self.actQ(inputs)
tf.compat.v1.summary.histogram('binary_activations', inputs)
with tf.name_scope("weightQ"):
kernel = self.weightQ(self.kernel)
tf.compat.v1.summary.histogram('weights', self.kernel)
tf.compat.v1.summary.histogram('binary_weights', kernel)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = tf.tensordot(inputs, kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = tf.matmul(inputs, kernel)
if self.use_bias:
outputs = tf.nn.bias_add(outputs, self.bias)
if self.use_act and self.activation is not None:
outputs = self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs, training=None):
if self.lr_mul == 1.0:
W = self.coeff * self.kernel
else:
@custom_gradient
def lr_multiplier(x):
y = array_ops.identity(x)
def grad(dy):
return dy * self.lr_mul
return y, grad
W = lr_multiplier(self.coeff * self.kernel)
training = self._get_training_value(training)
# Update singular vector by power iteration
W_T = array_ops.transpose(W)
u = array_ops.identity(self.u)
for i in range(self.power_iter):
v = nn_impl.l2_normalize(math_ops.matmul(u, W)) # 1 x filters
u = nn_impl.l2_normalize(math_ops.matmul(v, W_T))
# Spectral Normalization
sigma_W = math_ops.matmul(math_ops.matmul(u, W), array_ops.transpose(v))
# Backprop doesn't need in power iteration
sigma_W = array_ops.stop_gradient(sigma_W)
W_bar = W / array_ops.squeeze(sigma_W)
# Assign new singular vector
training_value = tf_utils.constant_value(training)
if training_value is not False:
def u_update():
def true_branch():
return self._assign_singular_vector(self.u, u)
def false_branch():
return self.u
return tf_utils.smart_cond(training, true_branch, false_branch)
self.add_update(u_update)
# normal Dense using W_bar
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, W_bar, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.shape.as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
inputs = math_ops.cast(inputs, self._compute_dtype)
outputs = math_ops.mat_mul(inputs, W_bar)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
if self.use_bias:
raise ValueError()
rank = common_shapes.rank(inputs)
outputs = standard_ops.tensordot(inputs, self.kernel,
[[rank - 1], [0]])
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
if common_shapes.rank(inputs) is not 2:
raise ValueError(
'`StressIntensityRange` only takes "rank 2" inputs.')
output = gen_math_ops.mul(self.kernel * inputs[:, 1],
gen_math_ops.sqrt(np.pi * inputs[:, 0]))
output = array_ops.reshape(output, (array_ops.shape(output)[0], 1))
# outputs should be (None, 1), so it is still rank = 2
return output
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
if common_shapes.rank(inputs) is not 2:
raise ValueError('`WalkerModel` only takes "rank 2" inputs.')
sig = 1 / (1 + gen_math_ops.exp(self.kernel[0] * inputs[:, 1]))
gamma = sig * self.kernel[1]
C = self.kernel[2] / ((1 - inputs[:, 1])**(self.kernel[3] *
(1 - gamma)))
output = C * (inputs[:, 0]**self.kernel[3])
output = array_ops.reshape(output, (array_ops.shape(output)[0], 1))
return output
def call(self, inputs):
rank = common_shapes.rank(inputs)
# This is same as linear output of a normal dense layer but
# it's not used as layer output. Instead, this value (key) is
# used to calculate the actual weights.
key = standard_ops.tensordot(inputs, self.key_kernel, [[rank - 1], [0]])
if self.use_key_bias:
key = key + self.key_bias
return super(PolymorphicDense, self).call(key, inputs)
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = clippedTensorDot(inputs, self.kernel, rank,self.bias,self.rate, self.rateInhib)
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = clippedMatMul(inputs, self.kernel,self.bias,self.rate, self.rateInhib)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
hadamard_product = tf.math.multiply(self.mask, self.kernel)
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
output = tf.linalg.matmul(inputs, hadamard_product)
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
output.set_shape(output_shape)
else:
if not self._mixed_precision_policy.should_cast_variables:
inputs = math_ops.cast(inputs, self.dtype)
output = tf.linalg.matmul(inputs, hadamard_product)
if self.use_bias:
output = K.bias_add(output, self.bias, data_format=None)
# pass the result of the layer through the activ. function
output = self.activation(output)
return output
def fc_shared_weight(inputs,
vocab_size,
embeddings,
biases_initializer,
activation_fn=None):
with tf.variable_scope('fc_shared_weights'):
word_weight = tf.transpose(embeddings, (1, 0))
embedding_dim = embeddings.shape[-1].value
assert embedding_dim
input_dim = inputs.shape[-1].value
assert input_dim == embedding_dim
blank_weight = tf.get_variable(
name='blank_weight',
initializer=tf.initializers.random_normal(0.05),
dtype=tf.float32,
shape=(embedding_dim, 1))
weight = tf.concat([blank_weight, word_weight], axis=-1)
print("fc_shared_weight: {}, {}, {}".format(blank_weight, word_weight,
weight))
bias = tf.get_variable(name='bias',
initializer=biases_initializer,
shape=(vocab_size + 1, ),
dtype=tf.float32)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = tf.tensordot(inputs, weight, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
# if not context.executing_eagerly():
# shape = inputs.get_shape().as_list()
# output_shape = shape[:-1] + [self.units]
# outputs.set_shape(output_shape)
else:
# Cast the inputs to self.dtype, which is the variable dtype. We do not
# cast if `should_cast_variables` is True, as in that case the variable
# will be automatically casted to inputs.dtype.
outputs = tf.matmul(inputs, weight)
outputs = tf.nn.bias_add(outputs, bias)
if activation_fn is not None:
return activation_fn(outputs) # pylint: disable=not-callable
else:
return outputs
def call(self, inputs, training=None):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
# Newly added lines for targeted dropout
if training is None:
training = K.learning_phase()
if (training):
if (self.targeted_dropout_type == "weight"):
dropped_kernel = targeted_weight_dropout(
self.kernel, self.targeted_dropout_rate, self.dropout_rate,
K.learning_phase())
elif (self.targeted_dropout_type == "unit"):
dropped_kernel = targeted_unit_dropout(
self.kernel, self.targeted_dropout_rate, self.dropout_rate,
K.learning_phase())
else:
raise ValueError("Should be of 'weight' or 'unit'")
if rank > 2:
# Broadcasting is required for the inputs.
if (training):
outputs = standard_ops.tensordot(inputs, dropped_kernel,
[[rank - 1], [0]])
else:
outputs = standard_ops.tensordot(inputs, self.kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
if (training):
outputs = gen_math_ops.mat_mul(inputs, dropped_kernel)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel, [[rank - 1], [0]])
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
scale = self.scale / (tf.norm(self.kernel, 2, 0) + 1e-8)
outputs = outputs * scale
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs)
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel, [[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.shape.as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
# Cast the inputs to self.dtype, which is the variable dtype. We do not
# cast if `should_cast_variables` is True, as in that case the variable
# will be automatically casted to inputs.dtype.
if not self._mixed_precision_policy.should_cast_variables:
inputs = math_ops.cast(inputs, self.dtype)
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
softmax_kernel = self.kernel * tf.nn.softmax(
logits=tf.abs(self.kernel) / self.temperature,
axis=0,
)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(
inputs,
# that's the actual change
softmax_kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.shape.as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
# Cast the inputs to self.dtype, which is the variable dtype. We do not
# cast if `should_cast_variables` is True, as in that case the variable
# will be automatically casted to inputs.dtype.
if not self._mixed_precision_policy.should_cast_variables:
inputs = math_ops.cast(inputs, self.dtype)
outputs = gen_math_ops.mat_mul(
inputs,
# that's the actual change
softmax_kernel,
)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs)
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.activation is not None:
outputs = self.activation(outputs) # pylint: disable=not-callable
if self.verbose > 0:
print(outputs.get_shape(), 'outputs before masking')
if self.leaky_inputs:
if self.verbose > 0:
print('performing mask op')
self.full_outputs = outputs
# outputs_d = {}
# for dim in range(outputs.get_shape()[1]):
outputs_1d = tf.reshape(tf.transpose(outputs), [
-1,
],
name='outputs_1d_')
# mask_array = self.mask_array['key_' + str(dim)]
if self.verbose > 0:
print('mask_array', self.mask_array.get_shape())
mask_array_1d = tf.reshape(self.mask_array, [
-1,
],
name='mask_ph_1d_')
if self.verbose > 0:
print('mask_array_1d', mask_array_1d.get_shape())
mask = tf.math.greater(mask_array_1d,
tf.constant(0.0),
name='masking_op_')
outputs = outputs_1d[mask]
outputs = tf.expand_dims(outputs, axis=1)
# outputs_d['val_' + str(dim)] = outputs
if self.verbose > 0:
print(outputs.get_shape(), 'shape of output after masking')
return outputs
else:
self.full_outputs = outputs
if self.verbose > 0:
print(outputs.get_shape(), 'shape of output without masking')
return outputs
def call(self, inputs):
inputs = ops.convert_to_tensor(inputs, dtype=self.dtype)
enable_quantop_dense = int(os.getenv('ENABLE_QUANTOP_DENSE', 0))
if enable_quantop_dense == 1:
inputs_qs = quantemu_ops.quantize_emu(
inputs,
data_format='unknown',
allocate_copy=int(os.getenv('QUANTEMU_ALLOCATE_COPY_INPUTS',
0)),
data_type=int(os.getenv('QUANTEMU_DENSE_DATA_TYPE', 0)),
precision=int(os.getenv('QUANTEMU_PRECISION_DENSE_INPUTS',
23)),
exponent_bits=int(os.getenv('QUANTEMU_EXPBITS', 5)),
round_mode=int(os.getenv('QUANTEMU_RMODE_INPUTS', 0)))
kernel_qs = quantemu_ops.quantize_emu(
self.kernel,
data_format='unknown',
allocate_copy=int(
os.getenv('QUANTEMU_ALLOCATE_COPY_FILTERS', 0)),
data_type=int(os.getenv('QUANTEMU_DENSE_DATA_TYPE', 0)),
precision=int(os.getenv('QUANTEMU_PRECISION_DENSE_FILTERS',
23)),
exponent_bits=int(os.getenv('QUANTEMU_EXPBITS', 5)),
round_mode=int(os.getenv('QUANTEMU_RMODE_FILTERS', 0)))
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs_qs, kernel_qs,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs_qs, kernel_qs)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
else: # No quantization
rank = common_shapes.rank(inputs)
if rank > 2:
# Broadcasting is required for the inputs.
outputs = standard_ops.tensordot(inputs, self.kernel,
[[rank - 1], [0]])
# Reshape the output back to the original ndim of the input.
if not context.executing_eagerly():
shape = inputs.get_shape().as_list()
output_shape = shape[:-1] + [self.units]
outputs.set_shape(output_shape)
else:
outputs = gen_math_ops.mat_mul(inputs, self.kernel)
if self.use_bias:
outputs = nn.bias_add(outputs, self.bias)
if self.activation is not None:
return self.activation(outputs) # pylint: disable=not-callable
return outputs
