def one_hot_encoding(target, n_classes, on_value=1.0, off_value=1.0,
name="OneHotEncoding"):
""" One Hot Encoding.
Transform numeric labels into a binary vector.
Input:
The Labels Placeholder.
Output:
2-D Tensor, The encoded labels.
Arguments:
target: `Placeholder`. The labels placeholder.
n_classes: `int`. Total number of classes.
on_value: `scalar`. A scalar defining the on-value.
off_value: `scalar`. A scalar defining the off-value.
name: A name for this layer (optional). Default: 'OneHotEncoding'.
"""
with tf.name_scope(name):
if target.dtype == tf.dtypes.int32:
target = standard_ops.to_int64(target)
target = standard_ops.one_hot(target, n_classes,
on_value=on_value,
off_value=off_value)
# Track output tensor.
tf.add_to_collection(tf.GraphKeys.LAYER_TENSOR + '/' + name, target)
return target
def one_hot_encoding(labels,
num_classes,
on_value=1.0,
off_value=0.0,
outputs_collections=None,
scope=None):
"""Transform numeric labels into onehot_labels using tf.one_hot.
Args:
labels: [batch_size] target labels.
num_classes: total number of classes.
on_value: A scalar defining the on-value.
off_value: A scalar defining the off-value.
outputs_collections: collection to add the outputs.
scope: Optional scope for op_scope.
Returns:
one hot encoding of the labels.
"""
with ops.op_scope([labels, num_classes], scope, 'OneHotEncoding') as sc:
if labels.dtype == dtypes.int32:
labels = standard_ops.to_int64(labels)
outputs = standard_ops.one_hot(labels,
num_classes,
on_value=on_value,
off_value=off_value)
return utils.collect_named_outputs(outputs_collections, sc, outputs)
def one_hot_encoding(target, n_classes, on_value=1.0, off_value=0.0,
name="OneHotEncoding"):
""" One Hot Encoding.
Transform numeric labels into a binary vector.
Input:
The Labels Placeholder.
Output:
2-D Tensor, The encoded labels.
Arguments:
target: `Placeholder`. The labels placeholder.
n_classes: `int`. Total number of classes.
on_value: `scalar`. A scalar defining the on-value.
off_value: `scalar`. A scalar defining the off-value.
name: A name for this layer (optional). Default: 'OneHotEncoding'.
"""
with tf.name_scope(name):
if target.dtype != dtypes.int64:
target = standard_ops.to_int64(target)
target = standard_ops.one_hot(target, n_classes,
on_value=on_value,
off_value=off_value)
# Track output tensor.
tf.add_to_collection(tf.GraphKeys.LAYER_TENSOR + '/' + name, target)
return target
def _preprocess(self, features, labels):
if isinstance(labels, Mapping):
labels = labels['label']
if self.one_hot_encode:
labels = standard_ops.one_hot(indices=labels, depth=self.n_classes)
return super(Classifier, self)._preprocess(features, labels)
def max_spanning_tree_gradient(mst_op, d_loss_d_max_scores, *_):
"""Returns a subgradient of the MaximumSpanningTree op.
Note that MaximumSpanningTree is only differentiable w.r.t. its |scores| input
and its |max_scores| output.
Args:
mst_op: The MaximumSpanningTree op being differentiated.
d_loss_d_max_scores: [B] vector where entry b is the gradient of the network
loss w.r.t. entry b of the |max_scores| output of the |mst_op|.
*_: The gradients w.r.t. the other outputs; ignored.
Returns:
1. None, since the op is not differentiable w.r.t. its |num_nodes| input.
2. [B,M,M] tensor where entry b,t,s is a subgradient of the network loss
w.r.t. entry b,t,s of the |scores| input, with the same dtype as
|d_loss_d_max_scores|.
"""
dtype = d_loss_d_max_scores.dtype.base_dtype
if dtype is None:
raise errors.InvalidArgumentError("Expected (%s) is not None" % dtype)
argmax_sources_bxm = mst_op.outputs[1]
input_dim = array_ops.shape(argmax_sources_bxm)[1] # M in the docstring
# The one-hot argmax is a subgradient of max. Convert the batch of maximal
# spanning trees into 0/1 indicators, then scale them by the relevant output
# gradients from |d_loss_d_max_scores|. Note that |d_loss_d_max_scores| must
# be reshaped in order for it to broadcast across the batch dimension.
indicators_bxmxm = standard_ops.one_hot(
argmax_sources_bxm, input_dim, dtype=dtype)
d_loss_d_max_scores_bx1 = array_ops.expand_dims(d_loss_d_max_scores, -1)
d_loss_d_max_scores_bx1x1 = array_ops.expand_dims(d_loss_d_max_scores_bx1, -1)
d_loss_d_scores_bxmxm = indicators_bxmxm * d_loss_d_max_scores_bx1x1
return None, d_loss_d_scores_bxmxm
def _build_loss(self, results, features, labels):
"""Creates the loss operation
Returns:
tuple `(losses, loss)`:
`losses` are the per-batch losses.
`loss` is a single scalar tensor to minimize.
"""
reward, action, done = labels['reward'], labels['action'], labels['done']
train_action_selector = standard_ops.one_hot(
indices=self._index_action, depth=self.num_actions)
target_q_values = tf.reduce_sum(
tf.multiply(self._target_results.q, train_action_selector), axis=1)
action_selector = standard_ops.one_hot(indices=action[:-1], depth=self.num_actions)
train_q_value = tf.reduce_sum(
tf.multiply(self._train_results.q[:-1], action_selector), axis=1)
target_q_value = (reward[:-1] + (1.0 - tf.cast(done[:-1], tf.float32)) *
self.discount * target_q_values[1:])
return super(DDQNModel, self)._build_loss(train_q_value, features, target_q_value)
def _build(self, incoming, *args, **kwargs):
"""
Args:
incoming: The Labels Placeholder.
Returns:
2-D Tensor, The encoded labels.
"""
if incoming.dtype != dtypes.int64:
incoming = standard_ops.to_int64(incoming)
incoming = standard_ops.one_hot(indices=incoming, depth=self.n_classes,
on_value=self.on_value, off_value=self.off_value)
track(incoming, tf.GraphKeys.LAYER_TENSOR, self.module_name)
return incoming
