def __init__(self, name, input_shape, output_dim, hidden_sizes,
conv_filters, conv_filter_sizes, conv_strides, conv_pads, hidden_nonlinearity, output_nonlinearity,
hidden_W_init=L.xavier_init, hidden_b_init=tf.zeros_initializer,
output_W_init=L.xavier_init, output_b_init=tf.zeros_initializer,
input_var=None, input_layer=None):
with tf.variable_scope(name):
if input_layer is not None:
l_in = input_layer
l_hid = l_in
elif len(input_shape) == 3:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
elif len(input_shape) == 2:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
input_shape = (1,) + input_shape
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
else:
l_in = L.InputLayer(shape=(None,) + input_shape, input_var=input_var, name="input")
l_hid = l_in
for idx, conv_filter, filter_size, stride, pad in zip(
xrange(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_hid = L.Conv2DLayer(
l_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
)
l_hid = L.flatten(l_hid, name="conv_flatten")
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
)
l_out = L.DenseLayer(
l_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
)
self._l_in = l_in
self._l_out = l_out
self._input_var = l_in.input_var
def _make_subnetwork(self,
input_layer,
dim_output,
hidden_sizes,
output_nonlinearity=tf.sigmoid,
hidden_nonlinearity=tf.nn.tanh,
name="pred_network",
conv_filters=None,
conv_filter_sizes=None,
conv_strides=None,
conv_pads=None,
input_shape=None):
if conv_filters is not None:
input_layer = L.reshape(input_layer, ([0], ) + input_shape,
name="reshape_input")
prob_network = ConvNetwork(input_shape=input_shape,
output_dim=dim_output,
hidden_sizes=hidden_sizes,
hidden_nonlinearity=hidden_nonlinearity,
output_nonlinearity=output_nonlinearity,
name=name,
input_layer=input_layer,
conv_filters=conv_filters,
conv_filter_sizes=conv_filter_sizes,
conv_strides=conv_strides,
conv_pads=conv_pads)
else:
prob_network = MLP(output_dim=dim_output,
hidden_sizes=hidden_sizes,
hidden_nonlinearity=hidden_nonlinearity,
output_nonlinearity=output_nonlinearity,
name=name,
input_layer=input_layer)
return prob_network.output_layer
def __init__(self, name, input_shape, output_dim,
conv_filters, conv_filter_sizes, conv_strides, conv_pads,
hidden_sizes, hidden_nonlinearity, output_nonlinearity,
hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer,
output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer,
input_var=None, input_layer=None, batch_normalization=False, weight_normalization=False):
Serializable.quick_init(self, locals())
"""
A network composed of several convolution layers followed by some fc layers.
input_shape: (width,height,channel)
HOWEVER, network inputs are assumed flattened. This network will first unflatten the inputs and then apply the standard convolutions and so on.
conv_filters: a list of numbers of convolution kernel
conv_filter_sizes: a list of sizes (int) of the convolution kernels
conv_strides: a list of strides (int) of the conv kernels
conv_pads: a list of pad formats (either 'SAME' or 'VALID')
hidden_nonlinearity: a nonlinearity from tf.nn, shared by all conv and fc layers
hidden_sizes: a list of numbers of hidden units for all fc layers
"""
with tf.variable_scope(name):
if input_layer is not None:
l_in = input_layer
l_hid = l_in
elif len(input_shape) == 3:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
elif len(input_shape) == 2:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
input_shape = (1,) + input_shape
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
else:
l_in = L.InputLayer(shape=(None,) + input_shape, input_var=input_var, name="input")
l_hid = l_in
if batch_normalization:
l_hid = L.batch_norm(l_hid)
for idx, conv_filter, filter_size, stride, pad in zip(
range(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_hid = L.Conv2DLayer(
l_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_hid = L.batch_norm(l_hid)
if output_nonlinearity == L.spatial_expected_softmax:
assert len(hidden_sizes) == 0
assert output_dim == conv_filters[-1] * 2
l_hid.nonlinearity = tf.identity
l_out = L.SpatialExpectedSoftmaxLayer(l_hid)
else:
l_hid = L.flatten(l_hid, name="conv_flatten")
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_hid = L.batch_norm(l_hid)
l_out = L.DenseLayer(
l_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_out = L.batch_norm(l_out)
self._l_in = l_in
self._l_out = l_out
# self._input_var = l_in.input_var
LayersPowered.__init__(self, l_out)
def __init__(self, name, input_shape, extra_input_shape, output_dim, hidden_sizes,
conv_filters, conv_filter_sizes, conv_strides, conv_pads,
extra_hidden_sizes=None,
hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer,
output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer,
hidden_nonlinearity=tf.nn.relu,
output_nonlinearity=None,
input_var=None, input_layer=None):
Serializable.quick_init(self, locals())
if extra_hidden_sizes is None:
extra_hidden_sizes = []
with tf.variable_scope(name):
input_flat_dim = np.prod(input_shape)
extra_input_flat_dim = np.prod(extra_input_shape)
total_input_flat_dim = input_flat_dim + extra_input_flat_dim
if input_layer is None:
l_in = L.InputLayer(shape=(None, total_input_flat_dim), input_var=input_var, name="input")
else:
l_in = input_layer
l_conv_in = L.reshape(
L.SliceLayer(
l_in,
indices=slice(input_flat_dim),
name="conv_slice"
),
([0],) + input_shape,
name="conv_reshaped"
)
l_extra_in = L.reshape(
L.SliceLayer(
l_in,
indices=slice(input_flat_dim, None),
name="extra_slice"
),
([0],) + extra_input_shape,
name="extra_reshaped"
)
l_conv_hid = l_conv_in
for idx, conv_filter, filter_size, stride, pad in zip(
range(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_conv_hid = L.Conv2DLayer(
l_conv_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
)
l_extra_hid = l_extra_in
for idx, hidden_size in enumerate(extra_hidden_sizes):
l_extra_hid = L.DenseLayer(
l_extra_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="extra_hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
)
l_joint_hid = L.concat(
[L.flatten(l_conv_hid, name="conv_hidden_flat"), l_extra_hid],
name="joint_hidden"
)
for idx, hidden_size in enumerate(hidden_sizes):
l_joint_hid = L.DenseLayer(
l_joint_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="joint_hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
)
l_out = L.DenseLayer(
l_joint_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
)
self._l_in = l_in
self._l_out = l_out
LayersPowered.__init__(self, [l_out], input_layers=[l_in])
def __init__(self,
name,
input_shape,
extra_input_shape,
output_dim,
hidden_sizes,
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
extra_hidden_sizes=None,
hidden_W_init=L.XavierUniformInitializer(),
hidden_b_init=tf.zeros_initializer(),
output_W_init=L.XavierUniformInitializer(),
output_b_init=tf.zeros_initializer(),
hidden_nonlinearity=tf.nn.relu,
output_nonlinearity=None,
input_var=None,
input_layer=None):
Serializable.quick_init(self, locals())
if extra_hidden_sizes is None:
extra_hidden_sizes = []
with tf.variable_scope(name):
input_flat_dim = np.prod(input_shape)
extra_input_flat_dim = np.prod(extra_input_shape)
total_input_flat_dim = input_flat_dim + extra_input_flat_dim
if input_layer is None:
l_in = L.InputLayer(shape=(None, total_input_flat_dim),
input_var=input_var,
name="input")
else:
l_in = input_layer
l_conv_in = L.reshape(L.SliceLayer(l_in,
indices=slice(input_flat_dim),
name="conv_slice"),
([0], ) + input_shape,
name="conv_reshaped")
l_extra_in = L.reshape(L.SliceLayer(l_in,
indices=slice(
input_flat_dim, None),
name="extra_slice"),
([0], ) + extra_input_shape,
name="extra_reshaped")
l_conv_hid = l_conv_in
for idx, conv_filter, filter_size, stride, pad in zip(
range(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_conv_hid = L.Conv2DLayer(
l_conv_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
)
l_extra_hid = l_extra_in
for idx, hidden_size in enumerate(extra_hidden_sizes):
l_extra_hid = L.DenseLayer(
l_extra_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="extra_hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
)
l_joint_hid = L.concat(
[L.flatten(l_conv_hid, name="conv_hidden_flat"), l_extra_hid],
name="joint_hidden")
for idx, hidden_size in enumerate(hidden_sizes):
l_joint_hid = L.DenseLayer(
l_joint_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="joint_hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
)
l_out = L.DenseLayer(
l_joint_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
)
self._l_in = l_in
self._l_out = l_out
LayersPowered.__init__(self, [l_out], input_layers=[l_in])
def __init__(self,
name,
input_shape,
output_dim,
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
hidden_sizes,
hidden_nonlinearity,
output_nonlinearity,
hidden_W_init=L.XavierUniformInitializer(),
hidden_b_init=tf.zeros_initializer(),
output_W_init=L.XavierUniformInitializer(),
output_b_init=tf.zeros_initializer(),
input_var=None,
input_layer=None,
batch_normalization=False,
weight_normalization=False):
Serializable.quick_init(self, locals())
"""
A network composed of several convolution layers followed by some fc layers.
input_shape: (width,height,channel)
HOWEVER, network inputs are assumed flattened. This network will first unflatten the inputs and then apply the standard convolutions and so on.
conv_filters: a list of numbers of convolution kernel
conv_filter_sizes: a list of sizes (int) of the convolution kernels
conv_strides: a list of strides (int) of the conv kernels
conv_pads: a list of pad formats (either 'SAME' or 'VALID')
hidden_nonlinearity: a nonlinearity from tf.nn, shared by all conv and fc layers
hidden_sizes: a list of numbers of hidden units for all fc layers
"""
with tf.variable_scope(name):
if input_layer is not None:
l_in = input_layer
l_hid = l_in
elif len(input_shape) == 3:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)),
input_var=input_var,
name="input")
l_hid = L.reshape(l_in, ([0], ) + input_shape,
name="reshape_input")
elif len(input_shape) == 2:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)),
input_var=input_var,
name="input")
input_shape = (1, ) + input_shape
l_hid = L.reshape(l_in, ([0], ) + input_shape,
name="reshape_input")
else:
l_in = L.InputLayer(shape=(None, ) + input_shape,
input_var=input_var,
name="input")
l_hid = l_in
if batch_normalization:
l_hid = L.batch_norm(l_hid)
for idx, conv_filter, filter_size, stride, pad in zip(
range(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_hid = L.Conv2DLayer(
l_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_hid = L.batch_norm(l_hid)
if output_nonlinearity == L.spatial_expected_softmax:
assert len(hidden_sizes) == 0
assert output_dim == conv_filters[-1] * 2
l_hid.nonlinearity = tf.identity
l_out = L.SpatialExpectedSoftmaxLayer(l_hid)
else:
l_hid = L.flatten(l_hid, name="conv_flatten")
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="hidden_%d" % idx,
W=hidden_W_init,
b=hidden_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_hid = L.batch_norm(l_hid)
l_out = L.DenseLayer(
l_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_out = L.batch_norm(l_out)
self._l_in = l_in
self._l_out = l_out
# self._input_var = l_in.input_var
LayersPowered.__init__(self, l_out)
def __init__(self, name, input_shape, output_dim,
conv_filters, conv_filter_sizes, conv_strides, conv_pads,
hidden_sizes, hidden_nonlinearity, output_nonlinearity,
hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer(),
output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer(),
input_var=None, input_layer=None, batch_normalization=False, weight_normalization=False):
Serializable.quick_init(self, locals())
"""
A network composed of several convolution layers followed by some fc layers.
input_shape: (width,height,channel)
HOWEVER, network inputs are assumed flattened. This network will first unflatten the inputs and then apply the standard convolutions and so on.
conv_filters: a list of numbers of convolution kernel
conv_filter_sizes: a list of sizes (int) of the convolution kernels
conv_strides: a list of strides (int) of the conv kernels
conv_pads: a list of pad formats (either 'SAME' or 'VALID')
hidden_nonlinearity: a nonlinearity from tf.nn, shared by all conv and fc layers
hidden_sizes: a list of numbers of hidden units for all fc layers
"""
with tf.variable_scope(name):
if input_layer is not None:
l_in = input_layer
l_hid = l_in
elif len(input_shape) == 3:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
elif len(input_shape) == 2:
l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var, name="input")
input_shape = (1,) + input_shape
l_hid = L.reshape(l_in, ([0],) + input_shape, name="reshape_input")
else:
l_in = L.InputLayer(shape=(None,) + input_shape, input_var=input_var, name="input")
l_hid = l_in
if batch_normalization:
l_hid = L.batch_norm(l_hid)
critical_size = hidden_sizes[0]
for idx, conv_filter, filter_size, stride, pad in zip(range(len(conv_filters)),
conv_filters,
conv_filter_sizes,
conv_strides,
conv_pads,
):
l_hid = L.Conv2DLayer(
l_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="SL_conv_hidden_%d" % idx,
weight_normalization=weight_normalization,
)
if batch_normalization:
l_hid = L.batch_norm(l_hid)
l_hid = L.flatten(l_hid, name="conv_flatten")
critical_layer = L.DenseLayer(
l_hid,
num_units=hidden_sizes[0],
nonlinearity=None,
name="SL_fc",
W=hidden_W_init,
b=hidden_b_init,
weight_normalization=weight_normalization,
)
#critical_layer = L.flatten(critical_layer)
# if output_nonlinearity == L.spatial_expected_softmax:
# assert len(hidden_sizes) == 0
# assert output_dim == conv_filters[-1] * 2
# l_hid.nonlinearity = tf.identity
# l_out = L.SpatialExpectedSoftmaxLayer(l_hid)
self.actValues = L.get_output(critical_layer)
#list_rem = hidden_sizes[1:]
#####Forward pass block#################################
with tf.variable_scope("PG"):
# fcFor = L.DenseLayer(
# critical_layer,
# num_units = hidden_sizes[1],
# nonlinearity=hidden_nonlinearity,
# name="pgLayer_init",
# W=hidden_W_init,
# b=hidden_b_init,
# weight_normalization=weight_normalization,
# )
fc_1 = L.DenseLayer(
critical_layer,
num_units=hidden_sizes[1],
nonlinearity=hidden_nonlinearity,
name="pgLayer_1",
W=hidden_W_init,
b=hidden_b_init,
weight_normalization=weight_normalization,
)
fc_2 = L.DenseLayer(
fc_1,
num_units=hidden_sizes[2],
nonlinearity=hidden_nonlinearity,
name="pgLayer_2" ,
W=hidden_W_init,
b=hidden_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
fc_2 = L.batch_norm(fcFor)
fcOut = L.DenseLayer(
fc_2,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="output",
W=output_W_init,
b=output_b_init,
weight_normalization=weight_normalization,
)
if batch_normalization:
fcOut = L.batch_norm(fcOut)
###################################################
self.actVariable = tf.Variable(initial_value = tf.zeros([ 10000, 32], dtype = tf.float32),name = "act_var1", trainable = True)
bcOut = fcOut.get_output_for(fc_2.get_output_for(fc_1.get_output_for(self.actVariable)))
self.bcOut = bcOut
backOutLayer = L.InputLayer(shape = (), input_var= bcOut , name="OutputLayer")
# shape is (actVariable[0] , 2)
self._l_in = l_in
self.forwardOutLayer = fcOut
self.backOutLayer = backOutLayer
outLayers = [fcOut, backOutLayer]
# self._input_var = l_in.input_var
LayersPowered.__init__(self, outLayers)
def make_network_image(self,
dim_input,
dim_output,
nn_input=None,
target=None):
"""
An example a network in tf that has both state and image inputs.
Args:
dim_input: Dimensionality of input. expecting 2d tuple (num_frames x num_batches)
dim_output: Dimensionality of the output.
batch_size: Batch size.
network_config: dictionary of network structure parameters
Returns:
A tfMap object that stores inputs, outputs, and scalar loss.
"""
if dim_input[0] != 1:
raise Exception(
"Currently don't support concatenating timesteps for images")
n_mlp_layers = 2
layer_size = 128
dim_hidden = (n_mlp_layers - 1) * [layer_size]
dim_hidden.append(dim_output)
pool_size = 2
filter_size = 3
num_filters = [5, 5]
#TODO: don't do this grossness
if nn_input is None:
nn_input, _ = self.get_input_layer_image(dim_input[1], dim_output)
if target is None:
_, target = self.get_input_layer_image(dim_input[1], dim_output)
conv_filters = [5, 5]
conv_filter_sizes = [3, 3]
conv_pads = ['SAME', 'SAME']
max_pool_sizes = [2, 2]
conv_strides = [1, 1]
hidden_sizes = [100, 100]
hidden_nonlinearity = tf.nn.relu
output_nonlinearity = None
l_in = L.InputLayer(shape=tuple(nn_input.get_shape().as_list()),
input_var=nn_input)
l_hid = L.reshape(l_in, ([0], ) + dim_input[1], name="reshape_input")
for idx, conv_filter, filter_size, stride, pad, max_pool_size in zip(
range(len(conv_filters)), conv_filters, conv_filter_sizes,
conv_strides, conv_pads, max_pool_sizes):
l_hid = L.Conv2DLayer(
l_hid,
num_filters=conv_filter,
filter_size=filter_size,
stride=(stride, stride),
pad=pad,
nonlinearity=hidden_nonlinearity,
name="conv_hidden_%d" % idx,
)
if max_pool_size is not None:
l_hid = L.Pool2DLayer(l_hid, max_pool_size, pad="SAME")
l_hid = L.flatten(l_hid, name="conv_flatten")
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="hidden_%d" % idx,
)
fc_output = L.get_output(
L.DenseLayer(
l_hid,
num_units=dim_output,
nonlinearity=output_nonlinearity,
name="output",
))
loss, optimizer = self.get_loss_layer(pred=fc_output,
target_output=target)
self.class_target = target
self.nn_input = nn_input
self.discrimination_logits = fc_output
self.optimizer = optimizer
self.loss = loss
label_accuracy = tf.equal(
tf.round(tf.nn.sigmoid(self.discrimination_logits)),
tf.round(self.class_target))
self.label_accuracy = tf.reduce_mean(
tf.cast(label_accuracy, tf.float32))
self.mse = tf.reduce_mean(
tf.nn.l2_loss(
tf.nn.sigmoid(self.discrimination_logits) - self.class_target))
ones = tf.ones_like(self.class_target)
true_positives = tf.round(tf.nn.sigmoid(
self.discrimination_logits)) * tf.round(self.class_target)
predicted_positives = tf.round(
tf.nn.sigmoid(self.discrimination_logits))
false_negatives = tf.logical_not(
tf.logical_xor(
tf.equal(tf.round(tf.nn.sigmoid(self.discrimination_logits)),
ones), tf.equal(tf.round(self.class_target), ones)))
self.label_precision = tf.reduce_sum(
tf.cast(true_positives, tf.float32)) / tf.reduce_sum(
tf.cast(predicted_positives, tf.float32))
self.label_recall = tf.reduce_sum(tf.cast(
true_positives, tf.float32)) / (
tf.reduce_sum(tf.cast(true_positives, tf.float32)) +
tf.reduce_sum(tf.cast(false_negatives, tf.float32)))
