def spartial_pyramid_pooling(self, x):
padding = Variable(np.zeros((1, x.shape[2]), dtype=np.float32))
h = [F.expand_dims(F.flatten(F.max(x, axis=3)), axis=0)]
length = x.shape[3]
for i in range(1, self.spp_level):
division = 2**i
window_size = length // division
if window_size > 0:
for j in range(i):
h.append(
F.expand_dims(F.flatten(
F.max(x[:, :, :,
(window_size * j):(window_size * (j + 1))],
axis=3)),
axis=0))
h.append(
F.expand_dims(F.flatten(
F.max(x[:, :, :, (window_size * i):], axis=3)),
axis=0))
else:
for j in range(length):
h.append(F.expand_dims(F.flatten(x[:, :, :, j]), axis=0))
extend = division - length
for j in range(extend):
h.append(padding)
return (h)
def fwd(self, x, train):
n = 3
_, _, x_h, x_w = x.shape
h = F.relu(self.conv1(x))
h = F.relu(self.conv2(h))
h_b, h_c, h_h, h_w = h.shape
if x_h != h_h and x_w != h_w:
pad = Variable(np.zeros(
(h_b, h_c, x_h - h_h, h_w)).astype(np.float32),
volatile=x.volatile)
if np.ndarray is not type(h.data):
pad.to_gpu()
h = F.concat((h, pad), axis=2)
pad = Variable(np.zeros(
(h_b, h_c, x_h, x_w - h_w)).astype(np.float32),
volatile=x.volatile)
if np.ndarray is not type(h.data):
pad.to_gpu()
h = F.concat((h, pad), axis=3)
h_b, h_c, h_h, h_w = h.shape
h_flat = F.reshape(F.flatten(h), (1, 3072))
x_flat = F.reshape(F.flatten(x), (1, 3072))
x = self.alpha(x_flat)
h_flat += x
h = F.reshape(h_flat, h.shape)
x = F.reshape(x_flat, h.shape)
h = self.fc(h)
self.alpha_log.add(float(self.alpha.W.data[0][0]))
self.alpha_log.save('./results/alpha_log')
return h
def _construct_relation_embedding(trig_embedding,
relation,
batch_i,
bilstm_i,
structures_above_threshold=None):
role = relation[0][0]
arg = relation[0][1]
io = relation[1]
role_type_embedding = self.embed_roletype(
np.array([role]).astype("i"))
triggers = batch_i[const.IDS_TRIGGERS_IDX]
is_trigger = arg in triggers
if is_trigger:
arg_embedding = _represent_type_and_argument(
batch_i, const.IDS_TRIGGERS_IDX, bilstm_i, arg,
structures_above_threshold)
else:
arg_embedding = _represent_type_and_argument(
batch_i, const.IDS_ENTITIES_IDX, bilstm_i, arg)
io_embedding = self.embed_io(np.array([io]).astype('i'))
relation_embedding = []
if len(arg_embedding) != 0:
for i in range(len(arg_embedding)):
a = F.flatten(trig_embedding)
b = F.flatten(role_type_embedding)
c = F.flatten(arg_embedding[i])
d = F.flatten(io_embedding)
z = F.hstack([a, b, c, d])
emb = F.reshape(z, (1, self.len_relation))
relation_embedding.append(emb)
return relation_embedding
def update_q_func(self, batch):
"""Compute loss for a given Q-function."""
batch_next_state = batch['next_state']
batch_rewards = batch['reward']
batch_terminal = batch['is_state_terminal']
batch_state = batch['state']
batch_actions = batch['action']
batch_discount = batch['discount']
with chainer.no_backprop_mode(), chainer.using_config('train', False):
next_actions = self.target_policy_smoothing_func(
self.target_policy(batch_next_state).sample().array)
next_q1 = self.target_q_func1(batch_next_state, next_actions)
next_q2 = self.target_q_func2(batch_next_state, next_actions)
next_q = F.minimum(next_q1, next_q2)
target_q = batch_rewards + batch_discount * \
(1.0 - batch_terminal) * F.flatten(next_q)
predict_q1 = F.flatten(self.q_func1(batch_state, batch_actions))
predict_q2 = F.flatten(self.q_func2(batch_state, batch_actions))
loss1 = F.mean_squared_error(target_q, predict_q1)
loss2 = F.mean_squared_error(target_q, predict_q2)
# Update stats
self.q1_record.extend(cuda.to_cpu(predict_q1.array))
self.q2_record.extend(cuda.to_cpu(predict_q2.array))
self.q_func1_loss_record.append(float(loss1.array))
self.q_func2_loss_record.append(float(loss2.array))
self.q_func1_optimizer.update(lambda: loss1)
self.q_func2_optimizer.update(lambda: loss2)
def _represent_type_and_argument(arg_ids,
type_index,
bilstm_i,
type_label,
structures_above_threshold=None):
embedding_list = []
if structures_above_threshold is not None:
embedding_list = structures_above_threshold[type_label]
else:
defn = arg_ids[type_label]
type_id = defn[const.IDS_ARG_TYPE]
type_embedding = None
if type_index == const.IDS_TRIGGERS_IDX:
type_embedding = self.embed_trigtype(
self.xp.array([type_id]).astype("i"))
elif type_index == const.IDS_ENTITIES_IDX:
type_embedding = self.embed_enttype(
self.xp.array([type_id]).astype("i"))
mention = defn[const.IDS_ARG_MENTION]
mention_ids = _get_word_ids(instance, mention)
mention_embedding = _represent_mentions(mention_ids, bilstm_i)
flattened_type_embedding = F.flatten(type_embedding)
flattened_mention_embedding = F.flatten(mention_embedding)
type_and_argument_embedding = F.hstack(
[flattened_type_embedding, flattened_mention_embedding])
reshaped_type_and_argument_embedding = F.reshape(
type_and_argument_embedding, (1, self.len_type_and_arg))
embedding_list.append(reshaped_type_and_argument_embedding)
return embedding_list
def _represent_type_and_argument(batch_i,
type_index,
bilstm_i,
type_label,
structures_above_threshold=None):
def _get_word_ids(xsi, mention):
word_ind = []
sentence_ids = xsi[const.IDS_SENTENCE_INFO_IDX][
const.IDS_SENTENCE_IDX]
for i in mention:
if i in sentence_ids:
ind = sentence_ids.index(i)
word_ind.append(ind)
return word_ind
embedding_list = []
if structures_above_threshold is not None:
embedding_list = structures_above_threshold[type_label]
else:
defn = batch_i[type_index][type_label]
type_id = defn[const.IDS_ARG_TYPE]
type_embedding = None
if type_index == const.IDS_TRIGGERS_IDX:
if self.REPLACE_TYPE:
trig_word = self.id2triggertype[type_id]
new_arg = Util.extract_category(
trig_word, self.GENERALISATION,
const.TYPE_GENERALISATION)
assert new_arg != '', "ERROR: new_arg is '' "
type_id = self.trigger_type2id[new_arg]
type_embedding = self.embed_trigtype(
np.array([type_id]).astype("i"))
elif type_index == const.IDS_ENTITIES_IDX:
if self.REPLACE_TYPE:
ent_word = self.id2entitytype[type_id]
new_arg = Util.extract_category(
ent_word, self.GENERALISATION,
const.TYPE_GENERALISATION)
assert new_arg != '', "ERROR: new_arg is '' "
type_id = self.entity_type2id[new_arg]
type_embedding = self.embed_argtype(
np.array([type_id]).astype("i"))
mention = defn[const.IDS_ARG_MENTION]
mention_ids = _get_word_ids(batch_i, mention)
mention_embedding = _represent_mentions(mention_ids, bilstm_i)
flattened_type_embedding = F.flatten(type_embedding)
flattened_mention_embedding = F.flatten(mention_embedding)
type_and_argument_embedding = F.hstack(
[flattened_type_embedding, flattened_mention_embedding])
reshaped_type_and_argument_embedding = F.reshape(
type_and_argument_embedding, (1, self.len_type_and_arg))
embedding_list.append(reshaped_type_and_argument_embedding)
return embedding_list
def _construct_relation_embedding(trig_embedding, pair, entities_ids, triggers_ids, bilstm_i, structures_above_threshold=None):
relation = pair[0]
action = pair[1]
if action == const.ACTION_NONE:
action_embedding = Variable(self.xp.zeros((self.action_dim), dtype=self.xp.float32))
else:
action_embedding = self.embed_action(self.xp.array([action]).astype("i"))
if relation[1] == const.NONE_ROLE_TYPE:
role = 0
type_id = 0
role_type_embedding = None
try:
role_type_embedding = self.embed_roletype(self.xp.array([role]).astype("i"))
except:
print("debug")
type_embedding = self.embed_enttype(self.xp.array([type_id]).astype("i"))
mention = [0] # TODO: how to represent this better?
mention_ids = _get_word_ids(instance, mention)
mention_embedding = _represent_mentions(mention_ids, bilstm_i)
flattened_type_embedding = F.flatten(type_embedding)
flattened_mention_embedding = F.flatten(mention_embedding)
type_and_argument_embedding = F.hstack([flattened_type_embedding, flattened_mention_embedding])
arg_embedding = F.reshape(type_and_argument_embedding, (1, self.len_type_and_arg))
relation_embedding = []
a = F.flatten(trig_embedding)
b = F.flatten(role_type_embedding)
c = F.flatten(arg_embedding)
d = F.flatten(action_embedding)
z = F.hstack([a, b, c, d])
emb = F.reshape(z, (1, self.len_relation + self.action_dim))
relation_embedding.append(emb)
else:
role = relation[0]
arg = relation[1]
role_type_embedding = self.embed_roletype(self.xp.array([role]).astype("i"))
is_trigger = arg in triggers_ids
if is_trigger:
arg_embedding = _represent_type_and_argument(triggers_ids, const.IDS_TRIGGERS_IDX, bilstm_i, arg,
structures_above_threshold)
else:
arg_embedding = _represent_type_and_argument(entities_ids, const.IDS_ENTITIES_IDX, bilstm_i, arg)
relation_embedding = []
if len(arg_embedding) != 0:
for i in range(len(arg_embedding)):
a = F.flatten(trig_embedding)
b = F.flatten(role_type_embedding)
c = F.flatten(arg_embedding[i])
d = F.flatten(action_embedding)
z = F.hstack([a, b, c, d])
emb = F.reshape(z, (1, self.len_relation + self.action_dim))
relation_embedding.append(emb)
return relation_embedding
def _calc_absorb_value(self, batch_demo):
absorb_state = self.xp.zeros((1, batch_demo['state'].shape[1]),
dtype=batch_demo['state'].dtype)
is_absorb = self.xp.ones((1, 1), dtype=self.xp.float32)
absorb_action = self.xp.zeros((1, 1), dtype=self.xp.float32)
# absorb_reward = self.reward_func(absorb_state, is_absorb, absorb_action)
absorb_q1 = self.q_func1(absorb_state, is_absorb, absorb_action)
absorb_q2 = self.q_func2(absorb_state, is_absorb, absorb_action)
# assert absorb_q1.shape == absorb_reward.shape
# return F.flatten(absorb_reward + self.gamma * F.minimum(absorb_q1, absorb_q2))
return F.flatten(absorb_q1), F.flatten(absorb_q2)
def _elementwise_softmax_cross_entropy(x, t, two_class):
assert x.shape[:-1] == t.shape
shape = t.shape
t = F.flatten(t)
if two_class:
x = F.flatten(x)
return F.reshape(
F.sigmoid_cross_entropy(x, t, reduce='no'), shape)
else:
x = F.reshape(x, (-1, x.shape[-1]))
return F.reshape(
F.softmax_cross_entropy(x, t, reduce='no'), shape)
def dice_coefficent(self,predict, ground_truth):
dice_numerator = 0.0
dice_denominator = 0.0
eps = 1e-16
predict = F.flatten(predict)
ground_truth = F.flatten(ground_truth.astype(np.float32))
dice_numerator = F.sum(2*(predict * ground_truth))
dice_denominator =F.sum(predict+ ground_truth)
loss = dice_numerator/(dice_denominator+eps)
return -loss
def _compute_bc_loss(self, batch):
# behavioral cloning
batch_state = batch['state']
batch_actions = batch['action']
batch_absorb = batch['is_state_absorb']
action_distrib = self.policy(batch_state, batch_absorb)
action = action_distrib.sample()
loss = F.mean_squared_error(F.flatten(batch_actions),
F.flatten(action))
return loss
def update_q_func(self, batch):
"""Compute loss for a given Q-function."""
batch_next_state = batch['next_state']
batch_rewards = batch['reward']
batch_terminal = batch['is_state_terminal']
batch_state = batch['state']
batch_actions = batch['action']
batch_discount = batch['discount']
with chainer.no_backprop_mode(), chainer.using_config('train', False):
next_action_distrib = self.policy(batch_next_state)
next_actions, next_log_prob =\
next_action_distrib.sample_with_log_prob()
next_q1 = self.target_q_func1(batch_next_state, next_actions)
next_q2 = self.target_q_func2(batch_next_state, next_actions)
next_q = F.minimum(next_q1, next_q2)
entropy_term = self.temperature * next_log_prob[..., None]
assert next_q.shape == entropy_term.shape
target_q = batch_rewards + batch_discount * \
(1.0 - batch_terminal) * F.flatten(next_q - entropy_term)
predict_q1 = F.flatten(self.q_func1(batch_state, batch_actions))
predict_q2 = F.flatten(self.q_func2(batch_state, batch_actions))
loss1 = 0.5 * F.mean_squared_error(target_q, predict_q1)
loss2 = 0.5 * F.mean_squared_error(target_q, predict_q2)
if self.use_mutual_learning:
for idx, agent in enumerate(self.all_agents):
if idx != self.assigned_idx:
#self.logger.info('Mutual learn Q')
other_predict_q1 = F.flatten(
agent.q_func1(batch_state, batch_actions))
other_predict_q2 = F.flatten(
agent.q_func2(batch_state, batch_actions))
loss1 += 0.5 * F.mean_squared_error(
predict_q1, other_predict_q1)
loss2 += 0.5 * F.mean_squared_error(
predict_q2, other_predict_q2)
# Update stats
self.q1_record.extend(cuda.to_cpu(predict_q1.array))
self.q2_record.extend(cuda.to_cpu(predict_q2.array))
self.q_func1_loss_record.append(float(loss1.array))
self.q_func2_loss_record.append(float(loss2.array))
self.q_func1_optimizer.update(lambda: loss1)
self.q_func2_optimizer.update(lambda: loss2)
def update_q_func(self, batch):
"""Compute loss for a given Q-function."""
batch_next_state = batch['next_state']
batch_rewards = batch['reward']
batch_terminal = batch['is_state_terminal']
batch_state = batch['state']
batch_actions = batch['action']
batch_discount = batch['discount']
with chainer.no_backprop_mode(), chainer.using_config('train', False):
next_action_distrib = self.policy(batch_next_state)
next_actions, next_log_prob =\
next_action_distrib.sample_with_log_prob()
entropy_term = self.temperature * next_log_prob
if self.is_discrete:
next_q1 = F.select_item(self.target_q_func1(batch_next_state),
next_actions)
next_q2 = F.select_item(self.target_q_func2(batch_next_state),
next_actions)
else:
next_q1 = self.target_q_func1(batch_next_state, next_actions)
next_q2 = self.target_q_func2(batch_next_state, next_actions)
entropy_term = entropy_term[..., None]
next_q = F.minimum(next_q1, next_q2)
assert next_q.shape == entropy_term.shape
target_q = batch_rewards + batch_discount * \
(1.0 - batch_terminal) * F.flatten(next_q - entropy_term)
if self.is_discrete:
predict_q1 = F.flatten(
F.select_item(self.q_func1(batch_state), batch_actions))
predict_q2 = F.flatten(
F.select_item(self.q_func2(batch_state), batch_actions))
else:
predict_q1 = F.flatten(self.q_func1(batch_state, batch_actions))
predict_q2 = F.flatten(self.q_func2(batch_state, batch_actions))
loss1 = 0.5 * F.mean_squared_error(target_q, predict_q1)
loss2 = 0.5 * F.mean_squared_error(target_q, predict_q2)
# Update stats
self.q1_record.extend(cuda.to_cpu(predict_q1.array))
self.q2_record.extend(cuda.to_cpu(predict_q2.array))
self.q_func1_loss_record.append(float(loss1.array))
self.q_func2_loss_record.append(float(loss2.array))
self.q_func1_optimizer.update(lambda: loss1)
self.q_func2_optimizer.update(lambda: loss2)
def __call__(self, *args):
x = args[:-1]
t = args[-1]
self.y = None
self.loss = None
self.accuracy = None
self.y = self.predictor(*x)
if self.output_size == 1:
self.y = F.flatten(self.y)
t = F.flatten(t)
self.loss = F.mean_absolute_error(self.y, t)
reporter.report({'loss': self.loss}, self)
reporter.report({'mae': self.loss}, self)
return self.loss
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.flatten(x)
self.assertEqual(y.shape, self.g_shape)
self.assertEqual(y.dtype, self.dtype)
testing.assert_allclose(self.x.flatten(), y.data)
def __call__(self, obs, conditional_input=None):
o_c, o_a1, o_a2 = obs
if self.conditional:
# concat image obs and conditional image input
o_c = F.concat((o_c, conditional_input), axis=1)
# image encoding part
h_a1 = self.f(self.e1_l1_a1(o_a1))
h_a2 = self.f(self.e1_l1_a1(o_a2))
h_a = F.concat((h_a1, h_a2), axis=1)
h_c = self.f(self.e1_c1(o_c))
# reshape
imshape = h_c.shape[2:]
h = h_c + F.reshape(F.tile(h_a, imshape), (1, 32) + imshape)
h = self.f(self.e2_c1(h))
h = self.f(self.e2_c2(h))
h = self.f(self.e2_c3(h))
h = F.expand_dims(F.flatten(h), 0)
h = self.f(self.e2_l1(h))
# lstm
h = self.lstm(h)
# output by the decoder
return self.decoder(h)
def __call__(self, data, face, eyes_grid):
# the network that uses data as input
pool1 = F.max_pooling_2d(F.relu(self.conv1(data)), ksize=3, stride=2)
norm1 = F.local_response_normalization(pool1,
n=5,
alpha=0.0001,
beta=0.75)
pool2 = F.max_pooling_2d(F.relu(self.conv2(norm1)), ksize=3, stride=2)
norm2 = norm1 = F.local_response_normalization(pool2,
n=5,
alpha=0.0001,
beta=0.75)
conv3 = F.relu(self.conv3(norm2))
conv4 = F.relu(self.conv4(conv3))
conv5 = F.relu(self.conv5(conv4))
conv5_red = F.relu(self.conv5_red(conv5))
# the network that uses face as input
pool1_face = F.max_pooling_2d(F.relu(self.conv1_face(face)),
ksize=3,
stride=2)
norm1_face = F.local_response_normalization(pool1_face,
n=5,
alpha=0.0001,
beta=0.75)
pool2_face = F.max_pooling_2d(F.relu(self.conv2_face(norm1_face)),
ksize=3,
stride=2)
norm2_face = F.local_response_normalization(pool2_face,
n=5,
alpha=0.0001,
beta=0.75)
conv3_face = F.relu(self.conv3_face(norm2_face))
conv4_face = F.relu(self.conv4_face(conv3_face))
pool5_face = F.max_pooling_2d(F.relu(self.conv5_face(conv4_face)),
ksize=3,
stride=2)
fc6_face = F.relu(self.fc6_face(pool5_face))
# now the eyes
eyes_grid_flat = F.flatten(eyes_grid)
eyes_grid_mult = 24 * eyes_grid_flat
eyes_grid_reshaped = F.reshape(
eyes_grid_mult,
(1, eyes_grid_mult.size)) # give it same ndim as fc6
# now bring everything together
face_input = F.concat((fc6_face, eyes_grid_reshaped), axis=1)
fc7_face = F.relu(self.fc7_face(face_input))
fc8_face = F.relu(self.fc8_face(fc7_face))
importance_map_reshape = F.reshape(
F.sigmoid(self.importance_no_sigmoid(fc8_face)), (1, 1, 13, 13))
fc_7 = conv5_red * self.importance_map(importance_map_reshape)
fc_0_0 = self.fc_0_0(fc_7)
fc_1_0 = self.fc_1_0(fc_7)
fc_0_1 = self.fc_0_1(fc_7)
fc_m1_0 = self.fc_m1_0(fc_7)
fc_0_m1 = self.fc_0_m1(fc_7)
return fc_0_0, fc_1_0, fc_0_1, fc_0_m1, fc_m1_0
def position2onehot(self, inds, dim):
inds = chaFunc.flatten(inds)
inds = inds.data.astype('float32') % self.max_n_spans
inds = inds.astype('int32')
eye = self.xp.identity(dim).astype(self.xp.float32)
onehot = chaFunc.embed_id(inds, eye)
return onehot
def __call__(self, z):
# decode location
z1 = z
h = F.reshape(z1, (1, 64, 2, 2))
h = self.f(self.l1_c1(h))
h = self.f(self.l1_c2(h))
h = self.f(self.l1_c3(h))
h = self.f(self.l1_c4(h))
h = self.l1_c5(h)
h = F.expand_dims(F.flatten(h), 0)
p1 = SoftmaxDistribution(h)
a1 = p1.sample()
# decode prob
h_a1 = self.f(self.l1_l1(
np.expand_dims(a1.data, 0).astype(np.float32)))
h_a1 = F.concat((z1, h_a1), axis=1)
z2 = self.f(self.l1_l2(h_a1))
h_a2 = self.l2_l1(z2)
p2 = SoftmaxDistribution(h_a2)
a2 = p2.sample()
probs = [p1, p2]
acts = [a1, a2]
return probs, acts
def __call__(self, xs, ys, train):
decoder_logits = self.predictor.predict(xs, ys, train)
labels = F.flatten(F.transpose(ys))
loss = F.softmax_cross_entropy(decoder_logits, labels)
accuracy = F.accuracy(decoder_logits, labels)
reporter.report({"loss": loss, "accuracy": accuracy}, self)
return loss
def _elementwise_softmax_cross_entropy(x, t):
assert x.shape[:-1] == t.shape
shape = t.shape
x = F.reshape(x, (-1, x.shape[-1]))
t = F.flatten(t)
return F.reshape(
F.softmax_cross_entropy(x, t, reduce='no'), shape)
def inverse_select_items_per_row(values2d, idx2d):
"""
Selects items from 2-dimensional tensor (matrix) per row that are not in the
given indices
:param values2d: The values to choose from
:type values2d: chainer.Variable
:param idx2d: The indices to select
:type idx2d: chainer.Variable
:return: A matrix with the other elements selected
:rtype: chainer.Variable
"""
xp = cuda.get_array_module(values2d, idx2d)
rows = idx2d.shape[0]
cols_idx = idx2d.shape[1]
cols_values = values2d.shape[1]
flattened_idx = xp.ravel(idx2d.data) + xp.repeat(
xp.arange(0, rows * cols_values, cols_values), cols_idx)
all_idx = xp.arange(0, rows * cols_values, dtype=idx2d.data.dtype)
all_idx[flattened_idx.data] = -1
remaining_idx = all_idx[all_idx >= 0]
flattened_values = F.flatten(values2d)
flattened_values = flattened_values[remaining_idx]
return F.reshape(flattened_values, (rows, cols_values - cols_idx))
def __call__(self, x, c, alpha=1.0):
if self.depth > 0 and alpha < 1:
h1 = self['b%d' % (7 - self.depth)](x, c, True)
x2 = F.average_pooling_2d(x, 2, 2)
h2 = F.leaky_relu(self['b%d' % (7 - self.depth + 1)].fromRGB(x2))
h = h2 * (1 - alpha) + h1 * alpha
else:
h = self['b%d' % (7 - self.depth)](x, c, True)
for i in range(self.depth):
h = self['b%d' % (7 - self.depth + 1 + i)](h, c)
if not c is None:
d = self.l(h)
d = F.flatten(d)
return d
else:
d = F.relu(self.l1(h))
#d = self.l2(d)
male = self.male(d)
blond = self.blond(d)
eye = self.eye(d)
no_beard = self.no_beard(d)
smiling = self.smiling(d)
return male, blond, eye, no_beard, smiling
def __call__(self, x, c=None): if c is not None: embedded = self.embedder(c) normalized = embedded / sqrt(mean(embedded ** 2, axis=1, keepdims=True) + 1e-08) c1 = self.mapper(normalized) h = self.main(x) return flatten(h) if c is None else sum(h * c1, axis=1) / root(h.shape[1])
def __call__(self, xs, ys):
"""Calculate loss between outputs and ys.
Args:
xs: Source sentences.
ys: Target sentences.
Returns:
loss: Cross-entoropy loss between outputs and ys.
"""
batch_size = len(xs)
hxs = self.encoder(xs)
os = self.decoder(ys, hxs)
concatenated_os = F.concat(os, axis=0)
concatenated_ys = F.flatten(ys.T)
n_words = len(self.xp.where(concatenated_ys.data != PAD)[0])
loss = F.sum(
F.softmax_cross_entropy(concatenated_os,
concatenated_ys,
reduce='no',
ignore_label=PAD))
loss = loss / n_words
chainer.report({'loss': loss.data}, self)
perp = self.xp.exp(loss.data * batch_size / n_words)
chainer.report({'perp': perp}, self)
return loss
def dice_coefficent(self, predict, ground_truth):
'''
Assume label 0 is background
'''
dice_numerator = 0.0
dice_denominator = 0.0
eps = 1e-16
predict = F.flatten(predict[:,1:self._max_label,:,:,:])
ground_truth = F.flatten(ground_truth[:,1:self._max_label,:,:,:].astype(np.float32))
dice_numerator = F.sum(predict * ground_truth)
dice_denominator =F.sum(predict+ ground_truth)
dice = 2*dice_numerator/(dice_denominator+eps)
return dice
def forward(self, x):
x = F.relu(F.max_pooling_2d(self.conv1(x), 2))
x = F.relu(F.max_pooling_2d(F.dropout(self.conv2(x)), 2))
x = F.reshape(F.flatten(x), (-1, 320))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
return x
def GeneralizedDiceLossFunction(y,t,w):
dice_numerator=0.0
dice_denominator=0.0
eps = 0.0001
div = cp.float32(y.shape[0] * y.shape[1])
y = F.softmax(y,axis=1)
for i in range(y.shape[0]):#batch-size
soft = y[i]
tb = cp.array(t[i].flatten()).astype(cp.float32)
for j in range(y.shape[1]):#class-size
wb = cp.array(w[i][j].flatten()).astype(cp.float32)
V_in = cp.where(tb == j,1,0).astype(cp.float32)
t_temp = chainer.Variable(V_in)
w_temp = chainer.Variable(wb)
soft_temp = F.flatten(soft[j])
dice_numerator += F.sum(w_temp * soft_temp * t_temp)
dice_denominator += F.sum(w_temp * (soft_temp + t_temp))
loss = 2.0 * dice_numerator / (dice_denominator+eps)
return -loss
def __call__(self, x_p, x_v):
h_l = F.tanh(self.bn_l0(self.l_phr(x_p)))
h_v = F.tanh(self.bn_v0(self.l_img(x_v)))
h = h_l * 0.5 + h_v * 0.5
h = F.relu(self.bn_1(self.l_1(h)))
h = self.cls(h)
h = F.flatten(h)
return h
def forward(self, xs):
hs_0 = F.leaky_relu(self.l0_conv(xs), slope=0.2)
hs_1 = F.leaky_relu(self.l1_bn(self.l1_conv(hs_0)), slope=0.2)
hs_2 = F.leaky_relu(self.l2_bn(self.l2_conv(hs_1)), slope=0.2)
hs_3 = F.leaky_relu(self.l3_bn(self.l3_conv(hs_2)), slope=0.2)
hs_4 = self.l4_dense(F.flatten(hs_3).reshape(len(xs), -1))
return hs_4
def _calc_rpn_loss_bbox(self, rpn_bbox_pred, bbox_reg_targets, inds_inside):
# rpn_bbox_pred has the shape of (1, 4 x n_anchors, feat_h, feat_w)
n_anchors = self.proposal_layer._num_anchors
# Reshape it into (4, A, K)
rpn_bbox_pred = rpn_bbox_pred.reshape(4, n_anchors, -1)
# Transpose it into (K, A, 4)
rpn_bbox_pred = rpn_bbox_pred.transpose(2, 1, 0)
# Reshape it into (K x A, 4)
rpn_bbox_pred = rpn_bbox_pred.reshape(-1, 4)
# Keep the number of bbox
n_bbox = rpn_bbox_pred.shape[0]
# Select bbox and ravel it
rpn_bbox_pred = F.flatten(rpn_bbox_pred[inds_inside])
# Create batch dimension
rpn_bbox_pred = F.expand_dims(rpn_bbox_pred, 0)
# Ravel the targets and create batch dimension
bbox_reg_targets = bbox_reg_targets.ravel()[None, :]
# Calc Smooth L1 Loss (When delta=1, huber loss is SmoothL1Loss)
rpn_loss_bbox = F.huber_loss(rpn_bbox_pred, bbox_reg_targets,
self._delta)
rpn_loss_bbox /= n_bbox
return rpn_loss_bbox.reshape(())
def forward(self, inputs, device):
x, = inputs
y = functions.flatten(x)
return y,
