Python keras.backend.ones_like() Examples
The following are code examples for showing how to use keras.backend.ones_like(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.
Example 1
| Project: deep-models Author: LaurentMazare File: rhn.py Apache License 2.0 | 6 votes |
|
def get_constants(self, x):
constants = []
if 0 < self.dropout_U < 1:
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.output_dim))
B_U = [K.in_train_phase(K.dropout(ones, self.dropout_U), ones) for _ in range(3)]
constants.append(B_U)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(3)])
if 0 < self.dropout_W < 1:
input_shape = self.input_spec[0].shape
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, input_dim))
B_W = [K.in_train_phase(K.dropout(ones, self.dropout_W), ones) for _ in range(3)]
constants.append(B_W)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(3)])
return constants
Example 2
| Project: keras_bn_library Author: bnsnapper File: rnnrbm.py MIT License | 6 votes |
|
def get_constants(self, x):
constants = []
if 0 < self.dropout_U < 1:
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.hidden_recurrent_dim))
B_U = K.in_train_phase(K.dropout(ones, self.dropout_U), ones)
constants.append(B_U)
else:
constants.append(K.cast_to_floatx(1.))
if self.consume_less == 'cpu' and 0 < self.dropout_W < 1:
input_shape = self.input_spec[0].shape
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, input_dim))
B_W = K.in_train_phase(K.dropout(ones, self.dropout_W), ones)
constants.append(B_W)
else:
constants.append(K.cast_to_floatx(1.))
return constants
Example 3
| Project: keras_bn_library Author: bnsnapper File: recurrent.py MIT License | 6 votes |
|
def get_constants(self, x): constants = [] if 0 < self.dropout_U < 1: ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1))) ones = K.tile(ones, (1, self.input_dim)) B_U = [K.in_train_phase(K.dropout(ones, self.dropout_U), ones) for _ in range(4)] constants.append(B_U) else: constants.append([K.cast_to_floatx(1.) for _ in range(4)]) if 0 < self.dropout_W < 1: input_shape = K.int_shape(x) input_dim = input_shape[-1] ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1))) ones = K.tile(ones, (1, int(input_dim))) B_W = [K.in_train_phase(K.dropout(ones, self.dropout_W), ones) for _ in range(4)] constants.append(B_W) else: constants.append([K.cast_to_floatx(1.) for _ in range(4)]) return constants
Example 4
| Project: yoctol-keras-layer-zoo Author: Yoctol File: rnn_cell.py GNU General Public License v3.0 | 6 votes |
|
def get_constants(self, inputs, training=None):
constants = self.recurrent_layer.get_constants(
inputs=inputs,
training=training
)
if 0 < self.dense_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.recurrent_layer.units))
def dropped_inputs():
return K.dropout(ones, self.dense_dropout)
out_dp_mask = [K.in_train_phase(dropped_inputs,
ones,
training=training)]
constants.append(out_dp_mask)
else:
constants.append([K.cast_to_floatx(1.)])
return constants
Example 5
| Project: cor-asv-ann Author: ASVLeipzig File: seq2seq.py Apache License 2.0 | 6 votes |
|
def _regularise_chars(self, embedding_matrix):
'''Calculate L2 loss of the char embedding weights
to control for underspecification at zero
(by interpolating between other embedding vectors).
'''
from keras import backend as K
em_dims = embedding_matrix.shape.as_list()
if em_dims[0] == 0: # voc_size starts with 0 before first training
return 0
vec0 = K.slice(embedding_matrix, [0, 0], [1, em_dims[1]]) # zero vector only,
#vec0 = K.repeat_elements(vec0, em_dims[0]-1, axis=0) # repeated
vecs = K.slice(embedding_matrix, [1, 0], [em_dims[0]-1, em_dims[1]]) # all vectors except zero
# make sure only vec0 is affected, i.e. vecs change only via global loss:
vecs = K.stop_gradient(K.mean(vecs, axis=0))
# scale to make gradients benign:
underspecification = 1 * K.sum(K.square(vec0 - vecs)) # c='\0' ~ mean of others
#lowrank = K.sum(0.01 * K.square(embedding_matrix)) # generalization/sparsity
norms = K.sum(K.square(embedding_matrix), axis=1)
norm0 = K.ones_like(norms) # square of target (non-zero) weight norm
lowrank = 0.01 * K.sum(K.square(norm0 - norms))
return K.in_train_phase(lowrank + underspecification, 0.)
Example 6
| Project: NTM-Keras Author: SigmaQuan File: lstm2ntm.py MIT License | 6 votes |
|
def get_constants(self, x):
constants = []
if 0 < self.dropout_U < 1:
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.output_dim))
B_U = [K.in_train_phase(K.dropout(ones, self.dropout_U), ones) for _ in range(4)]
constants.append(B_U)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
if 0 < self.dropout_W < 1:
input_shape = self.input_spec[0].shape
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, int(input_dim)))
B_W = [K.in_train_phase(K.dropout(ones, self.dropout_W), ones) for _ in range(4)]
constants.append(B_W)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
return constants
Example 7
| Project: RPGOne Author: RTHMaK File: bigru_index_selector.py Apache License 2.0 | 6 votes |
|
def call(self, inputs, mask=None):
"""
Extract the GRU output for the target document index for the forward
and backwards GRU outputs, and then concatenate them. If the target word index
is at index l, and there are T total document words, the desired output
in the forward pass is at GRU_f[l] (ignoring the batched case) and the
desired output of the backwards pass is at GRU_b[T-l].
We need to get these two vectors and concatenate them. To do so, we'll
reverse the backwards GRU, which allows us to use the same index/mask for both.
"""
# TODO(nelson): deal with case where cloze token appears multiple times
# in a question.
word_indices, gru_f, gru_b = inputs
index_mask = K.cast(K.equal((K.ones_like(word_indices) * self.target_index),
word_indices), "float32")
gru_mask = K.repeat_elements(K.expand_dims(index_mask, -1), K.int_shape(gru_f)[-1], K.ndim(gru_f) - 1)
masked_gru_f = switch(gru_mask, gru_f, K.zeros_like(gru_f))
selected_gru_f = K.sum(masked_gru_f, axis=1)
masked_gru_b = switch(gru_mask, gru_b, K.zeros_like(gru_b))
selected_gru_b = K.sum(masked_gru_b, axis=1)
selected_bigru = K.concatenate([selected_gru_f, selected_gru_b], axis=-1)
return selected_bigru
Example 8
| Project: ColiCoords Author: Jhsmit File: losses.py MIT License | 6 votes |
|
def weighted_dice_loss(y_true, y_pred):
y_true = K.cast(y_true, 'float32')
y_pred = K.cast(y_pred, 'float32')
# if we want to get same size of output, kernel size must be odd number
if K.int_shape(y_pred)[1] == 128:
kernel_size = 11
elif K.int_shape(y_pred)[1] == 256:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 512:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 1024:
kernel_size = 41
else:
raise ValueError('Unexpected image size')
averaged_mask = K.pool2d(
y_true, pool_size=(kernel_size, kernel_size), strides=(1, 1), padding='same', pool_mode='avg')
border = K.cast(K.greater(averaged_mask, 0.005), 'float32') * K.cast(K.less(averaged_mask, 0.995), 'float32')
weight = K.ones_like(averaged_mask)
w0 = K.sum(weight)
weight += border * 2
w1 = K.sum(weight)
weight *= (w0 / w1)
loss = 1 - weighted_dice_coeff(y_true, y_pred, weight)
return loss
Example 9
| Project: ColiCoords Author: Jhsmit File: losses.py MIT License | 6 votes |
|
def weighted_bce_dice_loss(y_true, y_pred):
y_true = K.cast(y_true, 'float32')
y_pred = K.cast(y_pred, 'float32')
# if we want to get same size of output, kernel size must be odd number
if K.int_shape(y_pred)[1] == 128:
kernel_size = 11
elif K.int_shape(y_pred)[1] == 256:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 512:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 1024:
kernel_size = 41
else:
raise ValueError('Unexpected image size')
averaged_mask = K.pool2d(
y_true, pool_size=(kernel_size, kernel_size), strides=(1, 1), padding='same', pool_mode='avg')
border = K.cast(K.greater(averaged_mask, 0.005), 'float32') * K.cast(K.less(averaged_mask, 0.995), 'float32')
weight = K.ones_like(averaged_mask)
w0 = K.sum(weight)
weight += border * 2
w1 = K.sum(weight)
weight *= (w0 / w1)
loss = weighted_bce_loss(y_true, y_pred, weight) + (1 - weighted_dice_coeff(y_true, y_pred, weight))
return loss
Example 10
| Project: keras-training Author: hls-fpga-machine-learning File: quantized_ops.py GNU General Public License v3.0 | 6 votes |
|
def _ternarize(W, H=1):
'''The weights' ternarization function,
# References:
- [Recurrent Neural Networks with Limited Numerical Precision](http://arxiv.org/abs/1608.06902)
- [Ternary Weight Networks](http://arxiv.org/abs/1605.04711)
'''
W /= H
ones = K.ones_like(W)
zeros = K.zeros_like(W)
Wt = switch(W > 0.5, ones, switch(W <= -0.5, -ones, zeros))
Wt *= H
return Wt
Example 11
| Project: face-swap Author: 5agado File: gan_utils.py Apache License 2.0 | 6 votes |
|
def define_loss(netD, real, fake, vggface_feat=None, mixup_alpha=None, use_lsgan=True):
loss_fn = get_loss_fun(use_lsgan)
if mixup_alpha:
dist = Beta(mixup_alpha, mixup_alpha)
lam = dist.sample()
mixup = lam * real + (1 - lam) * fake
output_mixup = netD(mixup)
loss_D = loss_fn(output_mixup, lam * K.ones_like(output_mixup))
output_fake = netD(fake) # dummy
loss_G = .5 * loss_fn(output_mixup, (1 - lam) * K.ones_like(output_mixup))
else:
output_real = netD(real) # positive sample
output_fake = netD(fake) # negative sample
loss_D_real = loss_fn(output_real, K.ones_like(output_real))
loss_D_fake = loss_fn(output_fake, K.zeros_like(output_fake))
loss_D = loss_D_real + loss_D_fake
loss_G = .5 * loss_fn(output_fake, K.ones_like(output_fake))
loss_G += K.mean(K.abs(fake - real))
if not vggface_feat is None:
loss_G = add_perceptual_loss(loss_G, real=real, fake=fake, vggface_feat=vggface_feat)
return loss_D, loss_G
Example 12
| Project: smach_based_introspection_framework Author: birlrobotics File: layer_utils.py BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def get_constants(self, inputs, training=None):
constants = []
if self.implementation != 0 and 0 < self.dropout < 1:
input_shape = K.int_shape(inputs)
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, int(input_dim)))
def dropped_inputs():
return K.dropout(ones, self.dropout)
dp_mask = [K.in_train_phase(dropped_inputs,
ones,
training=training) for _ in range(4)]
constants.append(dp_mask)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
if 0 < self.recurrent_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.units))
def dropped_inputs():
return K.dropout(ones, self.recurrent_dropout)
rec_dp_mask = [K.in_train_phase(dropped_inputs,
ones,
training=training) for _ in range(4)]
constants.append(rec_dp_mask)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
# append the input as well for use later
constants.append(inputs)
return constants
Example 13
| Project: CapsAttnNet Author: rstager File: canlayer.py MIT License | 5 votes |
|
def _part_to_whole_predictions(self, x):
"""
Estimate the pose of the whole given the pose of the part.
:param x: set of poses to transform
"""
# inputs.shape=[ input_num_capsule, input_num_instance, input_dim_capsule]
# output.shape=[num_instance*num_capsule, num_parts*input_num_capsule*input_num_instance,dim_capsule]
# xt.shape = [ input_num_capsule, num_instance, input_num_instance, input_dim_capsule]
# xpart.shape = [ num_instance, input_num_instance, num_capsule, num_part, dim_x,input_num_capsule]
# gpose.shape = [ input_num_capsule, num_instance, input_num_instance, dim_geom+1]
xt = K.tile(K.expand_dims(x,1),[1,self.num_instance,1,1])
tmp = K.reshape( xt[:,:,:,:1],[self.input_num_capsule,self.num_instance,self.input_num_instance,1,1,1])
tmp = K.tile(tmp,[1,1,1,self.num_capsule,self.num_part,1])
ppart=K.permute_dimensions(tmp,[1,2,3,4,5,0])
gpose = K.concatenate([xt[:,:,:,1:dim_geom+1],K.ones_like(xt[:,:,:,:1])]) # add 1 col to allow x-y translate
gpart = K.concatenate([K.expand_dims(K.dot(gpose[i],self.W1[i]),-1) for i in range(self.input_num_capsule)])
apart = K.concatenate([K.expand_dims(K.dot(xt[i,:,:,dim_geom+1:],self.W2[i]),-1) for i in range(self.input_num_capsule)])
whole=K.concatenate([ppart,gpart,apart],4)
output=K.permute_dimensions(whole,[0,2,3,5,1,4])
output=K.reshape(output,[self.num_instance*self.num_capsule,
self.num_part*self.input_num_capsule*self.input_num_instance,self.dim_capsule])
# output = tf.Print(output, [tf.shape(x)], message='x', summarize=16)
# output = tf.Print(output, [x[0,18,1:3]], message='x ', summarize=3)
# output = tf.Print(output, [gpose[0,0,0,:]], message='x gpose ', summarize=5)
# output = tf.Print(output, [gpose[0,1,0,:]], message='x gpose ', summarize=5)
# output = tf.Print(output, [gpart[0,0,0,0,0,:]], message='x gpart ', summarize=5)
# output = tf.Print(output, [gpart[0,1,0,0,0,:]], message='x gpart ', summarize=5)
return output
Example 14
| Project: keras-minimal-rnn Author: titu1994 File: minimal_rnn.py MIT License | 5 votes |
|
def _generate_dropout_mask(self, inputs, training=None):
if 0 < self.dropout < 1:
ones = K.ones_like(K.squeeze(inputs[:, 0:1, :], axis=1))
def dropped_inputs():
return K.dropout(ones, self.dropout)
self._dropout_mask = [K.in_train_phase(
dropped_inputs,
ones,
training=training)
for _ in range(1)]
else:
self._dropout_mask = None
Example 15
| Project: keras-minimal-rnn Author: titu1994 File: minimal_rnn.py MIT License | 5 votes |
|
def _generate_recurrent_dropout_mask(self, inputs, training=None):
if 0 < self.recurrent_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.units))
def dropped_inputs():
return K.dropout(ones, self.dropout)
self._recurrent_dropout_mask = [K.in_train_phase(
dropped_inputs,
ones,
training=training)
for _ in range(2)]
else:
self._recurrent_dropout_mask = None
Example 16
| Project: cbc_networks Author: saralajew File: detection_probability_functions.py BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def call(self, inputs, **kwargs):
# Both components and input given
if isinstance(inputs, list) and len(inputs) > 1:
signals, kernel = inputs
else:
signals = inputs
kernel = self.components.astype(K.floatx())
# move component_number to channel dimension
kernel = K.permute_dimensions(kernel, (1, 2, 3, 0))
# normalize kernel
kernel_norm = K.sum(K.square(kernel), (0, 1, 2), keepdims=True)
# get norm of signals
signals_norm = K.conv2d(K.square(signals),
K.ones_like(kernel),
strides=self.strides,
padding=self.padding,
data_format='channels_last',
dilation_rate=self.dilation_rate)
diss = kernel_norm \
- 2 * K.conv2d(signals,
kernel,
strides=self.strides,
padding=self.padding,
data_format='channels_last',
dilation_rate=self.dilation_rate) \
+ signals_norm
if self.n_replicas != 1:
shape = K.int_shape(diss)
diss = K.reshape(diss, (-1, shape[1], shape[2],
shape[3] // self.n_replicas,
self.n_replicas))
return self.activation(diss)
Example 17
| Project: MCF-3D-CNN Author: xyj77 File: liver_model.py MIT License | 5 votes |
|
def mycrossentropy(self, y_true, y_pred):
e = 0.3
# for i in range(y_true.shape[0]):
# for j in range(3):
# sum += 0.1*(-1**y_true(i,j))*exp(abs(np.argmax(y_true[i,:])-j))*log(y_pred(i,j))
# return sum/len
# y = np.argmax(y_true, axis=1)
# y_ = np.argmax(y_pred, axis=1)
# print '*****************',y_pred
# return (1-e)*K.categorical_crossentropy(y_pred,y_true) - e*K.categorical_crossentropy(y_pred, (1-y_true)/(self.config.classes-1))
return (1-e)*K.categorical_crossentropy(y_pred,y_true) + e*K.categorical_crossentropy(y_pred, K.ones_like(y_pred)/2)
Example 18
| Project: group-ksparse-temporal-cnns Author: srph25 File: layers.py MIT License | 5 votes |
|
def call(self, inputs, states, training=None):
if 0 < self.dropout < 1 and self._dropout_mask is None:
self._dropout_mask = _generate_dropout_mask(
K.ones_like(inputs),
self.dropout,
training=training,
count=1)
if (0 < self.recurrent_dropout < 1 and
self._recurrent_dropout_mask is None):
self._recurrent_dropout_mask = _generate_dropout_mask(
K.ones_like(states[0]),
self.recurrent_dropout,
training=training,
count=1)
# dropout matrices for input units
dp_mask = self._dropout_mask
# dropout matrices for recurrent units
rec_dp_mask = self._recurrent_dropout_mask
h_tm1 = states[0] # previous memory state
if 0 < self.dropout < 1.:
inputs = inputs * dp_mask[0]
if 0 < self.recurrent_dropout < 1.:
h_tm1 = h_tm1 * rec_dp_mask[0]
u1 = self.input_conv(inputs, self.kernel, self.bias, padding=self.padding)
u2 = self.recurrent_conv(h_tm1, self.recurrent_kernel)
u = self.recurrent_activation(u1 + u2)
h = (1 - u) * h_tm1 + u * inputs
if 0 < self.dropout + self.recurrent_dropout:
if training is None:
h._uses_learning_phase = True
return h, [h]
Example 19
| Project: yoctol-keras-layer-zoo Author: Yoctol File: rnn_decoder.py GNU General Public License v3.0 | 5 votes |
|
def compute_mask(self, inputs, mask):
output_mask = self.layer.compute_mask(
inputs=inputs,
mask=mask,
)
if self.time_steps is None:
return output_mask
else:
output_mask = K.ones_like(output_mask)
output_mask = K.any(output_mask, axis=1, keepdims=True)
return K.tile(output_mask, [1, self.time_steps])
Example 20
| Project: NTM-Keras Author: SigmaQuan File: ntm.py MIT License | 5 votes |
|
def get_constants(self, x):
print("begin get_constants(self, x)")
constants = []
if 0 < self.dropout_U < 1:
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.controller_output_dim))
B_U = [K.in_train_phase(K.dropout(ones, self.dropout_U), ones) for _ in range(4)]
constants.append(B_U)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
if 0 < self.dropout_W < 1:
input_shape = self.input_spec[0].shape
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, int(input_dim)))
B_W = [K.in_train_phase(K.dropout(ones, self.dropout_W), ones) for _ in range(4)]
constants.append(B_W)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
# if 0 < self.dropout_R < 1:
# input_shape = self.input_spec[0].shape
# input_dim = input_shape[-1]
# ones = K.ones_like(K.reshape(x[:, 0, 0], (-1, 1)))
# ones = K.tile(ones, (1, int(input_dim)))
# B_R = [K.in_train_phase(K.dropout(ones, self.dropout_R), ones) for _ in range(4)]
# constants.append(B_R)
# else:
# constants.append([K.cast_to_floatx(1.) for _ in range(4)])
print("end get_constants(self, x)")
return constants
Example 21
| Project: FSA-Net Author: shamangary File: layers.py Apache License 2.0 | 5 votes |
|
def _make_regular_grids(self, batch_size, height, width):
# making a single regular grid
x_linspace = K_linspace(-1., 1., width)
y_linspace = K_linspace(-1., 1., height)
x_coordinates, y_coordinates = K_meshgrid(x_linspace, y_linspace)
x_coordinates = K.flatten(x_coordinates)
y_coordinates = K.flatten(y_coordinates)
ones = K.ones_like(x_coordinates)
grid = K.concatenate([x_coordinates, y_coordinates, ones], 0)
# repeating grids for each batch
grid = K.flatten(grid)
grids = K.tile(grid, K.stack([batch_size]))
return K.reshape(grids, (batch_size, 3, height * width))
Example 22
| Project: RPGOne Author: RTHMaK File: backend.py Apache License 2.0 | 5 votes |
|
def very_negative_like(tensor):
return K.ones_like(tensor) * VERY_NEGATIVE_NUMBER
Example 23
| Project: RPGOne Author: RTHMaK File: backend.py Apache License 2.0 | 5 votes |
|
def tile_vector(vector, matrix):
"""
NOTE: If your matrix has known shape (i.e., the relevant dimension from `K.int_shape(matrix) is
not None`), you should just use `K.repeat_elements(vector)` instead of this. This method
works, however, when the number of rows in your matrix is unknown at graph compilation time.
This method takes a (collection of) vector(s) (shape: (batch_size, vector_dim)), and tiles that
vector a number of times, giving a matrix of shape (batch_size, tile_length, vector_dim). (I
say "vector" and "matrix" here because I'm ignoring the batch_size). We need the matrix as
input so we know what the tile_length is - the matrix is otherwise ignored.
This is necessary in a number of places in the code. For instance, if you want to do a dot
product of a vector with all of the vectors in a matrix, the most efficient way to do that is
to tile the vector first, then do an element-wise product with the matrix, then sum out the
last mode. So, we capture this functionality here.
This is not done as a Keras Layer, however; if you want to use this function, you'll need to do
it _inside_ of a Layer somehow, either in a Lambda or in the call() method of a Layer you're
writing.
"""
# Tensorflow can't use unknown sizes at runtime, so we have to make use of the broadcasting
# ability of TF and Theano instead to create the tiled sentence encoding.
# Shape: (tile_length, batch_size, vector_dim)
k_ones = K.permute_dimensions(K.ones_like(matrix), [1, 0, 2])
# Now we have a (tile_length, batch_size, vector_dim)*(batch_size, vector_dim)
# elementwise multiplication which is broadcast. We then reshape back.
tiled_vector = K.permute_dimensions(k_ones * vector, [1, 0, 2])
return tiled_vector
Example 24
| Project: RPGOne Author: RTHMaK File: backend.py Apache License 2.0 | 5 votes |
|
def tile_scalar(scalar, vector):
"""
NOTE: If your vector has known shape (i.e., the relevant dimension from `K.int_shape(vector) is
not None`), you should just use `K.repeat_elements(scalar)` instead of this. This method
works, however, when the number of entries in your vector is unknown at graph compilation time.
This method takes a (collection of) scalar(s) (shape: (batch_size, 1)), and tiles that
scala a number of times, giving a vector of shape (batch_size, tile_length). (I say "scalar"
and "vector" here because I'm ignoring the batch_size). We need the vector as input so we know
what the tile_length is - the vector is otherwise ignored.
This is not done as a Keras Layer, however; if you want to use this function, you'll need to do
it _inside_ of a Layer somehow, either in a Lambda or in the call() method of a Layer you're
writing.
TODO(matt): we could probably make a more general `tile_tensor` method, which can do this for
any dimenionsality. There is another place in the code where we do this with a matrix and a
tensor; all three of these can probably be one function.
"""
# Tensorflow can't use unknown sizes at runtime, so we have to make use of the broadcasting
# ability of TF and Theano instead to create the tiled sentence encoding.
# Shape: (tile_length, batch_size)
k_ones = K.permute_dimensions(K.ones_like(vector), [1, 0])
# Now we have a (tile_length, batch_size) * (batch_size, 1) elementwise multiplication which is
# broadcast. We then reshape back.
tiled_scalar = K.permute_dimensions(k_ones * K.squeeze(scalar, axis=1), [1, 0])
return tiled_scalar
Example 25
| Project: RPGOne Author: RTHMaK File: matrix_attention.py Apache License 2.0 | 5 votes |
|
def compute_mask(self, inputs, mask=None):
# pylint: disable=unused-argument
mask_1, mask_2 = mask
if mask_1 is None and mask_2 is None:
return None
if mask_1 is None:
mask_1 = K.ones_like(K.sum(inputs[0], axis=-1))
if mask_2 is None:
mask_2 = K.ones_like(K.sum(inputs[1], axis=-1))
# Theano can't do batch_dot on ints, so we need to cast to float and then back.
mask_1 = K.cast(K.expand_dims(mask_1, axis=2), 'float32')
mask_2 = K.cast(K.expand_dims(mask_2, axis=1), 'float32')
return K.cast(K.batch_dot(mask_1, mask_2), 'uint8')
Example 26
| Project: RPGOne Author: RTHMaK File: overlap.py Apache License 2.0 | 5 votes |
|
def call(self, inputs, mask=None):
# tensor_a, mask_a are of shape (batch size, length_a)
# tensor_b mask_b are of shape (batch size, length_b)
tensor_a, tensor_b = inputs
if mask is None:
mask_b = K.ones_like(tensor_b)
else:
mask_b = mask[1]
length_a = K.int_shape(tensor_a)[1]
length_b = K.int_shape(tensor_b)[1]
# change the indices that are masked in b to -1, since no indices
# in the document will ever be -1.
tensor_b = K.cast(switch(mask_b, tensor_b, -1*K.ones_like(tensor_b)), "int32")
# reshape tensor_a to shape (batch_size, length_a, length_b)
tensor_a_tiled = K.repeat_elements(K.expand_dims(tensor_a, 2),
length_b,
axis=2)
# reshape tensor_b to shape (batch_size, length_a, length_b)
tensor_b_tiled = K.repeat_elements(K.expand_dims(tensor_b, 1),
length_a,
axis=1)
overlap_mask = K.cast(K.equal(tensor_a_tiled, tensor_b_tiled), "float32")
indices_overlap = K.sum(overlap_mask, axis=-1)
binary_indices_overlap = K.cast(K.not_equal(indices_overlap,
K.zeros_like(indices_overlap)),
"int32")
one_hot_overlap = K.cast(K.one_hot(binary_indices_overlap, 2), "float32")
return one_hot_overlap
Example 27
| Project: RPGOne Author: RTHMaK File: vector_matrix_merge.py Apache License 2.0 | 5 votes |
|
def compute_mask(self, inputs, mask=None):
if mask is None or all(m is None for m in mask) or not self.propagate_mask:
return None
print(mask)
num_vectors = len(mask) - 1
matrix_mask = K.cast(mask[-1], 'uint8')
# We're just trying to get a mask of the right shape, here, so we can call K.ones_like() on
# it. We'll ignore the actual values in this.
vector_mask_template = K.sum(matrix_mask, axis=self.mask_concat_axis)
vector_mask = K.expand_dims(K.ones_like(vector_mask_template), axis=self.mask_concat_axis)
result_mask = matrix_mask
for _ in range(num_vectors):
result_mask = K.concatenate([vector_mask, result_mask], axis=self.mask_concat_axis)
return K.cast(result_mask, 'bool')
Example 28
| Project: RPGOne Author: RTHMaK File: multiply.py Apache License 2.0 | 5 votes |
|
def compute_mask(self, inputs, mask=None):
# pylint: disable=unused-argument
tensor_1, tensor_2 = inputs
tensor_1_mask, tensor_2_mask = mask
if tensor_1_mask is None:
tensor_1_mask = K.ones_like(tensor_1)
if tensor_2_mask is None:
tensor_2_mask = K.ones_like(tensor_2)
tensor_1_mask, tensor_2_mask = self.expand_dims_if_necessary(tensor_1_mask, tensor_2_mask)
return K.cast(tensor_1_mask, 'uint8') * K.cast(tensor_2_mask, 'uint8')
Example 29
| Project: Keras-FCN-template Author: MchZys File: losses.py BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def weighted_bce_dice_loss(y_true, y_pred):
y_true = K.cast(y_true, 'float32')
y_pred = K.cast(y_pred, 'float32')
# if we want to get same size of output, kernel size must be odd
averaged_mask = K.pool2d(
y_true, pool_size=(50, 50), strides=(1, 1), padding='same', pool_mode='avg')
weight = K.ones_like(averaged_mask)
w0 = K.sum(weight)
weight = 5. * K.exp(-5. * K.abs(averaged_mask - 0.5))
w1 = K.sum(weight)
weight *= (w0 / w1)
loss = weighted_bce_loss(y_true, y_pred, weight) + dice_loss(y_true, y_pred)
return loss
Example 30
| Project: stochastic_depth_keras Author: dblN File: train.py MIT License | 5 votes |
|
def residual_drop(x, input_shape, output_shape, strides=(1, 1)):
global add_tables
nb_filter = output_shape[0]
conv = Convolution2D(nb_filter, 3, 3, subsample=strides,
border_mode="same", W_regularizer=l2(weight_decay))(x)
conv = BatchNormalization(axis=1)(conv)
conv = Activation("relu")(conv)
conv = Convolution2D(nb_filter, 3, 3,
border_mode="same", W_regularizer=l2(weight_decay))(conv)
conv = BatchNormalization(axis=1)(conv)
if strides[0] >= 2:
x = AveragePooling2D(strides)(x)
if (output_shape[0] - input_shape[0]) > 0:
pad_shape = (1,
output_shape[0] - input_shape[0],
output_shape[1],
output_shape[2])
padding = K.zeros(pad_shape)
padding = K.repeat_elements(padding, K.shape(x)[0], axis=0)
x = Lambda(lambda y: K.concatenate([y, padding], axis=1),
output_shape=output_shape)(x)
_death_rate = K.variable(death_rate)
scale = K.ones_like(conv) - _death_rate
conv = Lambda(lambda c: K.in_test_phase(scale * c, c),
output_shape=output_shape)(conv)
out = merge([conv, x], mode="sum")
out = Activation("relu")(out)
gate = K.variable(1, dtype="uint8")
add_tables += [{"death_rate": _death_rate, "gate": gate}]
return Lambda(lambda tensors: K.switch(gate, tensors[0], tensors[1]),
output_shape=output_shape)([out, x])
Example 31
| Project: qkeras Author: google File: qlayers.py Apache License 2.0 | 5 votes |
|
def __call__(self, x):
# we right now use the following distributions for fm1, f0, fp1
#
# fm1 = ((1-T)-p)/(1-T) for p <= (1-T)
# f0 = 2*p/clip(0.5+T,0.5,1.0) for p <= 0.5
# 2*(1-p)/clip(0.5+T,0.5,1.0) for p > 0.5
# fp1 = (p-T)/(1-T) for p >= T
#
# threshold (1-T) determines the spread of -1 and +1
# for T < 0.5 we need to fix the distribution of f0
# to make it bigger when compared to the other
# distributions.
p = _sigmoid(x / self.alpha) # pylint: disable=invalid-name
T = self.threshold # pylint: disable=invalid-name
ones = K.ones_like(p)
zeros = K.zeros_like(p)
T0 = np.clip(0.5 + T, 0.5, 1.0) # pylint: disable=invalid-name
fm1 = tf.where(p <= (1 - T), ((1 - T) - p) / (1 - T), zeros)
f0 = tf.where(p <= 0.5, 2 * p, 2 * (1 - p)) / T0
fp1 = tf.where(p <= T, zeros, (p - T) / (1 - T))
f_all = fm1 + f0 + fp1
c_fm1 = fm1 / f_all
c_f0 = (fm1 + f0) / f_all
r = K.random_uniform(K.shape(p))
return x + K.stop_gradient(-x + self.alpha * tf.where(
r <= c_fm1, -1 * ones, tf.where(r <= c_f0, zeros, ones)))
Example 32
| Project: Keras-IndRNN Author: titu1994 File: ind_rnn.py MIT License | 5 votes |
|
def call(self, inputs, states, training=None):
if 0 < self.dropout < 1 and self._dropout_mask is None:
self._dropout_mask = _generate_dropout_mask(
K.ones_like(inputs),
self.dropout,
training=training,
count=1)
if (0 < self.recurrent_dropout < 1 and
self._recurrent_masks is None):
_recurrent_mask = _generate_dropout_mask(
K.ones_like(states[0]),
self.recurrent_dropout,
training=training,
count=1)
self._recurrent_masks = _recurrent_mask
# dropout matrices for input units
dp_mask = self._dropout_mask
# dropout matrices for recurrent units
rec_dp_masks = self._recurrent_masks
h_tm1 = states[0] # previous state
if 0. < self.dropout < 1.:
inputs *= dp_mask[0]
if 0. < self.recurrent_dropout < 1.:
h_tm1 *= rec_dp_masks[0]
h = K.dot(inputs, self.kernel)
h = h + (h_tm1 * self.recurrent_kernel)
if self.use_bias:
h = K.bias_add(h, self.bias)
h = self.activation(h)
if 0 < self.dropout + self.recurrent_dropout:
if training is None:
h._uses_learning_phase = True
return h, [h]
Example 33
| Project: adversarial-variational-bayes Author: gdikov File: losses.py MIT License | 5 votes |
|
def discriminator_loss(discrim_output_prior, discrim_output_posterior, from_logits=False):
if from_logits:
discrim_output_posterior = ker.sigmoid(discrim_output_posterior)
discrim_output_prior = ker.sigmoid(discrim_output_prior)
# The dicriminator loss is the GAN loss with input from the prior and posterior distributions
discriminator_loss = ker.mean(binary_crossentropy(y_pred=discrim_output_posterior,
y_true=ker.ones_like(discrim_output_posterior))
+ binary_crossentropy(y_pred=discrim_output_prior,
y_true=ker.zeros_like(discrim_output_prior)))
return discriminator_loss
Example 34
| Project: Nested-LSTM Author: titu1994 File: nested_lstm.py MIT License | 5 votes |
|
def call(self, inputs, states, training=None):
if 0 < self.dropout < 1 and self._dropout_mask is None:
self._dropout_mask = _generate_dropout_mask(
K.ones_like(inputs),
self.dropout,
training=training,
count=1)
if (0 < self.recurrent_dropout < 1 and
self._nested_recurrent_masks is None):
_nested_recurrent_mask = _generate_dropout_mask(
K.ones_like(states[0]),
self.recurrent_dropout,
training=training,
count=self.depth)
self._nested_recurrent_masks = _nested_recurrent_mask
# dropout matrices for input units
dp_mask = self._dropout_mask
# dropout matrices for recurrent units
rec_dp_masks = self._nested_recurrent_masks
h_tm1 = states[0] # previous memory state
c_tm1 = states[1:self.depth + 1] # previous carry states
if 0. < self.dropout < 1.:
inputs *= dp_mask[0]
h, c = self.nested_recurrence(inputs,
hidden_state=h_tm1,
cell_states=c_tm1,
recurrent_masks=rec_dp_masks,
current_depth=0)
if 0 < self.dropout + self.recurrent_dropout:
if training is None:
h._uses_learning_phase = True
return h, c
Example 35
| Project: dynamic_memory_networks_with_keras Author: vchudinov File: attention_cells.py GNU General Public License v3.0 | 5 votes |
|
def _generate_dropout_mask(self, inputs, training=None):
if 0 < self.dropout < 1:
ones = K.ones_like(K.squeeze(inputs[:, 0:1, :-1], axis=1))
def dropped_inputs():
return K.dropout(ones, self.dropout)
self._dropout_mask = [K.in_train_phase(
dropped_inputs,
ones,
training=training)
for _ in range(3)]
else:
self._dropout_mask = None
Example 36
| Project: dynamic_memory_networks_with_keras Author: vchudinov File: attention_cells.py GNU General Public License v3.0 | 5 votes |
|
def _generate_recurrent_dropout_mask(self, inputs, training=None):
if 0 < self.recurrent_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.units))
def dropped_inputs():
return K.dropout(ones, self.dropout)
self._recurrent_dropout_mask = [K.in_train_phase(
dropped_inputs,
ones,
training=training)
for _ in range(3)]
else:
self._recurrent_dropout_mask = None
Example 37
| Project: keras-training Author: hls-fpga-machine-learning File: quantized_layers.py GNU General Public License v3.0 | 5 votes |
|
def get_constants(self, inputs, training=None):
constants = []
if 0 < self.dropout < 1:
input_shape = K.int_shape(inputs)
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, int(input_dim)))
def dropped_inputs():
return K.dropout(ones, self.dropout)
dp_mask = K.in_train_phase(dropped_inputs,
ones,
training=training)
constants.append(dp_mask)
else:
constants.append(K.cast_to_floatx(1.))
if 0 < self.recurrent_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.units))
def dropped_inputs():
return K.dropout(ones, self.recurrent_dropout)
rec_dp_mask = K.in_train_phase(dropped_inputs,
ones,
training=training)
constants.append(rec_dp_mask)
else:
constants.append(K.cast_to_floatx(1.))
return constants
Example 38
| Project: MMdnn Author: microsoft File: utils.py MIT License | 5 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
# yolo_outputs order 13,26,52
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
for i in range(0,3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[i],
anchors[6-3*i:9-3*i], num_classes, input_shape, image_shape)
if i==0:
boxes, box_scores = _boxes, _box_scores
else:
boxes = K.concatenate([boxes,_boxes], axis=0)
box_scores = K.concatenate([box_scores,_box_scores], axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
for i in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, i])
class_box_scores = tf.boolean_mask(box_scores[:, i], mask[:, i])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * i
if i==0:
boxes_, scores_, classes_ = class_boxes, class_box_scores, classes
else:
boxes_ = K.concatenate([boxes_,class_boxes], axis=0)
scores_ = K.concatenate([scores_,class_box_scores], axis=0)
classes_ = K.concatenate([classes_,classes], axis=0)
return boxes_, scores_, classes_
Example 39
| Project: LSTM-FCN Author: ShobhitLamba File: layer_utils.py MIT License | 5 votes |
|
def get_constants(self, inputs, training=None):
constants = []
if self.implementation != 0 and 0 < self.dropout < 1:
input_shape = K.int_shape(inputs)
input_dim = input_shape[-1]
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, int(input_dim)))
def dropped_inputs():
return K.dropout(ones, self.dropout)
dp_mask = [K.in_train_phase(dropped_inputs,
ones,
training=training) for _ in range(4)]
constants.append(dp_mask)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
if 0 < self.recurrent_dropout < 1:
ones = K.ones_like(K.reshape(inputs[:, 0, 0], (-1, 1)))
ones = K.tile(ones, (1, self.units))
def dropped_inputs():
return K.dropout(ones, self.recurrent_dropout)
rec_dp_mask = [K.in_train_phase(dropped_inputs,
ones,
training=training) for _ in range(4)]
constants.append(rec_dp_mask)
else:
constants.append([K.cast_to_floatx(1.) for _ in range(4)])
# append the input as well for use later
constants.append(inputs)
return constants
Example 40
| Project: keras-transformer Author: kpot File: transformer.py MIT License | 5 votes |
|
def initialize_control_tensors(self, halting):
"""
Initializes constants and some step-tracking variables
during the first call of the layer (since for the Universal Transformer
all the following calls are supposed to be with inputs of identical
shapes).
"""
self.zeros_like_halting = K.zeros_like(
halting, name='zeros_like_halting')
self.ones_like_halting = K.ones_like(
halting, name='ones_like_halting')
self.remainder = self.ones_like_halting
self.active_steps = self.zeros_like_halting
self.halt_budget = self.ones_like_halting - self.halt_epsilon
Example 41
| Project: deep-mlsa Author: spinningbytes File: evaluation_metrics.py Apache License 2.0 | 5 votes |
|
def f1_score_keras(y_true, y_pred):
# convert probas to 0,1
y_pred_ones = K.zeros_like(y_true)
# y_pred_ones[:, K.argmax(y_pred, axis=-1)] = 1
# indices_x = K.arange(start=0, stop=y_true.get_shape()[0])
indices_x = K.expand_dims(K.arange(start=0, stop=tf.shape(y_true)[0], dtype='int64'), dim=-1)
indices_y = K.expand_dims(K.argmax(y_pred, axis=-1), dim=-1)
indices = K.concatenate((indices_x, indices_y))
values = K.sum(K.ones_like(indices_x, dtype='float32'), axis=-1)
shape = K.cast(tf.shape(y_pred_ones), dtype='int64')
delta = tf.SparseTensor(indices, values, shape)
y_pred_ones = y_pred_ones + tf.sparse_tensor_to_dense(delta)
# where y_ture=1 and y_pred=1 -> true positive
y_true_pred = K.sum(y_true * y_pred_ones, axis=0)
# for each class: how many where classified as said class
pred_cnt = K.sum(y_pred_ones, axis=0)
# for each class: how many are true members of said class
gold_cnt = K.sum(y_true, axis=0)
# precision for each class
precision = tf.select(K.equal(pred_cnt, 0), K.zeros_like(y_true_pred), y_true_pred / pred_cnt,
name='precision_f1_semeval')
# recall for each class
recall = tf.select(K.equal(gold_cnt, 0), K.zeros_like(y_true_pred), y_true_pred / gold_cnt,
name='racall_f1_semeval')
# f1 for each class
f1_class = tf.select(K.equal(precision + recall, 0), K.zeros_like(y_true_pred),
2 * (precision * recall) / (precision + recall), name='precision_f1_semeval')
# return average f1 score over all classes
return K.mean(f1_class)
Example 42
| Project: deep-mlsa Author: spinningbytes File: evaluation_metrics.py Apache License 2.0 | 5 votes |
|
def f1_score_semeval(y_true, y_pred):
#convert probas to 0,1
y_pred_ones = K.zeros_like(y_true)
#y_pred_ones[:, K.argmax(y_pred, axis=-1)] = 1
#indices_x = K.arange(start=0, stop=y_true.get_shape()[0])
indices_x = K.expand_dims(K.arange(start=0, stop=tf.shape(y_true, name='get_indicec_x_shape')[0], dtype='int64'), dim=-1)
indices_y = K.expand_dims(K.argmax(y_pred, axis=-1), dim=-1)
indices = K.concatenate((indices_x, indices_y))
values = K.sum(K.ones_like(indices_x, dtype='float32'), axis=-1)
shape = K.cast(tf.shape(y_pred_ones), dtype='int64')
delta = tf.SparseTensor(indices, values, shape)
y_pred_ones = y_pred_ones + tf.sparse_tensor_to_dense(delta)
#where y_ture=1 and y_pred=1 -> true positive
y_true_pred = K.sum(y_true*y_pred_ones, axis=0)
#for each class: how many where classified as said class
pred_cnt = K.sum(y_pred_ones, axis=0)
#for each class: how many are true members of said class
gold_cnt = K.sum(y_true, axis=0)
#precision for each class
precision = tf.select(K.equal(pred_cnt, 0), K.zeros_like(y_true_pred), y_true_pred/pred_cnt, name='precision_f1_semeval')
#recall for each class
recall = tf.select(K.equal(gold_cnt, 0), K.zeros_like(y_true_pred), y_true_pred/gold_cnt, name='racall_f1_semeval')
#f1 for each class
f1_class = tf.select(K.equal(precision + recall, 0), K.zeros_like(y_true_pred), 2*(precision*recall)/(precision+recall), name='precision_f1_semeval')
#return average f1 score over all classes
return (f1_class[0] + f1_class[2])/2.0
Example 43
| Project: deep-mlsa Author: spinningbytes File: evaluation_metrics.py Apache License 2.0 | 5 votes |
|
def f1_score_task3(y_true, y_pred):
# convert probas to 0,1
y_pred_ones = K.zeros_like(y_true)
# y_pred_ones = K.T.set_subtensor(y_ppred[K.T.arange(y_true.shape[0]), K.argmax(y_pred, axis=-1)], 1)
indices_x = K.arange(y_true.shape[0])
indices_y = K.argmax(y_pred, axis=-1)
indices = K.concatenate(indices_x, indices_y)
values = K.ones_like(indices_x)
shape = y_pred_ones.shape
delta = tf.SparseTensor(indices, values, shape)
y_pred_ones[:, K.argmax(y_pred, axis=-1)] = 1
# where y_ture=1 and y_pred=1 -> true positive
y_true_pred = K.sum(y_true * y_pred_ones, axis=0)
# for each class: how many where classified as said class
pred_cnt = K.sum(y_pred_ones, axis=0)
# for each class: how many are true members of said class
gold_cnt = K.sum(y_true, axis=0)
# precision for each class
precision = K.switch(K.equal(pred_cnt, 0), 0, y_true_pred / pred_cnt)
# recall for each class
recall = K.switch(K.equal(gold_cnt, 0), 0, y_true_pred / gold_cnt)
# f1 for each class
f1_class = K.switch(K.equal(precision + recall, 0), 0, 2 * (precision * recall) / (precision + recall))
# return average f1 score over all classes
return f1_class[1]
Example 44
| Project: Logo-Retrieval-in-Commercial-Plaza Author: zhang-rongchen File: model_Mobilenet.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
# print("yolo_outputs",yolo_outputs)
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 45
| Project: smach_based_introspection_framework Author: birlrobotics File: layer_utils.py BSD 3-Clause "New" or "Revised" License | 4 votes |
|
def _time_distributed_dense(x, w, b=None, dropout=None,
input_dim=None, output_dim=None,
timesteps=None, training=None):
"""Apply `y . w + b` for every temporal slice y of x.
# Arguments
x: input tensor.
w: weight matrix.
b: optional bias vector.
dropout: wether to apply dropout (same dropout mask
for every temporal slice of the input).
input_dim: integer; optional dimensionality of the input.
output_dim: integer; optional dimensionality of the output.
timesteps: integer; optional number of timesteps.
training: training phase tensor or boolean.
# Returns
Output tensor.
"""
if not input_dim:
input_dim = K.shape(x)[2]
if not timesteps:
timesteps = K.shape(x)[1]
if not output_dim:
output_dim = K.int_shape(w)[1]
if dropout is not None and 0. < dropout < 1.:
# apply the same dropout pattern at every timestep
ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim)))
dropout_matrix = K.dropout(ones, dropout)
expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps)
x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training)
# collapse time dimension and batch dimension together
x = K.reshape(x, (-1, input_dim))
x = K.dot(x, w)
if b is not None:
x = K.bias_add(x, b)
# reshape to 3D tensor
if K.backend() == 'tensorflow':
x = K.reshape(x, K.stack([-1, timesteps, output_dim]))
x.set_shape([None, None, output_dim])
else:
x = K.reshape(x, (-1, timesteps, output_dim))
return x
Example 46
| Project: keras-minimal-rnn Author: titu1994 File: minimal_rnn.py MIT License | 4 votes |
|
def _time_distributed_dense(x, w, b=None, dropout=None,
input_dim=None, output_dim=None,
timesteps=None, training=None):
"""Apply `y . w + b` for every temporal slice y of x.
# Arguments
x: input tensor.
w: weight matrix.
b: optional bias vector.
dropout: wether to apply dropout (same dropout mask
for every temporal slice of the input).
input_dim: integer; optional dimensionality of the input.
output_dim: integer; optional dimensionality of the output.
timesteps: integer; optional number of timesteps.
training: training phase tensor or boolean.
# Returns
Output tensor.
"""
if not input_dim:
input_dim = K.shape(x)[2]
if not timesteps:
timesteps = K.shape(x)[1]
if not output_dim:
output_dim = K.int_shape(w)[1]
if dropout is not None and 0. < dropout < 1.:
# apply the same dropout pattern at every timestep
ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim)))
dropout_matrix = K.dropout(ones, dropout)
expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps)
x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training)
# collapse time dimension and batch dimension together
x = K.reshape(x, (-1, input_dim))
x = K.dot(x, w)
if b is not None:
x = K.bias_add(x, b)
# reshape to 3D tensor
if K.backend() == 'tensorflow':
x = K.reshape(x, K.stack([-1, timesteps, output_dim]))
x.set_shape([None, None, output_dim])
else:
x = K.reshape(x, (-1, timesteps, output_dim))
return x
Example 47
| Project: ndsc_code_gakko_workshop Author: seansaito File: localize_image.py MIT License | 4 votes |
|
def yolo_predict(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""
Get prediction from YOLO model on given input and return filtered boxes.
"""
num_layers = len(yolo_outputs)
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
# Get the boxes and the confidences for each box
box_xy, box_wh, box_confidence, box_class_probs = yolo_head(yolo_outputs[l],
anchors[anchor_mask[l]],
num_classes,
input_shape)
_boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)
_boxes = K.reshape(_boxes, [-1, 4])
_box_scores = box_confidence * box_class_probs
_box_scores = K.reshape(_box_scores, [-1, num_classes])
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
# TensorFlow function for non max suppression of detection candidates
# This is for filtering overlapping bounding boxes
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 48
| Project: keras-yolo3 Author: bing0037 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 49
| Project: multi-object-tracking Author: jguoaj File: model.py GNU General Public License v3.0 | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 50
| Project: solder_joint_detection Author: lx-onism File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 51
| Project: vision-web-service Author: sherlockchou86 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 52
| Project: Keras_YOLOv3_Mobilenet Author: xuqing88 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 53
| Project: Keras_YOLOv3_Mobilenet Author: xuqing88 File: model_Mobilenet.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
# print("yolo_outputs",yolo_outputs)
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 54
| Project: YOLO-3D-Box Author: scutan90 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 55
| Project: deep_sort_yolov3 Author: Qidian213 File: model.py GNU General Public License v3.0 | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 56
| Project: keras-yolo3-master Author: lijialinneu File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 57
| Project: deep_sort_tiny_yolo3 Author: scofield1991 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 58
| Project: diktya Author: BioroboticsLab File: gan.py Apache License 2.0 | 4 votes |
|
def _build(self):
fake, _, _, g_additional_losses = self.g.run_internal_graph(self.g.inputs)
real = self.d.inputs[0]
data = concat([fake, real], axis=0)
realness, _, _, d_additional_losses = self.d.run_internal_graph(
[data] + self.d.inputs[1:])
nb_fakes = fake.shape[0]
fake_realness = realness[:nb_fakes]
real_realness = realness[nb_fakes:]
split = 2*nb_fakes // 3
g_fake_realness = fake_realness[:split]
d_fake_realness = fake_realness[split:]
outputs = OrderedDict()
g_loss = K.mean(K.binary_crossentropy(g_fake_realness, K.ones_like(real_realness)))
outputs['g_loss'] = g_loss
g_reg_loss = sum([v for v in g_additional_losses.values()])
if g_reg_loss != 0:
outputs['g_reg_loss'] = g_reg_loss
g_total_loss = g_loss + g_reg_loss
d_loss = K.mean(K.binary_crossentropy(real_realness, K.ones_like(real_realness)))
d_loss += K.mean(K.binary_crossentropy(d_fake_realness, K.zeros_like(real_realness)))
outputs['d_loss'] = d_loss
d_reg_loss = sum([v for v in d_additional_losses.values()])
if d_reg_loss != 0:
outputs['d_reg_loss'] = d_reg_loss
d_total_loss = d_loss + d_reg_loss
inputs = {i.name: i for i in self.g.inputs + self.d.inputs}
inputs_list = []
for name in self.input_names:
inputs_list.append(inputs[name])
g_updates = self.g_optimizer.get_updates(
collect_trainable_weights(self.g), self.g.constraints, g_total_loss)
d_updates = self.d_optimizer.get_updates(
collect_trainable_weights(self.d), self.d.constraints, d_total_loss)
if self.uses_learning_phase:
lr_phase = [K.learning_phase()]
else:
lr_phase = []
self.metrics_names = list(outputs.keys())
self._train_function = K.function(inputs_list + lr_phase, list(outputs.values()),
updates=g_updates + d_updates)
Example 59
| Project: perceptron-benchmark Author: advboxes File: keras_yolov3.py Apache License 2.0 | 4 votes |
|
def _eval_pred(
self,
boxes,
box_scores,
num_classes,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
""" Evaluate logits for boxes and scores to final boxes, class, scores
results
"""
import tensorflow as tf
def process_batch(params):
boxes, box_scores = params
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(
box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores,
max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
pad_len = max_boxes - tf.shape(boxes_)[0]
pad_boxes = tf.zeros([pad_len, 4], dtype=tf.float32)
pad_scores = tf.zeros(pad_len, dtype=tf.float32)
pad_classes = tf.zeros(pad_len, dtype=tf.int32)
boxes_ = tf.concat([boxes_, pad_boxes], axis=0)
scores_ = tf.concat([scores_, pad_scores], axis=0)
classes_ = tf.concat([classes_, pad_classes], axis=0)
return boxes_, scores_, classes_
boxes_, scores_, classes_ = tf.map_fn(
process_batch,
(boxes, box_scores),
dtype=(tf.float32, tf.float32, tf.int32))
return boxes_, scores_, classes_
Example 60
| Project: ImageAI Author: OlafenwaMoses File: utils.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 61
| Project: yolov3-3dcarbox Author: zoujialong9012 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 62
| Project: C2 Author: Master-cai File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=100,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 63
| Project: Vehicle-Detection-and-Tracking-Usig-YOLO-and-Deep-Sort-with-Keras-and-Tensorflow Author: Akhtar303 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 64
| Project: yoloface Author: sthanhng File: model.py MIT License | 4 votes |
|
def eval(outputs, anchors, num_classes, image_shape,
max_boxes=20, score_threshold=.6, iou_threshold=.5):
'''Evaluate the YOLO model on given input and return filtered boxes'''
num_layers = len(outputs)
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [
[3, 4, 5], [1, 2, 3]]
input_shape = K.shape(outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = boxes_and_scores(outputs[l],
anchors[anchor_mask[l]],
num_classes, input_shape,
image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use Keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor,
iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 65
| Project: Object-and-facial-detection-in-python Author: grebtsew File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 66
| Project: RPGOne Author: RTHMaK File: backend.py Apache License 2.0 | 4 votes |
|
def l1_normalize(tensor_to_normalize, mask=None):
"""
Normalize a tensor by its L1 norm. Takes an optional mask.
When the vector to be normalized is all 0's we return the uniform
distribution (taking masking into account, so masked values are still 0.0).
When the vector to be normalized is completely masked, we return the
uniform distribution over the max padding length of the tensor.
See the tests for concrete examples of the aforementioned behaviors.
Parameters
----------
tensor_to_normalize : Tensor
Tensor of shape (batch size, x) to be normalized, where
x is arbitrary.
mask: Tensor, optional
Tensor of shape (batch size, x) indicating which elements
of ``tensor_to_normalize`` are padding and should
not be considered when normalizing.
Returns
-------
normalized_tensor : Tensor
Normalized tensor with shape (batch size, x).
"""
if mask is None:
mask = K.ones_like(tensor_to_normalize)
# We cast the mask to float32 to prevent dtype
# issues when multiplying it with other things
mask = K.cast(mask, "float32")
# We apply the mask to the tensor and take the sum
# of the values in each row.
row_sum = K.sum(mask * tensor_to_normalize, axis=-1, keepdims=True)
# We divide the tensor by the sum of the elements in the rows,
# and then apply the mask. This is the result a naive
# implementation would yield; we instead return the uniform distribution
# in a host of special cases (see the docstring and tests for more detail).
normal_result = (tensor_to_normalize / row_sum) * mask
mask_row_sum = K.sum(mask, axis=1, keepdims=True)
# The number of non-masked elements in the tensor to normalize.
# If all the elements in the tensor to normalize are masked,
# we set it to be the number of elements in the tensor to normalize.
divisor = K.sum(switch(mask_row_sum, mask, K.ones_like(mask)), axis=1,
keepdims=True)
# This handles the case where mask is all 0 and all values are 0.
# If the sum of mask_row_sum and row_sum is 0, make mask all ones,
# else just keep the mask as it is.
temp_mask = switch(mask_row_sum+row_sum, mask, K.ones_like(mask))
uniform = (K.ones_like(mask)/(divisor)) * temp_mask
normalized_tensors = switch(row_sum, normal_result, uniform)
return normalized_tensors
Example 67
| Project: RPGOne Author: RTHMaK File: gated_attention.py Apache License 2.0 | 4 votes |
|
def call(self, inputs, mask=None):
# document_matrix is of shape (batch, document length, biGRU hidden length).
# question_matrix is of shape (batch, question length, biGRU hidden length).
# normalized_qd_attention is of shape (batch, document length, question length).
document_matrix, question_matrix, normalized_qd_attention = inputs
if mask is None:
document_mask = K.ones_like(document_matrix)[:, :, 0]
else:
document_mask = mask[0]
# question_update is of shape (batch, document length, bigru hidden).
question_update = K.batch_dot(normalized_qd_attention, question_matrix, axes=[2, 1])
# We use the gating function to calculate the new document representation
# which is of shape (batch, document length, biGRU hidden length).
masked_representation = None
if self.gating_function == "||":
# shape (batch, document length, biGRU hidden length*2)
unmasked_representation = K.concatenate([question_update, document_matrix])
# Apply the mask from the document to zero out things that should be masked.
# The mask is of shape (batch, document length), so we tile it to
# shape (batch, document length, biGRU hidden length*2)
tiled_mask = K.repeat_elements(K.expand_dims(document_mask, axis=2),
(2*K.int_shape(document_matrix)[2]), 2)
masked_representation = switch(tiled_mask, unmasked_representation,
K.zeros_like(unmasked_representation))
return masked_representation
if self.gating_function == "*":
unmasked_representation = question_update * document_matrix
if self.gating_function == "+":
# shape (batch, document length, biGRU hidden length)
unmasked_representation = question_update + document_matrix
# Apply the mask from the document to zero out things that should be masked.
# The mask is of shape (batch, document length), so we tile it to
# shape (batch, document length, biGRU hidden length)
tiled_mask = K.repeat_elements(K.expand_dims(document_mask, axis=2),
K.int_shape(document_matrix)[2], 2)
masked_representation = switch(tiled_mask, unmasked_representation, K.zeros_like(unmasked_representation))
if masked_representation is not None:
return masked_representation
else:
raise ConfigurationError("Invalid gating function "
"{}, expected one of {}".format(self.gating_function,
GATING_FUNCTIONS))
Example 68
| Project: conv_qsar_fast Author: connorcoley File: GraphEmbedding_sumAfter.py MIT License | 4 votes |
|
def attributes_update(self, attributes, depth, graph, original_graph, bonds): '''Given the current attributes, the current depth, and the graph that the attributes are based on, this function will update the 2D attributes tensor''' ############# GET NEW ATTRIBUTE MATRIX ######################### # New pre-activated attribute matrix v = M_i,j,: x ones((N_atom, 1)) -> (N_atom, N_features) # as long as dimensions are appropriately shuffled shuffled_graph = graph.copy().dimshuffle((2, 0, 1)) # (N_feature x N_atom x N_atom) shuffled_graph.name = 'shuffled_graph' ones_vec = K.ones_like(attributes[:, 0]) # (N_atom x 1) ones_vec.name = 'ones_vec' # Embed individually # (scan sequences iterates over the FIRST dimension) # (flatten(ndim) keeps the first ndim-1 dimensions the same, then expands the rest to fill) flattened_graph = shuffled_graph.flatten(ndim = 2).T # (N_atom^2 x N_feature) # Embed each possible atom-atom interaction (new_presummed_attributes_flat, updates) = theano.scan(lambda x: self.activation_inner( K.dot(x[:-1], self.W_inner[depth, :, :]) + self.b_inner[depth, 0, :]), sequences = flattened_graph) # still (N_atom^2 x N_feature) # Reshape into #(N_feature-1 x N_atom x N_atom) new_presummed_attributes = new_presummed_attributes_flat.T.reshape(shuffled_graph[:-1,:,:].shape) # Now sum activated self+neighbors (new_attributes, updates) = theano.scan(lambda x: K.dot(x, ones_vec), sequences = new_presummed_attributes) # (N_features x N_atom) # Append last feature (bond flag) after the loop new_attributes = K.concatenate((new_attributes.T, attributes[:, -1:]), axis = 1) new_attributes.name = 'new_attributes' ############ UPDATE GRAPH TENSOR WITH NEW ATOM ATTRIBUTES ################### ### Node attribute contribution is located in every entry of graph[i,j,:] where ### there is a bond @ ij or when i = j (self) # Get atoms matrix (identity) atoms = T.identity_like(bonds) # (N_atom x N_atom) atoms.name = 'atoms_identity' # Combine bonds_or_atoms = bonds + atoms # (N_atom x N_atom) bonds_or_atoms.name = 'bonds_or_atoms' atom_indeces = T.arange(ones_vec.shape[0]) # 0 to N_atoms - 1 (indeces) atom_indeces.name = 'atom_indeces vector' ### Subtract previous node attribute contribution # Multiply each entry in bonds_or_atoms by the previous atom features for that column (old_features_to_sub, updates) = theano.scan(lambda i: T.outer(bonds_or_atoms[:, i], attributes[i, :]), sequences = T.arange(ones_vec.shape[0])) old_features_to_sub.name = 'old_features_to_sub' ### Add new node attribute contribution # Multiply each entry in bonds_or_atoms by the previous atom features for that column (new_features_to_add, updates) = theano.scan(lambda i: T.outer(bonds_or_atoms[:, i], new_attributes[i, :]), sequences = T.arange(ones_vec.shape[0])) new_features_to_add.name = 'new_features_to_add' # Update new graph new_graph = graph - old_features_to_sub + new_features_to_add new_graph.name = 'new_graph' return (new_attributes, new_graph)
Example 69
| Project: conv_qsar_fast Author: connorcoley File: GraphEmbedding.py MIT License | 4 votes |
|
def attributes_update(self, attributes, depth, graph, original_graph, bonds): '''Given the current attributes, the current depth, and the graph that the attributes are based on, this function will update the 2D attributes tensor''' ############# GET NEW ATTRIBUTE MATRIX ######################### # New pre-activated attribute matrix v = M_i,j,: x ones((N_atom, 1)) -> (N_atom, N_features) # as long as dimensions are appropriately shuffled shuffled_graph = graph.copy().dimshuffle((2, 0, 1)) # (N_feature x N_atom x N_atom) shuffled_graph.name = 'shuffled_graph' ones_vec = K.ones_like(attributes[:, 0]) # (N_atom x 1) ones_vec.name = 'ones_vec' (new_preactivated_attributes, updates) = theano.scan(lambda x: K.dot(x, ones_vec), sequences = shuffled_graph) # (N_features x N_atom) # Need to pass through an activation function still # Final attribute = bond flag = is not part of W_inner or b_inner (new_attributes, updates) = theano.scan(lambda x: self.activation_inner( K.dot(x, self.W_inner[depth, :, :]) + self.b_inner[depth, 0, :]), sequences = new_preactivated_attributes[:-1, :].T) # (N_atom x N_features -1) # Append last feature (bond flag) after the loop new_attributes = K.concatenate((new_attributes, attributes[:, -1:]), axis = 1) new_attributes.name = 'new_attributes' ############ UPDATE GRAPH TENSOR WITH NEW ATOM ATTRIBUTES ################### ### Node attribute contribution is located in every entry of graph[i,j,:] where ### there is a bond @ ij or when i = j (self) # Get atoms matrix (identity) atoms = T.identity_like(bonds) # (N_atom x N_atom) atoms.name = 'atoms_identity' # Combine bonds_or_atoms = bonds + atoms # (N_atom x N_atom) bonds_or_atoms.name = 'bonds_or_atoms' atom_indeces = T.arange(ones_vec.shape[0]) # 0 to N_atoms - 1 (indeces) atom_indeces.name = 'atom_indeces vector' ### Subtract previous node attribute contribution # Multiply each entry in bonds_or_atoms by the previous atom features for that column (old_features_to_sub, updates) = theano.scan(lambda i: T.outer(bonds_or_atoms[:, i], attributes[i, :]), sequences = T.arange(ones_vec.shape[0])) old_features_to_sub.name = 'old_features_to_sub' ### Add new node attribute contribution # Multiply each entry in bonds_or_atoms by the previous atom features for that column (new_features_to_add, updates) = theano.scan(lambda i: T.outer(bonds_or_atoms[:, i], new_attributes[i, :]), sequences = T.arange(ones_vec.shape[0])) new_features_to_add.name = 'new_features_to_add' # Update new graph new_graph = graph - old_features_to_sub + new_features_to_add new_graph.name = 'new_graph' return (new_attributes, new_graph)
Example 70
| Project: ReID Author: Wowoho File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 71
| Project: DeepFakeTutorial Author: MITeoRIte File: Trainer.py GNU General Public License v3.0 | 4 votes |
|
def define_loss(self, netD, real, fake_argb, distorted, vggface_feat=None):
alpha = Lambda(lambda x: x[:,:,:, :1])(fake_argb)
fake_rgb = Lambda(lambda x: x[:,:,:, 1:])(fake_argb)
fake = alpha * fake_rgb + (1-alpha) * distorted
if self.use_mixup:
dist = Beta(self.mixup_alpha, self.mixup_alpha)
lam = dist.sample()
# ==========
mixup = lam * concatenate([real, distorted]) + (1 - lam) * concatenate([fake, distorted])
# ==========
output_mixup = netD(mixup)
loss_D = self.loss_fn(output_mixup, lam * K.ones_like(output_mixup))
output_fake = netD(concatenate([fake, distorted])) # dummy
loss_G = .5 * self.loss_fn(output_mixup, (1 - lam) * K.ones_like(output_mixup))
else:
output_real = netD(concatenate([real, distorted])) # positive sample
output_fake = netD(concatenate([fake, distorted])) # negative sample
loss_D_real = self.loss_fn(output_real, K.ones_like(output_real))
loss_D_fake = self.loss_fn(output_fake, K.zeros_like(output_fake))
loss_D = loss_D_real + loss_D_fake
loss_G = .5 * self.loss_fn(output_fake, K.ones_like(output_fake))
# ==========
loss_G += K.mean(K.abs(fake_rgb - real))
# ==========
# Edge loss (similar with total variation loss)
loss_G += 1 * K.mean(K.abs(self.first_order(fake_rgb, axis=1) - self.first_order(real, axis=1)))
loss_G += 1 * K.mean(K.abs(self.first_order(fake_rgb, axis=2) - self.first_order(real, axis=2)))
# Perceptual Loss
if not vggface_feat is None:
def preprocess_vggface(x):
x = (x + 1)/2 * 255 # channel order: BGR
#x[..., 0] -= 93.5940
#x[..., 1] -= 104.7624
#x[..., 2] -= 129.
x -= [91.4953, 103.8827, 131.0912]
return x
pl_params = (0.011, 0.11, 0.1919)
real_sz224 = tf.image.resize_images(real, [224, 224])
real_sz224 = Lambda(preprocess_vggface)(real_sz224)
# ==========
fake_sz224 = tf.image.resize_images(fake_rgb, [224, 224])
fake_sz224 = Lambda(preprocess_vggface)(fake_sz224)
# ==========
real_feat55, real_feat28, real_feat7 = vggface_feat(real_sz224)
fake_feat55, fake_feat28, fake_feat7 = vggface_feat(fake_sz224)
loss_G += pl_params[0] * K.mean(K.abs(fake_feat7 - real_feat7))
loss_G += pl_params[1] * K.mean(K.abs(fake_feat28 - real_feat28))
loss_G += pl_params[2] * K.mean(K.abs(fake_feat55 - real_feat55))
return loss_D, loss_G
Example 72
| Project: DeepFakeTutorial Author: MITeoRIte File: Trainer.py GNU General Public License v3.0 | 4 votes |
|
def define_loss(self, netD, real, fake_argb, fake_sz64, distorted, vggface_feat=None):
alpha = Lambda(lambda x: x[:,:,:, :1])(fake_argb)
fake_rgb = Lambda(lambda x: x[:,:,:, 1:])(fake_argb)
fake = alpha * fake_rgb + (1-alpha) * distorted
if self.use_mixup:
dist = Beta(self.mixup_alpha, self.mixup_alpha)
lam = dist.sample()
# ==========
mixup = lam * concatenate([real, distorted]) + (1 - lam) * concatenate([fake, distorted])
# ==========
output_mixup = netD(mixup)
loss_D = self.loss_fn(output_mixup, lam * K.ones_like(output_mixup))
#output_fake = netD(concatenate([fake, distorted])) # dummy
loss_G = 1 * self.loss_fn(output_mixup, (1 - lam) * K.ones_like(output_mixup))
else:
output_real = netD(concatenate([real, distorted])) # positive sample
output_fake = netD(concatenate([fake, distorted])) # negative sample
loss_D_real = self.loss_fn(output_real, K.ones_like(output_real))
loss_D_fake = self.loss_fn(output_fake, K.zeros_like(output_fake))
loss_D = loss_D_real + loss_D_fake
loss_G = 1 * self.loss_fn(output_fake, K.ones_like(output_fake))
# ==========
if self.use_mask_refinement:
loss_G += K.mean(K.abs(fake - real))
else:
loss_G += K.mean(K.abs(fake_rgb - real))
loss_G += K.mean(K.abs(fake_sz64 - tf.image.resize_images(real, [64, 64])))
# ==========
# Perceptual Loss
if not vggface_feat is None:
def preprocess_vggface(x):
x = (x + 1)/2 * 255 # channel order: BGR
x -= [93.5940, 104.7624, 129.]
return x
pl_params = (0.02, 0.3, 0.5)
real_sz224 = tf.image.resize_images(real, [224, 224])
real_sz224 = Lambda(preprocess_vggface)(real_sz224)
# ==========
if self.use_mask_refinement:
fake_sz224 = tf.image.resize_images(fake, [224, 224])
else:
fake_sz224 = tf.image.resize_images(fake_rgb, [224, 224])
fake_sz224 = Lambda(preprocess_vggface)(fake_sz224)
# ==========
real_feat55, real_feat28, real_feat7 = vggface_feat(real_sz224)
fake_feat55, fake_feat28, fake_feat7 = vggface_feat(fake_sz224)
loss_G += pl_params[0] * K.mean(K.abs(fake_feat7 - real_feat7))
loss_G += pl_params[1] * K.mean(K.abs(fake_feat28 - real_feat28))
loss_G += pl_params[2] * K.mean(K.abs(fake_feat55 - real_feat55))
return loss_D, loss_G
Example 73
| Project: keras-adabound Author: titu1994 File: adabound.py MIT License | 4 votes |
|
def get_updates(self, loss, params):
grads = self.get_gradients(loss, params)
self.updates = [K.update_add(self.iterations, 1)]
lr = self.lr
if self.initial_decay > 0:
lr = lr * (1. / (1. + self.decay * K.cast(self.iterations,
K.dtype(self.decay))))
t = K.cast(self.iterations, K.floatx()) + 1
# Applies bounds on actual learning rate
step_size = lr * (K.sqrt(1. - K.pow(self.beta_2, t)) /
(1. - K.pow(self.beta_1, t)))
final_lr = self.final_lr * lr / self.base_lr
lower_bound = final_lr * (1. - 1. / (self.gamma * t + 1.))
upper_bound = final_lr * (1. + 1. / (self.gamma * t))
ms = [K.zeros(K.int_shape(p), dtype=K.dtype(p)) for p in params]
vs = [K.zeros(K.int_shape(p), dtype=K.dtype(p)) for p in params]
if self.amsbound:
vhats = [K.zeros(K.int_shape(p), dtype=K.dtype(p)) for p in params]
else:
vhats = [K.zeros(1) for _ in params]
self.weights = [self.iterations] + ms + vs + vhats
for p, g, m, v, vhat in zip(params, grads, ms, vs, vhats):
# apply weight decay
if self.weight_decay != 0.:
g += self.weight_decay * K.stop_gradient(p)
m_t = (self.beta_1 * m) + (1. - self.beta_1) * g
v_t = (self.beta_2 * v) + (1. - self.beta_2) * K.square(g)
if self.amsbound:
vhat_t = K.maximum(vhat, v_t)
denom = (K.sqrt(vhat_t) + self.epsilon)
self.updates.append(K.update(vhat, vhat_t))
else:
denom = (K.sqrt(v_t) + self.epsilon)
# Compute the bounds
step_size_p = step_size * K.ones_like(denom)
step_size_p_bound = step_size_p / denom
bounded_lr_t = m_t * K.minimum(K.maximum(step_size_p_bound,
lower_bound), upper_bound)
p_t = p - bounded_lr_t
self.updates.append(K.update(m, m_t))
self.updates.append(K.update(v, v_t))
new_p = p_t
# Apply constraints.
if getattr(p, 'constraint', None) is not None:
new_p = p.constraint(new_p)
self.updates.append(K.update(p, new_p))
return self.updates
Example 74
| Project: EQanalytics Author: AntonMu File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 75
| Project: basasuya-yolo3 Author: Basasuya File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]]
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(3):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 76
| Project: keras-yolov3-KF-objectTracking Author: mattzheng File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 77
| Project: LSTM-FCN Author: ShobhitLamba File: layer_utils.py MIT License | 4 votes |
|
def _time_distributed_dense(x, w, b=None, dropout=None,
input_dim=None, output_dim=None,
timesteps=None, training=None):
"""Apply `y . w + b` for every temporal slice y of x.
# Arguments
x: input tensor.
w: weight matrix.
b: optional bias vector.
dropout: wether to apply dropout (same dropout mask
for every temporal slice of the input).
input_dim: integer; optional dimensionality of the input.
output_dim: integer; optional dimensionality of the output.
timesteps: integer; optional number of timesteps.
training: training phase tensor or boolean.
# Returns
Output tensor.
"""
if not input_dim:
input_dim = K.shape(x)[2]
if not timesteps:
timesteps = K.shape(x)[1]
if not output_dim:
output_dim = K.int_shape(w)[1]
if dropout is not None and 0. < dropout < 1.:
# apply the same dropout pattern at every timestep
ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim)))
dropout_matrix = K.dropout(ones, dropout)
expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps)
x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training)
# collapse time dimension and batch dimension together
x = K.reshape(x, (-1, input_dim))
x = K.dot(x, w)
if b is not None:
x = K.bias_add(x, b)
# reshape to 3D tensor
if K.backend() == 'tensorflow':
x = K.reshape(x, K.stack([-1, timesteps, output_dim]))
x.set_shape([None, None, output_dim])
else:
x = K.reshape(x, (-1, timesteps, output_dim))
return x
Example 78
| Project: face-swap Author: 5agado File: gan_utils.py Apache License 2.0 | 4 votes |
|
def define_loss_masked(netD, real, fake_argb, distorted, vggface_feat=None, mixup_alpha=None, use_lsgan=True):
# loss weights
w_D = 0.5 # Discriminator contribution to generator loss
w_recon = 1. # L1 reconstruction loss
w_edge = 1. # edge loss
loss_fn = get_loss_fun(use_lsgan)
alpha = Lambda(lambda x: x[:, :, :, :1])(fake_argb)
fake_rgb = Lambda(lambda x: x[:, :, :, 1:])(fake_argb)
fake = alpha * fake_rgb + (1 - alpha) * distorted
if mixup_alpha:
dist = Beta(mixup_alpha, mixup_alpha)
lam = dist.sample()
mixup = lam * concatenate([real, distorted]) + (1 - lam) * concatenate([fake, distorted])
output_mixup = netD(mixup)
loss_D = loss_fn(output_mixup, lam * K.ones_like(output_mixup))
output_fake = netD(concatenate([fake, distorted])) # dummy
loss_G = w_D * loss_fn(output_mixup, (1 - lam) * K.ones_like(output_mixup))
else:
output_real = netD(concatenate([real, distorted])) # positive sample
output_fake = netD(concatenate([fake, distorted])) # negative sample
loss_D_real = loss_fn(output_real, K.ones_like(output_real))
loss_D_fake = loss_fn(output_fake, K.zeros_like(output_fake))
loss_D = loss_D_real + loss_D_fake
loss_G = w_D * loss_fn(output_fake, K.ones_like(output_fake))
# Reconstruction loss
loss_G += w_recon * K.mean(K.abs(fake_rgb - real))
# Edge loss (similar with total variation loss)
loss_G += w_edge * K.mean(K.abs(first_order(fake_rgb, axis=1) - first_order(real, axis=1)))
loss_G += w_edge * K.mean(K.abs(first_order(fake_rgb, axis=2) - first_order(real, axis=2)))
# Perceptual Loss
if not vggface_feat is None:
loss_G = add_perceptual_loss_masked(loss_G, real=real, fake=fake, vggface_feat=vggface_feat, fake_rgb=fake_rgb)
return loss_D, loss_G
# Build a perceptual-loss model from VGG pre-trained model
# Via Keras can load VGG model via
# vgg = VGG16(include_top=False, model='resnet50', input_shape=HR_IMG_SHAPE) # model can be 'resnet50' or 'vgg16'
# of for VGGFace
# vggface = VGGFace(include_top=False, model='resnet50', input_shape=(224, 224, 3))
Example 79
| Project: human-counter Author: zzh2910 File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
Example 80
| Project: yolo3sort Author: ImLaoBJie File: model.py MIT License | 4 votes |
|
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
