def triplet_loss(anchor, positive, negative, alpha):
"""Calculate the triplet loss according to the FaceNet paper
Args:
anchor: the embeddings for the anchor images.
positive: the embeddings for the positive images.
negative: the embeddings for the negative images.
Returns:
the triplet loss according to the FaceNet paper as a float tensor.
"""
with tf.variable_scope('triplet_loss'):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist,neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
python类subtract()的实例源码
tf_utils.py 文件源码
项目:convolutional-pose-machines-tensorflow
作者: timctho
项目源码
文件源码
阅读 30
收藏 0
点赞 0
评论 0
def rotate_points(orig_points, angle, w, h):
"""Return rotated points
Args:
orig_points: 'Tensor' with shape [N,2], each entry is point (x,y)
angle: rotate radians
Returns:
'Tensor' with shape [N,2], with rotated points
"""
# rotation
rotate_mat = tf.stack([[tf.cos(angle) / w, tf.sin(angle) / h],
[-tf.sin(angle) / w, tf.cos(angle) / h]])
# shift coord
orig_points = tf.subtract(orig_points, 0.5)
orig_points = tf.stack([orig_points[:, 0] * w,
orig_points[:, 1] * h], axis=1)
print(orig_points)
rotated_points = tf.matmul(orig_points, rotate_mat) + 0.5
return rotated_points
def create_training_batch(serialized_example, cfg, add_summaries):
features = get_region_data(serialized_example, cfg, fetch_ids=False,
fetch_labels=True, fetch_text_labels=False)
original_image = features['image']
bboxes = features['bboxes']
labels = features['labels']
distorted_inputs = get_distorted_inputs(original_image, bboxes, cfg, add_summaries)
distorted_inputs = tf.subtract(distorted_inputs, 0.5)
distorted_inputs = tf.multiply(distorted_inputs, 2.0)
names = ('inputs', 'labels')
tensors = [distorted_inputs, labels]
return [names, tensors]
def create_classification_batch(serialized_example, cfg, add_summaries):
features = get_region_data(serialized_example, cfg, fetch_ids=True,
fetch_labels=False, fetch_text_labels=False)
original_image = features['image']
bboxes = features['bboxes']
ids = features['ids']
distorted_inputs = get_distorted_inputs(original_image, bboxes, cfg, add_summaries)
distorted_inputs = tf.subtract(distorted_inputs, 0.5)
distorted_inputs = tf.multiply(distorted_inputs, 2.0)
names = ('inputs', 'ids')
tensors = [distorted_inputs, ids]
return [names, tensors]
def __init__(self, actions):
self.replayMemory = deque()
self.timeStep = 0
self.epsilon = INITIAL_EPSILON
self.actions = actions
self.files = 0
self.currentQNet = QNet(len(actions))
self.targetQNet = QNet(len(actions))
self.actionInput = tf.placeholder("float", [None, len(actions)],name="actions_one_hot")
self.yInput = tf.placeholder("float", [None],name="y")
self.action_mask = tf.multiply(self.currentQNet.QValue, self.actionInput)
self.Q_action = tf.reduce_sum(self.action_mask, reduction_indices=1)
self.delta = delta = tf.subtract(self.Q_action, self.yInput)
self.loss = tf.where(tf.abs(delta) < 1.0, 0.5 * tf.square(delta), tf.abs(delta) - 0.5)
#self.loss = tf.square(tf.subtract( self.Q_action, self.yInput ))
self.cost = tf.reduce_mean(self.loss)
self.trainStep = tf.train.RMSPropOptimizer(learning_rate=RMS_LEARNING_RATE,momentum=RMS_MOMENTUM,epsilon= RMS_EPSILON,decay=RMS_DECAY).minimize(
self.cost)
#
def image_preprocessing(image, train):
"""Decode and preprocess one image for evaluation or training.
Args:
image: JPEG
train: boolean
Returns:
3-D float Tensor containing an appropriately scaled image
Raises:
ValueError: if user does not provide bounding box
"""
with tf.name_scope('image_preprocessing'):
if train:
image = tf.image.random_flip_left_right(image)
image = tf.image.random_brightness(image, 0.6)
if FLAGS.image_channel >= 3:
image = tf.image.random_saturation(image, 0.6, 1.4)
# Finally, rescale to [-1,1] instead of [0, 1)
image = tf.subtract(image, 0.5)
image = tf.multiply(image, 2.0)
image = tf.image.per_image_standardization(image)
return image
def build_graph(self, actor, critic, cfg):
self.ph_action = graph.Placeholder(np.float32, shape=(None, actor.action_size), name="ph_action")
self.ph_advantage = graph.Placeholder(np.float32, shape=(None,), name="ph_adv")
self.ph_discounted_reward = graph.Placeholder(np.float32, shape=(None,), name="ph_edr")
mu, sigma2 = actor.node
sigma2 += tf.constant(1e-8)
# policy entropy
self.entropy = -tf.reduce_mean(0.5 * (tf.log(2. * np.pi * sigma2) + 1.))
# policy loss (calculation)
b_size = tf.to_float(tf.size(self.ph_action.node) / actor.action_size)
log_pi = tf.log(sigma2)
x_prec = tf.exp(-log_pi)
x_diff = tf.subtract(self.ph_action.node, mu)
x_power = tf.square(x_diff) * x_prec * -0.5
gaussian_nll = (tf.reduce_sum(log_pi, axis=1)
+ b_size * tf.log(2. * np.pi)) / 2. - tf.reduce_sum(x_power, axis=1)
self.policy_loss = -(tf.reduce_mean(gaussian_nll * self.ph_advantage.node) + cfg.entropy_beta * self.entropy)
# value loss
# (Learning rate for the Critic is sized by critic_scale parameter)
self.value_loss = cfg.critic_scale * tf.reduce_mean(tf.square(self.ph_discounted_reward.node - critic.node))
def SparseSoftmaxCrossEntropyWithLogits_FwGrad(op,
dx,
dy,
_op_table=None,
_grad_table=None):
"""Forward gradient operator of sparse softmax cross entropy."""
grad = op.outputs[1] # This is already computed in the forward pass.
x = op.inputs[0]
if dx is None:
return None
y = tf.nn.softmax(x)
grad_grad = tf.subtract(
tf.multiply(y, dx),
tf.multiply(
y, tf.reduce_sum(
tf.multiply(dx, y), [1], keep_dims=True)))
return tf.reduce_sum(tf.multiply(grad, dx), [1]), grad_grad
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_height, output_width)
image.set_shape([output_height, output_width, 1])
image = tf.subtract(image, 0.5)
image = tf.multiply(image, 2.0)
return image
def ternary_decoder(encoded_data, scaler, shape):
"""Decoding the signs to float format """
a = tf.cast(encoded_data, tf.int32)
a_split1 = tf.mod(a,4)
a_split2 = tf.to_int32(tf.mod(a/4,4))
a_split3 = tf.to_int32(tf.mod(a/16,4))
a_split4 = tf.to_int32(tf.mod(a/64,4))
a = tf.concat([a_split1, a_split2, a_split3, a_split4], 0)
real_size = tf.reduce_prod(shape)
a = tf.to_float(a)
a = tf.gather(a, tf.range(0,real_size))
a = tf.reshape(a, shape)
a = tf.subtract(a,1)
decoded = a*scaler
return decoded
def _accur(self, pred, gtMap, num_image):
""" Given a Prediction batch (pred) and a Ground Truth batch (gtMaps),
returns one minus the mean distance.
Args:
pred : Prediction Batch (shape = num_image x 64 x 64)
gtMaps : Ground Truth Batch (shape = num_image x 64 x 64)
num_image : (int) Number of images in batch
Returns:
(float)
"""
err = tf.to_float(0)
for i in range(num_image):
err = tf.add(err, self._compute_err(pred[i], gtMap[i]))
return tf.subtract(tf.to_float(1), err/num_image)
# MULTI CONTEXT ATTENTION MECHANISM
# WORK IN PROGRESS DO NOT USE THESE METHODS
# BASED ON:
# Multi-Context Attention for Human Pose Estimation
# Authors: Xiao Chu, Wei Yang, Wanli Ouyang, Cheng Ma, Alan L. Yuille, Xiaogang Wang
# Paper: https://arxiv.org/abs/1702.07432
# GitHub Torch7 Code: https://github.com/bearpaw/pose-attention
DenoisingAutoencoder.py 文件源码
项目:MachineLearningTutorial
作者: SpikeKing
项目源码
文件源码
阅读 30
收藏 0
点赞 0
评论 0
def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(),
scale=0.1):
self.n_input = n_input # ??????
self.n_hidden = n_hidden # ??????????????
self.transfer = transfer_function # ????
self.scale = tf.placeholder(tf.float32) # ?????????????feed???training_scale
self.training_scale = scale # ??????
network_weights = self._initialize_weights() # ???????????w1/b1????w2/b2
self.weights = network_weights # ??
# model
self.x = tf.placeholder(tf.float32, [None, self.n_input]) # ??feed???
self.hidden = self.transfer(tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)),
self.weights['w1']),
self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])
# cost?0.5*(x - x_)^2???
self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
self.optimizer = optimizer.minimize(self.cost)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init) # ???
DenoisingAutoencoder.py 文件源码
项目:MachineLearningTutorial
作者: SpikeKing
项目源码
文件源码
阅读 31
收藏 0
点赞 0
评论 0
def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(),
dropout_probability=0.95):
self.n_input = n_input
self.n_hidden = n_hidden
self.transfer = transfer_function
self.dropout_probability = dropout_probability
self.keep_prob = tf.placeholder(tf.float32)
network_weights = self._initialize_weights()
self.weights = network_weights
# model
self.x = tf.placeholder(tf.float32, [None, self.n_input])
self.hidden = self.transfer(tf.add(tf.matmul(tf.nn.dropout(self.x, self.keep_prob), self.weights['w1']),
self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])
# cost
self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
self.optimizer = optimizer.minimize(self.cost)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer = tf.train.AdamOptimizer()):
self.n_input = n_input
self.n_hidden = n_hidden
self.transfer = transfer_function
network_weights = self._initialize_weights()
self.weights = network_weights
# model
self.x = tf.placeholder(tf.float32, [None, self.n_input])
self.hidden = self.transfer(tf.add(tf.matmul(self.x, self.weights['w1']), self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])
# cost
self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
self.optimizer = optimizer.minimize(self.cost)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
def triplet_loss(anchor, positive, negative, alpha):
"""Calculate the triplet loss according to the FaceNet paper
Args:
anchor: the embeddings for the anchor images.
positive: the embeddings for the positive images.
negative: the embeddings for the negative images.
Returns:
the triplet loss according to the FaceNet paper as a float tensor.
"""
with tf.variable_scope('triplet_loss'):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist,neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
def triplet_loss(anchor, positive, negative, alpha):
"""Calculate the triplet loss according to the FaceNet paper
args:
anchor: the embeddings for the anchor images.
positive: the embeddings for the positive images.
negative: the embeddings for the negative images.
returns:
the triplet loss according to the FaceNet paper as a float tensor.
"""
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
tot_dist = tf.sum(tf.subtract(pos_dist, neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(tot_dist, 0.0), 0)
return loss
def __init__(self):
#self.x = tf.placeholder(tf.float32, [None, 115, 200, 3])
self.x = tf.placeholder(tf.float32, [None, 115, 200, 3])
self.y_ = tf.placeholder(tf.float32, [None, 2])
(self.h_conv1, _) = conv_layer(self.x, conv=(5, 5), stride=2, n_filters=24, use_bias=True)
(self.h_conv2, _) = conv_layer(self.h_conv1, conv=(5, 5), stride=2, n_filters=36, use_bias=True)
(self.h_conv3, _) = conv_layer(self.h_conv2, conv=(5, 5), stride=2, n_filters=48, use_bias=True)
(self.h_conv4, _) = conv_layer(self.h_conv3, conv=(3, 3), stride=1, n_filters=64, use_bias=True)
(self.h_conv5, _) = conv_layer(self.h_conv4, conv=(3, 3), stride=1, n_filters=64, use_bias=True)
self.h_conv5_flat = flattened(self.h_conv5)
(self.h_fc1_drop, _, _, self.keep_prob_fc1) = fc_layer(x=self.h_conv5_flat, n_neurons=512, activation=tf.nn.relu, use_bias=True, dropout=True)
(self.h_fc2_drop, _, _, self.keep_prob_fc2) = fc_layer(self.h_fc1_drop, 100, tf.nn.relu, True, True)
(self.h_fc3_drop, _, _, self.keep_prob_fc3) = fc_layer(self.h_fc2_drop, 50, tf.nn.relu, True, True)
(self.h_fc4_drop, _, _, self.keep_prob_fc4) = fc_layer(self.h_fc3_drop, 10, tf.nn.relu, True, True)
W_fc5 = weight_variable([10, 2])
b_fc5 = bias_variable([2])
self.y_out = tf.matmul(self.h_fc4_drop, W_fc5) + b_fc5
self.loss = tf.reduce_mean(tf.abs(tf.subtract(self.y_, self.y_out)))
def loss_with_spring(self):
margin = 5.0
labels_t = self.y_
labels_f = tf.subtract(1.0, self.y_, name="1-yi") # labels_ = !labels;
eucd2 = tf.pow(tf.subtract(self.o1, self.o2), 2)
eucd2 = tf.reduce_sum(eucd2, 1)
eucd = tf.sqrt(eucd2+1e-6, name="eucd")
C = tf.constant(margin, name="C")
# yi*||CNN(p1i)-CNN(p2i)||^2 + (1-yi)*max(0, C-||CNN(p1i)-CNN(p2i)||^2)
pos = tf.multiply(labels_t, eucd2, name="yi_x_eucd2")
# neg = tf.multiply(labels_f, tf.subtract(0.0,eucd2), name="yi_x_eucd2")
# neg = tf.multiply(labels_f, tf.maximum(0.0, tf.subtract(C,eucd2)), name="Nyi_x_C-eucd_xx_2")
neg = tf.multiply(labels_f, tf.pow(tf.maximum(tf.subtract(C, eucd), 0), 2), name="Nyi_x_C-eucd_xx_2")
losses = tf.add(pos, neg, name="losses")
loss = tf.reduce_mean(losses, name="loss")
return loss
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def _modified_smooth_l1(self, sigma, bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights):
"""
ResultLoss = outside_weights * SmoothL1(inside_weights * (bbox_pred - bbox_targets))
SmoothL1(x) = 0.5 * (sigma * x)^2, if |x| < 1 / sigma^2
|x| - 0.5 / sigma^2, otherwise
"""
sigma2 = sigma * sigma
inside_mul = tf.multiply(bbox_inside_weights, tf.subtract(bbox_pred, bbox_targets))
smooth_l1_sign = tf.cast(tf.less(tf.abs(inside_mul), 1.0 / sigma2), tf.float32)
smooth_l1_option1 = tf.multiply(tf.multiply(inside_mul, inside_mul), 0.5 * sigma2)
smooth_l1_option2 = tf.subtract(tf.abs(inside_mul), 0.5 / sigma2)
smooth_l1_result = tf.add(tf.multiply(smooth_l1_option1, smooth_l1_sign),
tf.multiply(smooth_l1_option2, tf.abs(tf.subtract(smooth_l1_sign, 1.0))))
outside_mul = tf.multiply(bbox_outside_weights, smooth_l1_result)
return outside_mul
def triplet_loss(anchor, positive, negative, alpha):
"""Calculate the triplet loss according to the FaceNet paper
Args:
anchor: the embeddings for the anchor images.
positive: the embeddings for the positive images.
negative: the embeddings for the negative images.
Returns:
the triplet loss according to the FaceNet paper as a float tensor.
"""
with tf.variable_scope('triplet_loss'):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist,neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def triplet_loss(anchor, positive, negative, alpha=0.2, name='triplet_loss'):
"""Calculate the triplet loss according to the FaceNet paper
Args:
anchor: 2-D `tensor` [batch_size, embedding_size], the embeddings for the anchor images.
positive: 2-D `tensor` [batch_size, embedding_size], the embeddings for the positive images.
negative: 2-D `tensor` [batch_size, embedding_size], the embeddings for the negative images.
alpha: positive to negative triplet distance margin
Returns:
the triplet loss.
"""
with tf.name_scope(name):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
def vggnet_input(im_tf):
im_tf = tf.image.convert_image_dtype(im_tf, dtype=tf.float32)
# im_tf = tf.image.central_crop(im_tf, central_fraction=0.875)
# im_tf = tf.expand_dims(im_tf, 0)
# im_tf = tf.image.resize_bilinear(im_tf, [224, 224], align_corners=False)
# im_tf = tf.squeeze(im_tf, [0])
im_tf = tf.subtract(im_tf, 0.5)
im_tf = tf.multiply(im_tf, 2.0)
im_tf = im_tf * 255.0
r_, g_, b_ = tf.split(im_tf, 3, axis=2)
r_ = r_ - VGG_MEAN[2]
g_ = b_ - VGG_MEAN[1]
b_ = b_ - VGG_MEAN[0]
im_tf = tf.concat([r_, g_, b_], axis=2)
# im_tf = tf.expand_dims(im_tf, 0)
return im_tf
def preprocess_image(image, output_height, output_width, is_training):
"""Preprocesses the given image.
Args:
image: A `Tensor` representing an image of arbitrary size.
output_height: The height of the image after preprocessing.
output_width: The width of the image after preprocessing.
is_training: `True` if we're preprocessing the image for training and
`False` otherwise.
Returns:
A preprocessed image.
"""
image = tf.to_float(image)
image = tf.image.resize_image_with_crop_or_pad(
image, output_width, output_height)
image = tf.subtract(image, 128.0)
image = tf.div(image, 128.0)
return image
def _get_step(self, inputs):
Z, Y, X, theta, lmbd = self.inputs
K, p = self.D.shape
L = self.L
with tf.name_scope("ISTA_iteration"):
self.S = tf.constant(np.eye(K, dtype=np.float32) - self.S0/L,
shape=[K, K], name='S')
self.We = tf.constant(self.D.T/L, shape=[p, K],
dtype=tf.float32, name='We')
hk = tf.matmul(Y, self.S) + tf.matmul(X, self.We)
self.step_FISTA = Zk = soft_thresholding(hk, lmbd/L)
# self.theta_k = tk = (tf.sqrt(theta*theta+4) - theta)*theta/2
self.theta_k = tk = (1 + tf.sqrt(1 + 4*theta*theta))/2
dZ = tf.subtract(Zk, Z)
# self.Yk = Zk + tk*(1/theta-1)*dZ
self.Yk = Zk + (theta-1)/tk*dZ
self.dz = tf.reduce_mean(tf.reduce_sum(
dZ*dZ, reduction_indices=[1]))
step = tf.tuple([Zk, tk, self.Yk])
return step, self.dz
def _build_q_head(self, input_state):
self.w_value, self.b_value, self.value = layers.fc('fc_value', input_state, 1, activation='linear')
self.w_adv, self.b_adv, self.advantage = layers.fc('fc_advantage', input_state, self.num_actions, activation='linear')
self.output_layer = (
self.value + self.advantage
- tf.reduce_mean(
self.advantage,
axis=1,
keep_dims=True
)
)
q_selected_action = tf.reduce_sum(self.output_layer * self.selected_action_ph, axis=1)
diff = tf.subtract(self.target_ph, q_selected_action)
return self._value_function_loss(diff)
def get_masks(origin_images, height, width, channels=3):
"""add horizon color lines and set empty"""
quarty = tf.random_uniform([height/4, 1])
prop = tf.scalar_mul(tf.convert_to_tensor(0.2), tf.ones([height/4, 1]))
quarty = tf.round(tf.add(quarty, prop))
y = tf.reshape(tf.stack([quarty, quarty, quarty, quarty], axis=1), [height, 1])
mask = tf.matmul(y, tf.ones([1, width]))
masks = tf.expand_dims(mask, 0)
masks = tf.expand_dims(masks, -1)
maskedimages = tf.mul(origin_images, masks)
"""add noise"""
scale = tf.random_uniform([channels, height, 1])
y = tf.subtract(tf.ones([height, 1]), y)
y = tf.expand_dims(y, 0)
y = tf.scalar_mul(tf.convert_to_tensor(255.), tf.multiply(scale, y))
noise = tf.add(mask, tf.matmul(y, tf.ones([channels, 1, width])))
noise = tf.pack(tf.split(value=noise, num_or_size_splits=noise.get_shape()[0], axis=0), axis=3)
maskedimages = tf.add(maskedimages, noise)
return maskedimages