def _ceil_divide_int(x, y):
"""Returns ceil(x / y) as tf.int32."""
z = tf.truediv(x, y)
tf.debugging.check_numerics(
z, message='_ceil_divide_int output is NaN or Inf.')
z = tf.math.ceil(z)
z = tf.cast(z, dtype=tf.int32)
return z
def _classification_loss(pred_labels, gt_labels, num_matched_boxes):
"""Computes the classification loss.
Computes the classification loss with hard negative mining.
Args:
pred_labels: a dict from index to tensor of predicted class. The shape
of the tensor is [batch_size, num_anchors, num_classes].
gt_labels: a list of tensor that represents the classification groundtruth
targets. The shape is [batch_size, num_anchors, 1].
num_matched_boxes: the number of anchors that are matched to a groundtruth
targets. This is used as the loss normalizater.
Returns:
box_loss: a float32 representing total box regression loss.
"""
with tf.name_scope("class_loss_scope"):
keys = sorted(pred_labels.keys())
batch_size = gt_labels[0].shape[0]
assert (len(keys) == 1)
assert (keys[0] == 'flatten')
gt_label = gt_labels[0]
pred_label = pred_labels['flatten']
cross_entropy = tf.reshape(_softmax_cross_entropy_mme(
pred_label, gt_label), [batch_size, -1],
name="cross_entropy")
mask = tf.greater(gt_label, 0, name="mask")
float_mask = tf.cast(mask, tf.float32, name="float_mask")
# Hard example mining
neg_masked_cross_entropy = cross_entropy * (1 - float_mask)
num_neg_boxes = tf.expand_dims(
tf.minimum(
tf.cast(num_matched_boxes, tf.int32) *
constants.NEGS_PER_POSITIVE, constants.NUM_SSD_BOXES), -1)
_, neg_sorted_cross_indices = tf.nn.top_k(
neg_masked_cross_entropy,
tf.shape(neg_masked_cross_entropy)[1]) # descending order
_, neg_sorted_cross_rank = tf.nn.top_k(
-1 * neg_sorted_cross_indices,
tf.shape(neg_sorted_cross_indices)[1]) # ascending order
topk_neg_mask = tf.cast(
tf.math.less(neg_sorted_cross_rank, num_neg_boxes), tf.float32)
add = tf.add(float_mask, topk_neg_mask, name="add")
class_loss = tf.reduce_sum(tf.multiply(cross_entropy, add, name="mul"),
axis=1,
name="reduce_sum")
normalized_class_loss = tf.truediv(class_loss,
num_matched_boxes,
name="normalized_class_loss")
return tf.reduce_mean(normalized_class_loss, name="class_loss_1")
def _add_loss_graph(self):
"""Define the loss operation."""
mc = self.mc
with tf.variable_scope('class_regression') as scope:
# cross-entropy: q * -log(p) + (1-q) * -log(1-p)
# add a small value into log to prevent blowing up
self.class_loss = tf.truediv(tf.reduce_sum(
(self.labels * (-tf.log(self.pred_class_probs + mc.EPSILON)) +
(1 - self.labels) *
(-tf.log(1 - self.pred_class_probs + mc.EPSILON))) *
self.input_mask * mc.LOSS_COEF_CLASS),
self.num_objects,
name='class_loss')
tf.add_to_collection('losses', self.class_loss)
with tf.variable_scope('confidence_score_regression') as scope:
input_mask = tf.reshape(self.input_mask,
[mc.BATCH_SIZE, mc.ANCHORS])
self.conf_loss = tf.reduce_mean(tf.abs(
tf.reduce_sum(
tf.square((self.ious - self.pred_conf)) *
(input_mask * mc.LOSS_COEF_CONF_POS / self.num_objects +
(1 - input_mask) * mc.LOSS_COEF_CONF_NEG /
(mc.ANCHORS - self.num_objects)),
reduction_indices=[1])),
name='confidence_loss')
tf.add_to_collection('losses', self.conf_loss)
tf.summary.scalar('mean iou',
tf.reduce_sum(self.ious) / self.num_objects)
with tf.variable_scope('bounding_box_regression') as scope:
self.bbox_loss = tf.truediv(tf.reduce_sum(
mc.LOSS_COEF_BBOX *
tf.square(self.input_mask *
(self.pred_box_delta - self.box_delta_input))),
self.num_objects,
name='bbox_loss')
tf.add_to_collection('losses', self.bbox_loss)
# add above losses as well as weight decay losses to form the total loss
self.loss = tf.add_n(tf.get_collection('losses'), name='total_loss')
def _safe_div(numerator, denominator):
"""Divides two tensors element-wise, returning 0 if the denominator is <= 0.
Args:
numerator: A real `Tensor`.
denominator: A real `Tensor`, with dtype matching `numerator`.
Returns:
0 if `denominator` <= 0, else `numerator` / `denominator`
"""
t = tf.truediv(numerator, denominator)
zero = tf.zeros_like(t, dtype=denominator.dtype)
condition = tf.greater(denominator, zero)
zero = tf.cast(zero, t.dtype)
return tf.where(condition, t, zero)
def calculate_signal_to_noise_ratio_from_power(signal_power, noise_power,
epsilon):
"""Computes the signal to noise ratio given signal_power and noise_power.
Args:
signal_power: A tensor of unknown shape and arbitrary rank.
noise_power: A tensor matching the signal tensor.
epsilon: An optional float for numerical stability, since silences
can lead to divide-by-zero.
Returns:
A tensor of size [...] with SNR computed between matching slices of the
input signal and noise tensors.
"""
# Pre-multiplication and change of logarithm base.
constant = tf.cast(10.0 / tf.log(10.0), signal_power.dtype)
return constant * tf.log(
tf.truediv(signal_power + epsilon, noise_power + epsilon))
def ioa(boxlist1, boxlist2, scope=None):
"""Computes pairwise intersection-over-area between box collections.
intersection-over-area (IOA) between two boxes box1 and box2 is defined as
their intersection area over box2's area. Note that ioa is not symmetric,
that is, ioa(box1, box2) != ioa(box2, box1).
Args:
boxlist1: BoxList holding N boxes
boxlist2: BoxList holding M boxes
scope: name scope.
Returns:
a tensor with shape [N, M] representing pairwise ioa scores.
"""
with tf.name_scope(scope, 'IOA'):
intersections = intersection(boxlist1, boxlist2)
areas = tf.expand_dims(area(boxlist2), 0)
return tf.truediv(intersections, areas)
def matched_iou(boxlist1, boxlist2, scope=None):
"""Compute intersection-over-union between corresponding boxes in boxlists.
Args:
boxlist1: BoxList holding N boxes
boxlist2: BoxList holding N boxes
scope: name scope.
Returns:
a tensor with shape [N] representing pairwise iou scores.
"""
with tf.name_scope(scope, 'MatchedIOU'):
intersections = matched_intersection(boxlist1, boxlist2)
areas1 = area(boxlist1)
areas2 = area(boxlist2)
unions = areas1 + areas2 - intersections
return tf.where(tf.equal(intersections, 0.0),
tf.zeros_like(intersections),
tf.truediv(intersections, unions))
def iou(boxlist1, boxlist2, scope=None):
"""Computes pairwise intersection-over-union between box collections.
Args:
boxlist1: BoxList holding N boxes
boxlist2: BoxList holding M boxes
scope: name scope.
Returns:
a tensor with shape [N, M] representing pairwise iou scores.
"""
with tf.name_scope(scope, 'IOU'):
intersections = intersection(boxlist1, boxlist2)
areas1 = area(boxlist1)
areas2 = area(boxlist2)
unions = (tf.expand_dims(areas1, 1) + tf.expand_dims(areas2, 0) -
intersections)
return tf.where(tf.equal(intersections, 0.0),
tf.zeros_like(intersections),
tf.truediv(intersections, unions))
def calculate_signal_to_noise_ratio(signal, noise, epsilon=1.0e-5):
"""Computes the signal to noise ratio given signal and noise.
Args:
signal: A [..., samples] tensor of unknown shape and arbitrary rank.
noise: A tensor matching the signal tensor.
epsilon: An optional float for numerical stability, since silences
can lead to divide-by-zero.
Returns:
A tensor of size [...] with SNR computed between matching slices of the
input signal and noise tensors.
"""
def power(x):
return tf.reduce_sum(tf.square(x), reduction_indices=[-1])
# Pre-multiplication and change of logarithm base.
constant = tf.cast(10.0 / tf.log(10.0), signal.dtype)
return constant * tf.log(
tf.truediv(power(signal) + epsilon,
power(noise) + epsilon))
def normalize(v): return tf.truediv(v, tf.cast(self._num_microbatches, tf.float32))
def normalize_to_target(inputs,
target_norm_value,
dim,
epsilon=1e-7,
trainable=True,
scope='NormalizeToTarget',
summarize=True):
"""L2 normalizes the inputs across the specified dimension to a target norm.
This op implements the L2 Normalization layer introduced in
Liu, Wei, et al. "SSD: Single Shot MultiBox Detector."
and Liu, Wei, Andrew Rabinovich, and Alexander C. Berg.
"Parsenet: Looking wider to see better." and is useful for bringing
activations from multiple layers in a convnet to a standard scale.
Note that the rank of `inputs` must be known and the dimension to which
normalization is to be applied should be statically defined.
TODO(jonathanhuang): Add option to scale by L2 norm of the entire input.
Args:
inputs: A `Tensor` of arbitrary size.
target_norm_value: A float value that specifies an initial target norm or
a list of floats (whose length must be equal to the depth along the
dimension to be normalized) specifying a per-dimension multiplier
after normalization.
dim: The dimension along which the input is normalized.
epsilon: A small value to add to the inputs to avoid dividing by zero.
trainable: Whether the norm is trainable or not
scope: Optional scope for variable_scope.
summarize: Whether or not to add a tensorflow summary for the op.
Returns:
The input tensor normalized to the specified target norm.
Raises:
ValueError: If dim is smaller than the number of dimensions in 'inputs'.
ValueError: If target_norm_value is not a float or a list of floats with
length equal to the depth along the dimension to be normalized.
"""
with tf.variable_scope(scope, 'NormalizeToTarget', [inputs]):
if not inputs.get_shape():
raise ValueError('The input rank must be known.')
input_shape = inputs.get_shape().as_list()
input_rank = len(input_shape)
if dim < 0 or dim >= input_rank:
raise ValueError(
'dim must be non-negative but smaller than the input rank.')
if not input_shape[dim]:
raise ValueError('input shape should be statically defined along '
'the specified dimension.')
depth = input_shape[dim]
if not (isinstance(target_norm_value, float) or
(isinstance(target_norm_value, list) and
len(target_norm_value) == depth) and
all([isinstance(val, float) for val in target_norm_value])):
raise ValueError('target_norm_value must be a float or a list of floats '
'with length equal to the depth along the dimension to '
'be normalized.')
if isinstance(target_norm_value, float):
initial_norm = depth * [target_norm_value]
else:
initial_norm = target_norm_value
target_norm = slim.model_variable(
name='weights',
dtype=tf.float32,
initializer=tf.constant(initial_norm, dtype=tf.float32),
trainable=trainable)
if summarize:
mean = tf.reduce_mean(target_norm)
tf.summary.scalar(tf.get_variable_scope().name, mean)
lengths = epsilon + tf.sqrt(tf.reduce_sum(tf.square(inputs), dim, True))
mult_shape = input_rank*[1]
mult_shape[dim] = depth
return tf.reshape(target_norm, mult_shape) * tf.truediv(inputs, lengths)
# tf.add: 덧셈 # tf.subtract: 뺄셈 # tf.multiply: 곱셈 # tf.truediv: 나눗셈의 몫 # tf.mod: 나눗셈의 나머지 # tf.abs: 절대값 sess = tf.Session() a = tf.constant(17) b = tf.constant(5) # 덧셈 c = tf.add(a, b) print(sess.run(c)) # 뺄셈 c = tf.subtract(a, b) print(sess.run(c)) # 곱셈 c = tf.multiply(a, b) print(sess.run(c)) # 나눗셈 몫 c = tf.truediv(a, b) print(sess.run(c)) # 나눗셈 나머지 c = tf.mod(a, b) print(sess.run(c)) # 절대값 c = tf.abs(-a) print(sess.run(c))
def normalize(v): return tf.truediv(v, global_state.denominator)
def normalize(v):
try:
return tf.truediv(
v, tf.cast(self._num_microbatches, tf.float32))
except TypeError:
return None
# initialize placeholders
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
# create variables for linear regression
A = tf.Variable(tf.random_normal(shape=[1, 1]))
b = tf.Variable(tf.random_uniform(shape=[1, 1]))
# In[2]:
with tf.Session() as sess:
fomula = tf.add(tf.matmul(x_data, A), b)
demm_numer = tf.abs(tf.subtract(fomula, y_target)) # numerator
demm_denom = tf.sqrt(tf.add(tf.square(A), 1)) # denominator
loss = tf.reduce_mean(tf.truediv(demm_numer, demm_denom)) # 점과 직선사이의 거리
opt = tf.train.GradientDescentOptimizer(learning_rate=0.15)
train_step = opt.minimize(loss)
init = tf.global_variables_initializer()
init.run()
loss_vec = []
batch_size = 125
for i in range(1000):
rand_idx = np.random.choice(len(x_val), size=batch_size)
rand_x = x_val[rand_idx].reshape(-1, 1)
rand_y = y_val[rand_idx].reshape(-1, 1)
def call(self, x):
input_image, y_pred, y_true, true_boxes = x
# adjust the shape of the y_predict [batch, grid_h, grid_w, 3, 4+1+nb_class]
y_pred = tf.reshape(
y_pred,
tf.concat([tf.shape(input=y_pred)[:3],
tf.constant([3, -1])],
axis=0))
# initialize the masks
object_mask = tf.expand_dims(y_true[..., 4], 4)
# the variable to keep track of number of batches processed
batch_seen = tf.Variable(0.)
# compute grid factor and net factor
grid_h = tf.shape(input=y_true)[1]
grid_w = tf.shape(input=y_true)[2]
grid_factor = tf.reshape(tf.cast([grid_w, grid_h], tf.float32),
[1, 1, 1, 1, 2])
net_h = tf.shape(input=input_image)[1]
net_w = tf.shape(input=input_image)[2]
net_factor = tf.reshape(tf.cast([net_w, net_h], tf.float32),
[1, 1, 1, 1, 2])
"""
Adjust prediction
"""
pred_box_xy = (self.cell_grid[:, :grid_h, :grid_w, :, :] +
tf.sigmoid(y_pred[..., :2])) # sigma(t_xy) + c_xy
pred_box_wh = y_pred[..., 2:4] # t_wh
pred_box_conf = tf.expand_dims(tf.sigmoid(y_pred[..., 4]),
4) # adjust confidence
pred_box_class = y_pred[..., 5:] # adjust class probabilities
"""
Adjust ground truth
"""
true_box_xy = y_true[..., 0:2] # (sigma(t_xy) + c_xy)
true_box_wh = y_true[..., 2:4] # t_wh
true_box_conf = tf.expand_dims(y_true[..., 4], 4)
true_box_class = tf.argmax(input=y_true[..., 5:], axis=-1)
"""
Compare each predicted box to all true boxes
"""
# initially, drag all objectness of all boxes to 0
conf_delta = pred_box_conf - 0
# then, ignore the boxes which have good overlap with some true box
true_xy = true_boxes[..., 0:2] / grid_factor
true_wh = true_boxes[..., 2:4] / net_factor
true_wh_half = true_wh / 2.
true_mins = true_xy - true_wh_half
true_maxes = true_xy + true_wh_half
pred_xy = tf.expand_dims(pred_box_xy / grid_factor, 4)
pred_wh = tf.expand_dims(
tf.exp(pred_box_wh) * self.anchors / net_factor, 4)
pred_wh_half = pred_wh / 2.
pred_mins = pred_xy - pred_wh_half
pred_maxes = pred_xy + pred_wh_half
intersect_mins = tf.maximum(pred_mins, true_mins)
intersect_maxes = tf.minimum(pred_maxes, true_maxes)
intersect_wh = tf.maximum(intersect_maxes - intersect_mins, 0.)
intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1]
true_areas = true_wh[..., 0] * true_wh[..., 1]
pred_areas = pred_wh[..., 0] * pred_wh[..., 1]
union_areas = pred_areas + true_areas - intersect_areas
iou_scores = tf.truediv(intersect_areas, union_areas)
best_ious = tf.reduce_max(input_tensor=iou_scores, axis=4)
conf_delta *= tf.expand_dims(
tf.cast(best_ious < self.ignore_thresh, dtype=tf.float32), 4)
"""
Compute some online statistics
"""
true_xy = true_box_xy / grid_factor
true_wh = tf.exp(true_box_wh) * self.anchors / net_factor
true_wh_half = true_wh / 2.
true_mins = true_xy - true_wh_half
true_maxes = true_xy + true_wh_half
pred_xy = pred_box_xy / grid_factor
pred_wh = tf.exp(pred_box_wh) * self.anchors / net_factor
pred_wh_half = pred_wh / 2.
pred_mins = pred_xy - pred_wh_half
pred_maxes = pred_xy + pred_wh_half
intersect_mins = tf.maximum(pred_mins, true_mins)
intersect_maxes = tf.minimum(pred_maxes, true_maxes)
intersect_wh = tf.maximum(intersect_maxes - intersect_mins, 0.)
intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1]
true_areas = true_wh[..., 0] * true_wh[..., 1]
pred_areas = pred_wh[..., 0] * pred_wh[..., 1]
union_areas = pred_areas + true_areas - intersect_areas
iou_scores = tf.truediv(intersect_areas, union_areas)
iou_scores = object_mask * tf.expand_dims(iou_scores, 4)
count = tf.reduce_sum(input_tensor=object_mask)
count_noobj = tf.reduce_sum(input_tensor=1 - object_mask)
detect_mask = tf.cast((pred_box_conf * object_mask) >= 0.5,
dtype=tf.float32)
class_mask = tf.expand_dims(
tf.cast(tf.equal(tf.argmax(input=pred_box_class, axis=-1),
true_box_class),
dtype=tf.float32), 4)
recall50 = tf.reduce_sum(
input_tensor=tf.cast(iou_scores >= 0.5, dtype=tf.float32) *
detect_mask * class_mask) / (count + 1e-3)
recall75 = tf.reduce_sum(
input_tensor=tf.cast(iou_scores >= 0.75, dtype=tf.float32) *
detect_mask * class_mask) / (count + 1e-3)
avg_iou = tf.reduce_sum(input_tensor=iou_scores) / (count + 1e-3)
avg_obj = tf.reduce_sum(input_tensor=pred_box_conf *
object_mask) / (count + 1e-3)
avg_noobj = tf.reduce_sum(input_tensor=pred_box_conf *
(1 - object_mask)) / (count_noobj + 1e-3)
avg_cat = tf.reduce_sum(input_tensor=object_mask *
class_mask) / (count + 1e-3)
"""
Warm-up training
"""
batch_seen = tf.assign_add(batch_seen, 1.)
true_box_xy, true_box_wh, xywh_mask = tf.cond(
pred=tf.less(batch_seen, self.warmup_batches + 1),
true_fn=lambda: [
true_box_xy +
(0.5 + self.cell_grid[:, :grid_h, :grid_w, :, :]) *
(1 - object_mask), true_box_wh + tf.zeros_like(true_box_wh) *
(1 - object_mask),
tf.ones_like(object_mask)
],
false_fn=lambda: [true_box_xy, true_box_wh, object_mask])
"""
Compare each true box to all anchor boxes
"""
wh_scale = tf.exp(true_box_wh) * self.anchors / net_factor
wh_scale = tf.expand_dims(
2 - wh_scale[..., 0] * wh_scale[..., 1],
axis=4) # the smaller the box, the bigger the scale
xy_delta = xywh_mask * (pred_box_xy -
true_box_xy) * wh_scale * self.xywh_scale
wh_delta = xywh_mask * (pred_box_wh -
true_box_wh) * wh_scale * self.xywh_scale
conf_delta = object_mask * (
pred_box_conf - true_box_conf) * self.obj_scale + (
1 - object_mask) * conf_delta * self.noobj_scale
class_delta = object_mask * \
tf.expand_dims(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=true_box_class, logits=pred_box_class), 4) * \
self.class_scale
loss_xy = tf.reduce_sum(input_tensor=tf.square(xy_delta),
axis=list(range(1, 5)))
loss_wh = tf.reduce_sum(input_tensor=tf.square(wh_delta),
axis=list(range(1, 5)))
loss_conf = tf.reduce_sum(input_tensor=tf.square(conf_delta),
axis=list(range(1, 5)))
loss_class = tf.reduce_sum(input_tensor=class_delta,
axis=list(range(1, 5)))
loss = loss_xy + loss_wh + loss_conf + loss_class
loss = tf.Print(loss, [grid_h, avg_obj],
message='avg_obj \t\t',
summarize=1000)
loss = tf.Print(loss, [grid_h, avg_noobj],
message='avg_noobj \t\t',
summarize=1000)
loss = tf.Print(loss, [grid_h, avg_iou],
message='avg_iou \t\t',
summarize=1000)
loss = tf.Print(loss, [grid_h, avg_cat],
message='avg_cat \t\t',
summarize=1000)
loss = tf.Print(loss, [grid_h, recall50],
message='recall50 \t',
summarize=1000)
loss = tf.Print(loss, [grid_h, recall75],
message='recall75 \t',
summarize=1000)
loss = tf.Print(loss, [grid_h, count],
message='count \t',
summarize=1000)
loss = tf.Print(loss, [
grid_h,
tf.reduce_sum(input_tensor=loss_xy),
tf.reduce_sum(input_tensor=loss_wh),
tf.reduce_sum(input_tensor=loss_conf),
tf.reduce_sum(input_tensor=loss_class)
],
message='loss xy, wh, conf, class: \t',
summarize=1000)
return loss * self.grid_scale
def build_model(self, learning_rate=[0.001, 0.01]):
'''
Model - wide and deep - built using tflearn
'''
n_cc = len(self.continuous_columns)
n_categories = 1 # two categories: is_idv and is_not_idv
input_shape = [None, n_cc]
if self.verbose:
print("=" * 77 + " Model %s (type=%s)" %
(self.name, self.model_type))
print(" Input placeholder shape=%s" % str(input_shape))
wide_inputs = tflearn.input_data(shape=input_shape, name="wide_X")
if not isinstance(learning_rate, list):
learning_rate = [learning_rate, learning_rate] # wide, deep
if self.verbose:
print(" Learning rates (wide, deep)=%s" % learning_rate)
with tf.name_scope(
"Y"): # placeholder for target variable (i.e. trainY input)
Y_in = tf.placeholder(shape=[None, 1], dtype=tf.float32, name="Y")
with tf.variable_scope(None, "cb_unit", [wide_inputs]) as scope:
central_bias = tflearn.variables.variable(
'central_bias',
shape=[1],
initializer=tf.constant_initializer(np.random.randn()),
trainable=True,
restore=True)
tf.add_to_collection(tf.GraphKeys.LAYER_VARIABLES + '/cb_unit',
central_bias)
if 'wide' in self.model_type:
wide_network = self.wide_model(wide_inputs, n_cc)
network = wide_network
wide_network_with_bias = tf.add(wide_network,
central_bias,
name="wide_with_bias")
if 'deep' in self.model_type:
deep_network = self.deep_model(wide_inputs, n_cc)
deep_network_with_bias = tf.add(deep_network,
central_bias,
name="deep_with_bias")
if 'wide' in self.model_type:
network = tf.add(wide_network, deep_network)
if self.verbose:
print("Wide + deep model network %s" % network)
else:
network = deep_network
network = tf.add(network, central_bias, name="add_central_bias")
# add validation monitor summaries giving confusion matrix entries
with tf.name_scope('Monitors'):
predictions = tf.cast(tf.greater(network, 0), tf.int64)
print("predictions=%s" % predictions)
Ybool = tf.cast(Y_in, tf.bool)
print("Ybool=%s" % Ybool)
pos = tf.boolean_mask(predictions, Ybool)
neg = tf.boolean_mask(predictions, ~Ybool)
psize = tf.cast(tf.shape(pos)[0], tf.int64)
nsize = tf.cast(tf.shape(neg)[0], tf.int64)
true_positive = tf.reduce_sum(pos, name="true_positive")
false_negative = tf.subtract(psize,
true_positive,
name="false_negative")
false_positive = tf.reduce_sum(neg, name="false_positive")
true_negative = tf.subtract(nsize,
false_positive,
name="true_negative")
overall_accuracy = tf.truediv(tf.add(true_positive, true_negative),
tf.add(nsize, psize),
name="overall_accuracy")
vmset = [
true_positive, true_negative, false_positive, false_negative,
overall_accuracy
]
trainable_vars = tf.trainable_variables()
tv_deep = [v for v in trainable_vars if v.name.startswith('deep_')]
tv_wide = [v for v in trainable_vars if v.name.startswith('wide_')]
if self.verbose:
print("DEEP trainable_vars")
for v in tv_deep:
print(" Variable %s: %s" % (v.name, v))
print("WIDE trainable_vars")
for v in tv_wide:
print(" Variable %s: %s" % (v.name, v))
if 'wide' in self.model_type:
if not 'deep' in self.model_type:
tv_wide.append(central_bias)
tflearn.regression(
wide_network_with_bias,
placeholder=Y_in,
optimizer='sgd',
#loss='roc_auc_score',
loss='binary_crossentropy',
metric="accuracy",
learning_rate=learning_rate[0],
validation_monitors=vmset,
trainable_vars=tv_wide,
op_name="wide_regression",
name="Y")
if 'deep' in self.model_type:
if not 'wide' in self.model_type:
tv_wide.append(central_bias)
tflearn.regression(
deep_network_with_bias,
placeholder=Y_in,
optimizer='adam',
#loss='roc_auc_score',
loss='binary_crossentropy',
metric="accuracy",
learning_rate=learning_rate[1],
validation_monitors=vmset
if not 'wide' in self.model_type else None,
trainable_vars=tv_deep,
op_name="deep_regression",
name="Y")
if self.model_type == 'wide+deep': # learn central bias separately for wide+deep
tflearn.regression(
network,
placeholder=Y_in,
optimizer='adam',
loss='binary_crossentropy',
metric="accuracy",
learning_rate=learning_rate[0], # use wide learning rate
trainable_vars=[central_bias],
op_name="central_bias_regression",
name="Y")
self.model = tflearn.DNN(
network,
tensorboard_verbose=self.tensorboard_verbose,
max_checkpoints=5,
checkpoint_path="%s/%s.tfl" % (self.checkpoints_dir, self.name),
)
if self.verbose:
print("Target variables:")
for v in tf.get_collection(tf.GraphKeys.TARGETS):
print(" variable %s: %s" % (v.name, v))
print("=" * 77)
if isinstance(target_norm_value, float):
initial_norm = depth * [target_norm_value]
else:
initial_norm = target_norm_value
target_norm = slim.model_variable(
name='weights',
dtype=tf.float32,
initializer=tf.constant(initial_norm, dtype=tf.float32),
trainable=trainable)
if summarize:
mean = tf.reduce_mean(target_norm)
tf.summary.scalar(tf.get_variable_scope().name, mean)
lengths = epsilon + tf.sqrt(tf.reduce_sum(tf.square(inputs), dim, True))
mult_shape = input_rank*[1]
mult_shape[dim] = depth
return tf.reshape(target_norm, mult_shape) * tf.truediv(inputs, lengths)
def batch_position_sensitive_crop_regions(images,
boxes,
crop_size,
num_spatial_bins,
global_pool,
parallel_iterations=64):
"""Position sensitive crop with batches of images and boxes.
This op is exactly like `position_sensitive_crop_regions` below but operates
on batches of images and boxes. See `position_sensitive_crop_regions` function
below for the operation applied per batch element.
Args:
