def decompress(self, tensor, ctx, *args, **kwargs):
"""Returns the tensor added with additional momentum for wd
m_t = \mu * m_{t-1} + wd * x_t
x_{t+1} = x_t - \eta_t (tensor + \mu m_t + wd * x_t)
"""
if "x" not in kwargs:
raise ValueError("x is missing")
x = kwargs["x"].astype(tensor.dtype, copy=False)
if not self.inited:
self.cache = nd.zeros_like(tensor)
if size(tensor.shape) >= self.threshold:
self.mom = nd.zeros_like(tensor)
self.wdmom = True
self.inited = True
# weight decay
nd._internal._mul_scalar(x, self.wd, out=self.cache)
# weight decay momentum
if self.wdmom:
self.mom += self.cache
nd._internal._mul_scalar(self.mom, self.mu, out=self.mom)
tensor += self.mom
tensor += self.cache
return self.compressor.decompress(tensor, ctx, *args, **kwargs)
def test_detach_updated_grad():
x = nd.ones((2, 2))
dx = nd.zeros_like(x)
y = nd.ones_like(x)
dy = nd.zeros_like(x)
mark_variables([x, y], [dx, dy])
assert x._fresh_grad == False
assert y._fresh_grad == False
with train_section():
x2 = x + 2
y2 = x2 + y
y2.backward()
assert (dx.asnumpy() == 1).all()
assert x._fresh_grad == True
assert y._fresh_grad == True
dx[:] = 0
x._fresh_grad = False
y._fresh_grad = False
assert x._fresh_grad == False
assert y._fresh_grad == False
with train_section():
x2 = x + 2
x2 = x2.detach()
y2 = x2 + y
y2.backward()
assert (dx.asnumpy() == 0).all()
assert y._fresh_grad == True
assert x._fresh_grad == False
def forward(self, data, im_info, gt_boxes, rpn_label, rpn_bbox_target, rpn_bbox_weight):
# We use a 1x1 tensor to indicate there is no gt_boxes for this images, as a zero size tensor can not be passed
# through multi-processing Dataloader (and also as_in_context).
is_negative = gt_boxes.size < 2
if not is_negative:
gt_boxes = gt_boxes[:, :, :5]
rois, rpn_cls_scores, rpn_bbox_preds, fpn_features = self.base_net.rpn(data, im_info)
if not is_negative:
proposal_targets_r = proposal_target(rois, gt_boxes[0].asnumpy(), config)
rcnn_labels, rcnn_bbox_targets, rcnn_bbox_weights = (nd.array(x, ctx=data.context) for x in
proposal_targets_r[1:])
rois = proposal_targets_r[0]
rois, rcnn_cls_score, rcnn_bbox_pred = self.base_net.rcnn(rois, fpn_features)
# If there is no gt_boxes for one image, we call it negative sample. Bounding box regression is not needed for
# a negative sample, so the rcnn_bbox_targets and rcnn_bbox_weights are both all zeros, and so is rcnn_labels.
if is_negative:
rcnn_bbox_targets = nd.zeros_like(rcnn_bbox_pred.squeeze())
rcnn_bbox_weights = nd.zeros_like(rcnn_bbox_pred.squeeze())
rcnn_labels = nd.zeros(shape=(rois.shape[0],), dtype='f', ctx=data.context)
rpn_cls_scores = [x.reshape(0, 2, -1) for x in rpn_cls_scores]
rpn_cls_scores = mx.nd.concat(*rpn_cls_scores, dim=2)
rpn_bbox_preds = [x.reshape(1, 4 * config.network.NUM_ANCHORS, -1) for x in rpn_bbox_preds]
rpn_bbox_preds = mx.nd.concat(*rpn_bbox_preds, dim=2)
loss_rpn_cls, loss_rpn_loc = self.rpn_criterion(rpn_cls_scores, rpn_bbox_preds,
rpn_label, rpn_bbox_target, rpn_bbox_weight)
loss_rcnn_cls, loss_rcnn_loc = self.rcnn_criterion(rcnn_cls_score, rcnn_bbox_pred, rcnn_labels,
rcnn_bbox_targets,
rcnn_bbox_weights)
return loss_rpn_cls, loss_rpn_loc, loss_rcnn_cls, loss_rcnn_loc, rpn_label, rpn_cls_scores
def test_detach_updated_grad():
x = nd.ones((2, 2))
dx = nd.zeros_like(x)
y = nd.ones_like(x)
dy = nd.zeros_like(x)
mark_variables([x, y], [dx, dy])
assert x._fresh_grad == False
assert y._fresh_grad == False
with record():
x2 = x + 2
y2 = x2 + y
y2.backward()
assert (dx.asnumpy() == 1).all()
assert x._fresh_grad == True
assert y._fresh_grad == True
dx[:] = 0
x._fresh_grad = False
y._fresh_grad = False
assert x._fresh_grad == False
assert y._fresh_grad == False
with record():
x2 = x + 2
x2 = x2.detach()
y2 = x2 + y
y2.backward()
assert (dx.asnumpy() == 0).all()
assert y._fresh_grad == True
assert x._fresh_grad == False
def forward_message_embedding(self, inputs, loss, training):
results = []
for i in range(self.slots):
results.append(self.local_trans(inputs[i], training=training))
results.append(self.global_trans(inputs[-1], training=training))
if self.use_comm:
for i in range(self.slots):
tmp = nd.zeros_like(results[i])
for j in range(self.slots):
msg = nd.softmax(
self.local2local_msg_encode(inputs[j],
training=training))
tmp = tmp + self.local2local_extract(
self.local2local_embedding(msg, training=training),
training=training)
msg = nd.softmax(
self.global2local_msg_encode(inputs[-1],
training=training))
tmp = tmp + self.global2local_extract(
self.global2local_embedding(msg, training=training),
training=training)
results[i] = results[i] + (tmp / float(self.slots))
tmp = nd.zeros_like(results[-1])
for i in range(self.slots):
msg = nd.softmax(
self.local2global_msg_encode(inputs[i], training=training))
tmp = tmp + self.local2global_extract(
self.local2global_embedding(msg, training=training),
training=training)
results[-1] = results[-1] + (tmp / float(self.slots))
return results
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
data = in_data[0]
rois = in_data[1]
BS, C, H, W = data.shape
N = rois.shape[0]
dout = out_grad[0]
ddata = nd.zeros_like(data)
rois = rois.asnumpy()
for i in range(N):
roi = rois[i]
batch_id = roi[0].astype(np.int64)
x1, y1, x2, y2 = roi[1:] * self.spatial_scale
x1, y1, x2, y2 = np.floor(x1), np.floor(y1), np.ceil(x2), np.ceil(
y2)
x1, y1, x2, y2 = np.clip(x1, 0, W), np.clip(y1, 0, H), np.clip(
x2, 0, W), np.clip(y2, 0, H)
x1, y1, x2, y2 = x1.astype(np.int64), y1.astype(
np.int64), x2.astype(np.int64), y2.astype(np.int64)
if x1 >= x2 or y1 >= y2:
continue
h = y2 - y1
w = x2 - x1
# (C, h, w)
roi_data = data[batch_id, :, y1:y2, x1:x2]
# (h*w, C)
roi_data = roi_data.reshape((C, -1)).transpose((1, 0))
# (h*w, C, 1)
roi_data = roi_data.reshape((0, 0, 1))
# (h*w, C, C)
out_product = nd.batch_dot(roi_data, roi_data.transpose((0, 2, 1)))
# (C, C)
if self.type == "max":
reduce_product = nd.max(out_product, axis=0)
max_mask = out_product == reduce_product
# max_index = nd.argmax(out_product, axis=0)
# max_index = max_index.reshape((C * C))
# d_max = nd.eye(h*w)[max_index].transpose((1, 0)).reshape((h*w, C, C))
dout_product = nd.stack(*[dout[i]
for _ in range(h * w)]) * max_mask
elif self.type == "mean":
dout_product = nd.stack(*[dout[i]
for _ in range(h * w)]) / (h * w)
else:
raise NotImplementedError()
droi_data = []
for j in range(C):
droi_data.append(
nd.sum(dout_product[:, j, :] * roi_data[:, :, 0], axis=1) +
nd.sum(dout_product[:, :, j] * roi_data[:, :, 0], axis=1))
droi_data = nd.stack(*droi_data, axis=1) # (hw, C)
droi_data = droi_data.transpose((1, 0)).reshape((C, h, w))
ddata[batch_id, :, y1:y2, x1:x2] = droi_data
self.assign(in_grad[0], req[0], ddata)
self.assign(in_grad[1], req[1], nd.zeros_like(in_data[1]))
def _init_states(self):
if self._e == [] and self._x == []:
# initialize the remaining error
for i, param in enumerate(self._params):
if param.grad_req != 'null':
self._e.append(zeros_like(param.list_data()[0]))
self._x.append(zeros_like(param.list_data()[0]))
else:
self._e.append([])
self._x.append([])
self._states_to_init = False
def kv_push(self, key, value):
#if value.context!=mx.cpu():
# value = value.as_in_context(mx.cpu())
if not key in self._kvinit:
self._distkv.init(key, nd.zeros_like(value))
self._kvinit[key] = 1
self._distkv.push(key, value)
def train(hyperparameters, hosts, num_gpus, **kwargs):
data_dir = os.environ["SM_CHANNEL_TRAIN"]
data_file = os.listdir(data_dir)[0]
num_shots = int(hyperparameters.get("num_shots", 30))
team = hyperparameters.get("team")
create_board = True
games = 0
with open(data_dir + '/' + data_file) as f:
for x in f:
games += 1
record = json.loads(x)
if create_board:
board = nd.zeros_like(nd.array(record["TeamB"]["board"]))
create_board = False
if record["TeamB"]["TeamName"] != team:
for shot in record["TeamB"]["shots"][:num_shots]:
board[shot["y"]][shot["x"]] += 1
if record["TeamA"]["TeamName"] != team:
for shot in record["TeamA"]["shots"][:num_shots]:
board[shot["y"]][shot["x"]] += 1
print(board)
board = 1 / (board + 0.01)
board = board / board.sum()
print(board)
save(board)
def activation(X, act_type='relu'):
if act_type == 'relu':
return nd.maximum(X, nd.zeros_like(X))
elif act_type == 'elu':
return nd.LeakyReLU(X, act_type=act_type)
else:
print('Something wrong with the act_type!')
def forward(self, inputs, is_target=False):
result = None
loss = 0.
for _ in range(self.n_samples):
tmp = inputs
weights = []
biases = []
for i in range(len(self.weight_mus)):
weights.append(self.get_sample(
mu=self.weight_mus[i].data(), rho=self.weight_rhos[i].data(), is_target=is_target))
biases.append(self.get_sample(mu=self.bias_mus[i].data(), rho=self.bias_rhos[i].data(), is_target=is_target))
loss = loss + log_gaussian(
x=weights[-1], mu=self.weight_mus[i].data(), sigma=softplus(self.weight_rhos[i].data()))
loss = loss + log_gaussian(x=biases[-1], mu=self.bias_mus[i].data(), sigma=softplus(self.bias_rhos[i].data()))
loss = loss - log_gaussian(x=weights[-1], mu=0., sigma=self.sigma_prior)
loss = loss - log_gaussian(x=weights[-1], mu=0., sigma=self.sigma_prior)
for i in range(len(weights)):
tmp = nd.dot(tmp, weights[i]) + biases[i]
if i != len(weights) - 1:
tmp = nd.relu(tmp)
if result is None:
result = nd.zeros_like(tmp)
result = result + tmp
result = result / float(self.n_samples)
loss = loss / float(self.n_samples)
return result, loss
def update(self, data, batch_size, episode_num, discount_factor):
with autograd.record():
observations = nd.zeros((batch_size, 1, 128, 128))
actions = nd.zeros(batch_size)
rewards = nd.zeros_like(actions)
next_obs = nd.zeros_like(observations)
dones = nd.zeros_like(actions)
for i in range(batch_size):
observations[i] = data[i].obs
actions[i] = data[i].action
rewards[i] = data[i].reward
next_obs[i] = data[i].next_obs
dones[i] = data[i].done
actions = actions.reshape((-1, 1))
rewards = rewards.reshape((-1, 1))
dones = dones.reshape((-1, 1))
print('observations:', observations.shape)
print('actions:', actions.shape)
print('rewards:', rewards.shape)
print('next observations:', next_obs.shape)
print('dones:', dones.shape)
not_dones = nd.array(np.logical_not(dones).astype('int8'))
with autograd.predict_mode():
next_max_action_values = nd.max(self.model(next_obs), 1)
target = nd.array(
rewards) + discount_factor * next_max_action_values * not_dones
del next_max_action_values
obs_values = self.model(observations)
obs_actions_values = nd.zeros_like(actions)
for i in range(len(obs_actions_values)):
obs_actions_values[i] = obs_values[i][actions[i]]
del obs_values
loss = self.loss(obs_actions_values, target)
loss.backward()
self.trainer.step(batch_size, True)
return loss
def _init_params_cache(self):
if self._params_cache == []:
# initialize the states
for i, param in enumerate(self._params):
if param.grad_req != 'null':
self._params_cache.append(zeros_like(param.list_data()[0]))
else:
self._params_cache.append([])
self._params_cache_to_init = False
def test_program():
import matplotlib.pyplot as plt
import matplotlib.patches as patches
ssd = ssd_mx.ssd_model()
for model in ssd:
model.initialize()
data = get_iterators(data_shape=304, batch_size=4)
batch_data = data.next()
# 将-1占位符改为背景标签0，对应坐标框记录为[0,0,0,0]
label = nd.where(batch_data.label[0] < 0,
nd.zeros_like(batch_data.label[0]), batch_data.label[0])
anchors, class_preds, box_preds = ssd_mx.ssd_forward(batch_data.data[0], ssd)
target_labels, target_localizations, target_scores = \
ssd_mx.bboxes_encode(label[:, :, 0],
label[:, :, 1:],
anchors)
# print(label[:, :, 0].shape, label[:, :, 1:].shape)
# print('target_labels', [f.shape for f in target_labels])
# print('target_localizations', [f.shape for f in target_localizations])
# print('target_scores', [f.shape for f in target_scores])
print('[*] class_preds', [f.shape for f in class_preds])
print('[*] box_preds', [f.shape for f in box_preds])
# Add loss function.
logits, gclasses, no_classes, fpmask, fnmask = \
ssd_mx.data_reshape(class_preds, box_preds,
target_labels, target_localizations, target_scores,
match_threshold=.5,
negative_ratio=3)
p_cls_loss = util_mx.FocalLoss()
n_cls_loss = util_mx.FocalLoss()
print(nd.sum(p_cls_loss(logits, gclasses) * fpmask),
nd.sum(n_cls_loss(logits, no_classes) * fnmask))
reg_loss = util_mx.SmoothL1Loss()
print(nd.sum(reg_loss(box_preds, target_localizations, fpmask.expand_dims(-1))))
# .asnumpy比使用np.array速度快得多
plt.imshow(batch_data.data[0][2].asnumpy().transpose(1, 2, 0) / 255.)
currentAxis = plt.gca()
for i in range(6):
box = batch_data.label[0][2][i][1:].asnumpy() * 300
if any(box < 0):
continue
print(int(batch_data.label[0][2][i][0].asscalar()))
rect = patches.Rectangle((box[1], box[0]), box[3] - box[1], box[2] - box[0],
linewidth=1, edgecolor='g', facecolor='none')
currentAxis.add_patch(rect)
plt.show()
def wrapped(*args):
"""Wrapped function."""
variables = args
if argnum is not None:
argnum_ = argnum if isinstance(argnum, list) else [argnum]
variables = [args[i] for i in argnum_]
for x in variables:
assert isinstance(x, NDArray), "type of autograd input should NDArray."
grads = [zeros_like(x) for x in variables]
mark_variables(variables, grads)
with record():
outputs = func(*args)
backward([outputs] if isinstance(outputs, NDArray) else outputs)
return grads, outputs
def get_disc_loss(gen, disc, loss_fn, X, batch_size, z_dim, ctx):
# loss from real images
y_pred_real = disc(X).reshape(X.shape[0], -1)
y_true_real = nd.ones_like(y_pred_real)
loss_real = loss_fn(y_pred_real, y_true_real)
# loss from fake images
z = nd.random.randn(batch_size, z_dim, 1, 1, ctx=ctx)
xhat = gen(z).detach()
y_pred_fake = disc(xhat).reshape(X.shape[0])
y_true_fake = nd.zeros_like(y_pred_fake)
loss_fake = loss_fn(y_pred_fake, y_true_fake)
# total discriminator loss
loss = 0.5 * (loss_real + loss_fake)
return loss
def test_out_grads():
x = nd.ones((3, 5))
dx = nd.zeros_like(x)
mark_variables([x], [dx])
da = None
db = nd.array([1, 2, 3, 4, 5])
dc = nd.array([5, 4, 3, 2, 1])
with record():
a, b, c = nd.split(x, axis=0, num_outputs=3, squeeze_axis=True)
backward([a, b, c], [da, db, dc])
assert (dx.asnumpy() == np.array([[1, 1, 1, 1, 1], [1, 2, 3, 4, 5],
[5, 4, 3, 2, 1]])).all()
def fftfilt_nd(x, params):
(b, m, nx, nb, L, nfft) = params
B = nd.contrib.fft(data=nd.concatenate(
[b.T, nd.zeros(shape=(1, (nfft - b.size)), ctx=ctx)], axis=1))
if b.size == 1:
B = B.T # make sure fft of B is a column (might be a row if b is scalar)
if b.shape[1] == 1:
B = nd.repeat(data=B, repeats=x.shape[1],
axis=0) # replicate the column B
B_re = nd.slice(data=B, begin=(0, 0), end=(0, None), step=(1, 2))
B_im = nd.slice(data=B, begin=(0, 1), end=(0, None), step=(1, 2))
if x.shape[1] == 1:
x = nd.repeat(data=x, repeats=b.shape[1],
axis=1) # replicate the column x
y = nd.zeros_like(x.T)
istart = 1
while istart <= nx:
iend = min(istart + L - 1, nx)
if (iend - istart) == 0:
X = x[istart] * np.ones((nfft, 1)) # need to fft a scalar
else:
temp = nd.slice(x, begin=istart - 1, end=iend).T
X = nd.contrib.fft(data=nd.concatenate([
temp,
nd.zeros(shape=(temp.shape[0], (nfft - temp.shape[1])),
ctx=ctx)
],
axis=1))
X_re = nd.slice(data=X, begin=(0, 0), end=(0, None), step=(1, 2))
X_im = nd.slice(data=X, begin=(0, 1), end=(0, None), step=(1, 2))
XprodB_re = (X_re * B_re - X_im * B_im)
XprodB_im = (X_re * B_im + X_im * B_re)
Ytemp = nd.zeros((X.shape[0], X.shape[1]), ctx=ctx)
Ytemp[:, ::2] = XprodB_re
Ytemp[:, 1::2] = XprodB_im
Y = mx.contrib.ndarray.ifft(Ytemp / nfft) # only the real part!!!!
yend = min(nx, istart + nfft - 1)
y[:, istart - 1:yend] = nd.slice(
data=y, begin=(0, istart - 1), end=(0, yend),
step=(1, 1)) + nd.slice(
data=Y, begin=(0, 0), end=(0, yend - istart + 1), step=(1, 1))
istart += L
# y = real(y)
return y
def wrapped(*args):
"""Wrapped function."""
variables = args
if argnum is not None:
argnum_ = argnum if isinstance(argnum, list) else [argnum]
variables = [args[i] for i in argnum_]
for x in variables:
assert isinstance(x, NDArray), "type of autograd input should NDArray."
grads = [zeros_like(x) for x in variables]
mark_variables(variables, grads)
with record():
outputs = func(*args)
backward([outputs] if isinstance(outputs, NDArray) else outputs)
return grads, outputs
def test_out_grads():
x = nd.ones((3, 5))
dx = nd.zeros_like(x)
mark_variables([x], [dx])
da = None
db = nd.array([1,2,3,4,5])
dc = nd.array([5,4,3,2,1])
with train_section():
a, b, c = nd.split(x, axis=0, num_outputs=3, squeeze_axis=True)
backward([a, b, c], [da, db, dc])
assert (dx.asnumpy() == np.array(
[[1,1,1,1,1],
[1,2,3,4,5],
[5,4,3,2,1]])).all()
def decompress(self, tensor, ctx, *args, **kwargs):
"""Add nesterov momentum for uncompressed gradients"""
tensor = self.compressor.decompress(tensor, ctx, *args, **kwargs)
# uncompressed gradients need to do nag explicitly
if not self.inited:
if size(tensor.shape) < self.threshold:
self.mom = nd.zeros_like(tensor)
self.nag = True
self.inited = True
if self.nag:
self.mom += tensor
nd._internal._mul_scalar(self.mom, self.mu, out=self.mom)
tensor += self.mom
return tensor
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
# 1.update class center
for class_id in xrange(int(self.num_class)):
center_diff = nd.where(nd.array(
(self.label == class_id).astype(np.int8)),
x=self.diff,
y=nd.zeros_like(self.diff))
# print nd.where(nd.array(self.label==class_id),diff,nd.zeros(diff))
# print "class id", class_id,
self.center[class_id] += self.alpha * nd.sum(center_diff, axis=0)
# print self.center
# 2. assign grad to former layer
self.assign(
in_grad[0], req[0],
self.diff.reshape(self.diff_reshape).transpose(
(0, 3, 1, 2)) * self.grad_scale)
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
if ReluOp.guided_backprop:
# Get output and gradients of output
y = out_data[0]
dy = out_grad[0]
# Zero out the negatives in the gradients of the output
dy_positives = nd.maximum(dy, nd.zeros_like(dy))
# What output values were greater than 0?
y_ones = y.__gt__(0)
# Mask out the values for which at least one of dy or y is negative
dx = dy_positives * y_ones
self.assign(in_grad[0], req[0], dx)
else:
# Regular backward for ReLU
x = in_data[0]
x_gt_zero = x.__gt__(0)
dx = out_grad[0] * x_gt_zero
self.assign(in_grad[0], req[0], dx)
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
if ReluOp.guided_backprop:
# Get output and gradients of output
y = out_data[0]
dy = out_grad[0]
# Zero out the negatives in the gradients of the output
dy_positives = nd.maximum(dy, nd.zeros_like(dy))
# What output values were greater than 0?
y_ones = y.__gt__(0)
# Mask out the values for which at least one of dy or y is negative
dx = dy_positives * y_ones
self.assign(in_grad[0], req[0], dx)
else:
# Regular backward for ReLU
x = in_data[0]
x_gt_zero = x.__gt__(0)
dx = out_grad[0] * x_gt_zero
self.assign(in_grad[0], req[0], dx)
def forward(self, is_train, req, in_data, out_data, aux):
arm_cls_preds = in_data[0]
odm_cls_target = in_data[1]
odm_loc_target_mask = in_data[2]
arm_cls_preds = nd.softmax(data=arm_cls_preds)
arm_cls_preds_classes = nd.split(data=arm_cls_preds,axis=1,num_outputs=2)
# arm_cls_preds_bg shape : (batch , h*w*num_anchors[:layers]) 负类【0】
arm_cls_preds_bg = nd.reshape(data=arm_cls_preds_classes[0],shape=(0,-1))
prob_temp = nd.ones_like(arm_cls_preds_bg)*0.99
cond1 = arm_cls_preds_bg >= prob_temp # > 0.99 idx is 1
# print('negative cond1 ------- :',heapq.nlargest(2,arm_cls_preds_bg[0]))
temp1 = nd.ones_like(odm_cls_target)*(-1) ### TODO： 0 还是-1表示背景??
# 如果ARM分类出的负类的置信度大于0.99，将其在ODM的anchor标号中去掉（-1替代），负类转换为背景
odm_cls_target_mask = nd.where(condition=cond1,x=temp1,y=odm_cls_target)
# apply filtering to odm_loc_target_mask
# odm_loc_target_mask_shape: (batch, num_anchors, 4)
arm_cls_preds_bg = nd.reshape(data=arm_cls_preds_bg,shape=(0,-1,1))#(batch , h*w*num_anchors[:layers],1)
# (batch , h*w*num_anchors[:layers] , 4 )
odm_loc_target_mask = nd.reshape(data=odm_loc_target_mask,shape=(0,-1,4))
odm_loc_target_mask = odm_loc_target_mask[:,:,0] #(batch , h*w*num_anchors[:layers])
#(batch , h*w*num_anchors[:layers], 1)
## 取整个batch中 所有行的 第一列，相当于对原来的4个相同label[0 0 0 0 ],[1 1 1 1]变成[0],[1]
odm_loc_target_mask = nd.reshape(data=odm_loc_target_mask,shape=(0,-1,1))
loc_temp = nd.ones_like(odm_loc_target_mask)*0.99
cond2 = arm_cls_preds_bg >= loc_temp
temp2 = nd.zeros_like(odm_loc_target_mask) # 取0
# 如果ARM分类出的负类的置信度大于0.99，将其在ODM的掩码置0
## 实际上不管IOU计算的大小，用AMR的分类结果，如果是大于0.99的负类，不管通过IOU判断的正负类结果如何，都设置为背景
odm_loc_target_bg_mask = nd.where(cond2,temp2,odm_loc_target_mask)
odm_loc_target_bg_mask = nd.concat(*[odm_loc_target_bg_mask]*4,dim=2)
# 还原维度
odm_loc_target_bg_mask = nd.reshape(odm_loc_target_bg_mask,shape=(0,-1))
for ind, val in enumerate([odm_cls_target_mask, odm_loc_target_bg_mask]):
self.assign(out_data[ind], req[ind], val)
def draw(self):
'''
Draw samples from the fake distribution.
Returns:
`Tuple` of `mxnet.ndarray`s.
The shape is ... $(\hat{z}, x)$.
'''
condition_arr = self.condition_sampler.draw()
if condition_arr.ndim == 5:
seq_len = condition_arr.shape[1]
else:
seq_len = 1
soft_assignment_arr = condition_arr
if seq_len == 1:
x_arr = self.model(condition_arr)
else:
soft_assignment_arr = nd.zeros_like(condition_arr)
for i in range(seq_len):
x_arr[:, i] = self.model(condition_arr[:, i])
return x_arr, soft_assignment_arr
def hybrid_forward(self, F, pred, label, sample_weight=None):
if not self._from_logits:
pred = F.log_softmax(pred, axis=self._axis)
if self._sparse_label:
if self._size_average:
valid_label_map = (label !=
self._ignore_label).astype('float32')
loss = -(F.pick(pred, label, axis=self._axis, keepdims=True) *
valid_label_map)
else:
loss = -F.pick(pred, label, axis=self._axis, keepdims=True)
loss = F.where(
label.expand_dims(axis=self._axis) == self._ignore_label,
F.zeros_like(loss), loss)
else:
label = _reshape_like(F, label, pred)
loss = -F.sum(pred * label, axis=self._axis, keepdims=True)
loss = _apply_weighting(F, loss, self._weight, sample_weight)
if self._size_average:
return F.mean(loss, axis=self._batch_axis, exclude=True) * \
valid_label_map.size / F.sum(valid_label_map)
else:
return F.mean(loss, axis=self._batch_axis, exclude=True)
def do_transform_ip(self, buffer: Gst.Buffer) -> Gst.FlowReturn:
try:
# convert Gst.Buffer to np.ndarray
caps = self.sinkpad.get_current_caps()
#it's a reference on GstBuffer data
#if you modify it output will be modified as well
image = gst_buffer_with_caps_for_ndarray(buffer, caps)
#c, h, w = image.shape
#convert to NDArray
t = nd.array(image, dtype=np.float32)
#clip low level signals to 0
if self.minimal > 0:
if self.zeros_vec is None:
#since we don't expect change of frame parametors,
# must not make it every time
self.zeros_vec = nd.zeros_like(t)
t = nd.where(t < self.minimal, self.zeros_vec, t)
t = self.apply_conv(t)
#clear output
image.fill(0)
#detach from mxnet context and copy to numpy.nddarray[w,h]
conved = t[0, 0, :, :].asnumpy()
#simple contrast
if self.contrast == True:
conved = simpleContrast(conved, 0.0)
#copy to top left coner
ch, cw = conved.shape
image[0, :ch, :cw] = conved
except Exception as e:
logging.info(conved.shape)
logging.error(e)
return Gst.FlowReturn.OK
def replace_inf_with_zero(x):
return nd.where(nd.abs(x) == np.inf, nd.zeros_like(x), x)
def zeros_like(input):
return nd.zeros_like(input)
trainer = mx.gluon.Trainer(ssd.collect_params(),
'sgd', {'learning_rate': 0.01, 'wd': 5e-4})
data = get_iterators(data_shape=304, batch_size=batch_size)
for epoch in range(30):
# reset data iterators and metrics
data.reset()
cls_metric.reset()
# box_metric.reset()
tic = time.time()
for i, batch in enumerate(data):
start_time = time.time()
x = batch.data[0].as_in_context(ctx)
y = batch.label[0].as_in_context(ctx)
# 将-1占位符改为背景标签0，对应坐标框记录为[0,0,0,0]
y = nd.where(y < 0, nd.zeros_like(y), y)
with mx.autograd.record():
anchors, class_preds, box_preds = ssd(x, False)
target_labels, target_localizations, target_scores = \
ssd_mx.bboxes_encode(y[:, :, 0],
y[:, :, 1:],
anchors)
logits, gclasses, no_classes, fpmask, fnmask, localisations, glocalisations = \
ssd_mx.data_reshape(class_preds, box_preds,
target_labels, target_localizations, target_scores,
match_threshold=.5,
negative_ratio=3)
p_cls = nd.sum(p_cls_loss(logits, gclasses) * fpmask)
n_cls = nd.sum(n_cls_loss(logits, no_classes) * fnmask)
def log_pdf_grad(self, x, args):
grad = nd.zeros_like(x)
return grad
print('a+b:', a + b)
# 跟 Numpy 的转换
x = np.ones((2, 3))
y = nd.array(x)
z = y.asnumpy()
print([z, y])
# 替换操作
x = nd.ones((3, 4))
y = nd.ones((3, 4))
before = id(y)
y = y + x
print(id(y) == before)
z = nd.zeros_like(x)
before = id(z)
z[:] = x + y
print(id(z) == before)
nd.elemwise_add(x, y, out=z)
print(id(z) == before)
# 截取 (Slicing)
x = nd.arange(0, 9).reshape((3, 3))
print('x:', x)
print(x[1:3])
x[1, 2] = 9.0
print(x)
def forward(self, is_train, req, in_data, out_data, aux):
x = in_data[0]
y = nd.maximum(x, nd.zeros_like(x))
self.assign(out_data[0], req[0], y)
def forward(self, inputs, loss=None):
assert len(inputs) == self.slots + 1
if self.non_local_mode:
return self.forward_multidims(inputs, loss)
if self.message_embedding:
return self.forward_message_embedding(inputs, loss)
local_drop_vec = nd.ones_like(inputs[0])
local_drop_vec = self.local_dropout_op(local_drop_vec)
for i in range(self.slots):
inputs[i] = inputs[i] * local_drop_vec
inputs[-1] = self.global_dropout_op(inputs[-1])
# local_share_vec = []
# local_private_vec = []
# if self.concrete_share_rate:
# raise ValueError('no share_private!!!')
# for i in range(self.slots):
# proba = nd.sigmoid(data=self.share_rate[i].data())
# proba = nd.broadcast_axis(data=proba, axis=(0, 1), size=inputs[0].shape)
# u_vec = nd.random_uniform(low=1e-5, high=1. - 1e-5, shape=inputs[0].shape, ctx=CTX)
# local_share_vec.append(nd.sigmoid(10. * (
# nd.log(proba) - nd.log(1. - proba) +
# nd.log(u_vec) - nd.log(1. - u_vec)
# )))
# local_private_vec.append(1. - local_share_vec[i])
# # print 'proba:', proba
# # print 'dropout_regularizer:', self.dropout_regularizer
# if loss is not None:
# loss.append(
# self.dropout_regularizer * nd.sum(proba * nd.log(proba) + (1. - proba) * nd.log(1. - proba)))
# if random.random() < 0.01:
# for i in range(self.slots):
# proba = nd.sigmoid(data=self.share_rate[i].data())
# print proba.asnumpy(),
# print ''
# else:
# local_share_vec = [nd.ones_like(inputs[0]), ] * self.slots
# local_private_vec = [nd.zeros_like(inputs[0]), ] * self.slots
# local_share_vec = (1. - self.private_rate) * nd.Dropout(
# nd.ones(shape=(inputs[0].shape[0], self.local_units)), p=self.private_rate, mode='always')
# local_private_vec = 1. - local_share_vec
comm_rate = nd.ones(shape=(self.slots + 1, self.slots + 1))
if self.use_comm and self.topo_learning_mode:
proba = nd.sigmoid(self.topo.data())
if random.random() < 1e-2:
print '---------------------------------------------'
print proba.asnumpy()
print '---------------------------------------------'
u_vec = nd.random_uniform(low=1e-5, high=1. - 1e-5, shape=(self.slots + 1, self.slots + 1))
comm_rate = nd.sigmoid(10. * (
nd.log(proba) - nd.log(1. - proba) +
nd.log(u_vec) - nd.log(1. - u_vec)
))
if loss is not None:
loss.append(4e-4 * nd.sum(proba * nd.log(proba) + (1. - proba) * nd.log(1. - proba)))
results = []
for i in range(self.slots):
results.append(self.local_share_trans(inputs[i]))
results.append(self.global_trans(inputs[-1]))
if self.use_comm:
if self.topo_learning_mode:
assert self.concrete_share_rate is False
for i in range(self.slots):
tmp = nd.zeros_like(results[i])
norm = nd.zeros_like(comm_rate[0][0])
for j in range(self.slots):
if i != j:
tmp = tmp + self.local2local_share_comm(inputs[j]) * comm_rate[j][i]
norm = norm + comm_rate[j][i]
# results[i] = results[i] + self.global2local_comm(inputs[-1]) * comm_rate[-1][i]
tmp = tmp + self.global2local_comm(inputs[-1]) * comm_rate[-1][i]
norm = norm + comm_rate[-1][i]
if nd.sum(norm) > 1e-5:
results[i] = results[i] + tmp / norm
tmp = nd.zeros_like(results[-1])
norm = nd.zeros_like(comm_rate[0][0])
for j in range(self.slots):
tmp = tmp + self.local2global_comm(inputs[j]) * comm_rate[j][-1]
norm = norm + comm_rate[j][-1]
if nd.sum(norm) > 1e-5:
results[-1] = results[-1] + tmp / norm
else:
for i in range(self.slots):
tmp = nd.zeros_like(results[i])
for j in range(self.slots):
if j != i:
tmp = tmp + self.local2local_share_comm(inputs[j])
tmp = tmp + self.global2local_comm(inputs[-1])
results[i] = results[i] + (tmp / float(self.slots))
tmp = nd.zeros_like(results[-1])
for i in range(self.slots):
tmp = tmp + self.local2global_comm(inputs[i])
results[-1] = results[-1] + (tmp / float(self.slots))
if self.block_mode:
assert self.local_in_units == self.local_units
assert self.global_in_units == self.global_units
for i in range(self.slots):
results[i] = self.yz_weight_local(results[i]) + inputs[i]
results[-1] = self.yz_weight_global(results[-1]) + inputs[-1]
return results