def check_binary_func(x, y):
f_add = lambda x, y: x+y
f_add_grad = lambda x, y: [nd.ones(x.shape), nd.ones(y.shape)]
autograd_assert(x, y, func=f_add, grad_func=f_add_grad)
f_mul = lambda x, y: x*y
f_mul_grad = lambda x, y: [y, x]
autograd_assert(x, y, func=f_mul, grad_func=f_mul_grad)
f_compose = lambda x, y: x+x*y
f_compose_grad = lambda x, y: [nd.ones(x.shape) + y, x]
autograd_assert(x, y, func=f_compose, grad_func=f_compose_grad)
def test_binary_func():
x = nd.uniform(shape=(4, 5))
y = nd.uniform(shape=(4, 5))
f_add = lambda x, y: x+y
f_add_grad = lambda x, y: [nd.ones(x.shape), nd.ones(y.shape)]
autograd_assert(x, y, func=f_add, grad_func=f_add_grad)
f_mul = lambda x, y: x*y
f_mul_grad = lambda x, y: [y, x]
autograd_assert(x, y, func=f_mul, grad_func=f_mul_grad)
f_compose = lambda x, y: x+x*y
f_compose_grad = lambda x, y: [nd.ones(x.shape) + y, x]
autograd_assert(x, y, func=f_compose, grad_func=f_compose_grad)
def test_argnum():
def f_with_mode(a, b, mode):
if mode:
return a+b
else:
return a*b
a = nd.uniform(shape=(3, 2))
b = nd.uniform(shape=(3, 2))
f_add_grad = lambda x, y, mode: [nd.ones(x.shape), nd.ones(y.shape)]
f_mul_grad = lambda x, y, mode: [y, x]
autograd_assert(a, b, True,
argnum=[0, 1], func=f_with_mode, grad_func=f_add_grad)
autograd_assert(a, b, False,
argnum=[0, 1], func=f_with_mode, grad_func=f_mul_grad)
def _init_NDArrayIter_data(data_type, is_image=False):
if is_image:
data = nd.random.uniform(0, 255, shape=(5000, 1, 28, 28))
labels = nd.ones((5000, 1))
return data, labels
if data_type == 'NDArray':
data = nd.ones((1000, 2, 2))
labels = nd.ones((1000, 1))
else:
data = np.ones((1000, 2, 2))
labels = np.ones((1000, 1))
for i in range(1000):
data[i] = i / 100
labels[i] = i / 100
return data, labels
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 test_training():
x = nd.ones((10, 10))
with train_section():
y = nd.Dropout(x, p=0.5)
assert not (y.asnumpy() == x.asnumpy()).all()
with test_section():
y = nd.Dropout(x, p=0.5)
assert (y.asnumpy() == x.asnumpy()).all()
def bilinear(x, W, y, input_size, seq_len, batch_size, num_outputs=1, bias_x=False, bias_y=False):
"""Do xWy
Parameters
----------
x : NDArray
(input_size x seq_len) x batch_size
W : NDArray
(num_outputs x ny) x nx
y : NDArray
(input_size x seq_len) x batch_size
input_size : int
input dimension
seq_len : int
sequence length
batch_size : int
batch size
num_outputs : int
number of outputs
bias_x : bool
whether concat bias vector to input x
bias_y : bool
whether concat bias vector to input y
Returns
-------
output : NDArray
[seq_len_y x seq_len_x if output_size == 1 else seq_len_y x num_outputs x seq_len_x] x batch_size
"""
if bias_x:
x = nd.concat(x, nd.ones((1, seq_len, batch_size)), dim=0)
if bias_y:
y = nd.concat(y, nd.ones((1, seq_len, batch_size)), dim=0)
nx, ny = input_size + bias_x, input_size + bias_y
# W: (num_outputs x ny) x nx
lin = nd.dot(W, x)
if num_outputs > 1:
lin = reshape_fortran(lin, (ny, num_outputs * seq_len, batch_size))
y = y.transpose([2, 1, 0]) # May cause performance issues
lin = lin.transpose([2, 1, 0])
blin = nd.batch_dot(lin, y, transpose_b=True)
blin = blin.transpose([2, 1, 0])
if num_outputs > 1:
blin = reshape_fortran(blin, (seq_len, num_outputs, seq_len, batch_size))
return blin
def gan_loss(input,target_is_real):
if target_is_real:
target = nd.ones(input.shape,ctx=input.context)
else:
target = nd.zeros(input.shape, ctx=input.context)
#mse loss for lsgan
e = ((input - target) ** 2).mean(axis=0, exclude=True)
return e
def test_training():
x = nd.ones((10, 10))
with record():
y = nd.Dropout(x, p=0.5)
assert not (y.asnumpy() == x.asnumpy()).all()
with pause():
y = nd.Dropout(x, p=0.5)
assert (y.asnumpy() == x.asnumpy()).all()
def forward(self, x):
if isinstance(x, np.ndarray):
x = nd.array(x)
if self._max_len > x.size:
pad = nd.ones((self._max_len - x.size,)) * self._fill_value
x = nd.concat(x, pad, dim=0)
elif self._max_len < x.size:
x = x[:self._max_len]
return x
def dumpR(data_set, mx_model, batch_size, name='', data_extra = None, label_shape = None):
print('dump verification embedding..')
data_list = data_set[0]
issame_list = data_set[1]
model = mx_model
embeddings_list = []
if data_extra is not None:
_data_extra = nd.array(data_extra)
time_consumed = 0.0
if label_shape is None:
_label = nd.ones( (batch_size,) )
else:
_label = nd.ones( label_shape )
for i in xrange( len(data_list) ):
data = data_list[i]
embeddings = None
ba = 0
while ba<data.shape[0]:
bb = min(ba+batch_size, data.shape[0])
count = bb-ba
_data = nd.slice_axis(data, axis=0, begin=bb-batch_size, end=bb)
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
if data_extra is None:
db = mx.io.DataBatch(data=(_data,), label=(_label,))
else:
db = mx.io.DataBatch(data=(_data,_data_extra), label=(_label,))
model.forward(db, is_train=False)
net_out = model.get_outputs()
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed+=diff.total_seconds()
if embeddings is None:
embeddings = np.zeros( (data.shape[0], _embeddings.shape[1]) )
embeddings[ba:bb,:] = _embeddings[(batch_size-count):,:]
ba = bb
embeddings_list.append(embeddings)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
actual_issame = np.asarray(issame_list)
outname = os.path.join('temp.bin')
with open(outname, 'wb') as f:
pickle.dump((embeddings, issame_list), f, protocol=pickle.HIGHEST_PROTOCOL)
def check_unary_func(x):
f_exp = lambda x: nd.exp(x)
f_exp_grad = lambda x: [nd.exp(x)]
autograd_assert(x, func=f_exp, grad_func=f_exp_grad)
f_half = lambda x: x/2
f_half_grad = lambda x: [nd.ones(x.shape) * 0.5]
autograd_assert(x, func=f_half, grad_func=f_half_grad)
f_square = lambda x: x**2
f_square_grad = lambda x: [2*x]
autograd_assert(x, func=f_square, grad_func=f_square_grad)
def test_unary_func():
x = nd.uniform(shape=(4, 5))
f_exp = lambda x: nd.exp(x)
f_exp_grad = lambda x: [nd.exp(x)]
autograd_assert(x, func=f_exp, grad_func=f_exp_grad)
f_half = lambda x: x/2
f_half_grad = lambda x: [nd.ones(x.shape) * 0.5]
autograd_assert(x, func=f_half, grad_func=f_half_grad)
f_square = lambda x: x**2
f_square_grad = lambda x: [2*x]
autograd_assert(x, func=f_square, grad_func=f_square_grad)
def test_module_input_grads():
a = mx.sym.Variable('a', __layout__='NC')
b = mx.sym.Variable('b', __layout__='NC')
c = mx.sym.Variable('c', __layout__='NC')
c = a + 2 * b + 3 * c
net = mx.mod.Module(c, data_names=['b', 'c', 'a'], label_names=None,
context=[mx.cpu(0), mx.cpu(1)])
net.bind(data_shapes=[['b', (5, 5)], ['c', (5, 5)], ['a', (5, 5)]],
label_shapes=None, inputs_need_grad=True)
net.init_params()
net.forward(data_batch=mx.io.DataBatch(data=[nd.ones((5, 5)),
nd.ones((5, 5)),
nd.ones((5, 5))]))
net.backward(out_grads=[nd.ones((5, 5))])
input_grads = net.get_input_grads()
b_grad = input_grads[0].asnumpy()
c_grad = input_grads[1].asnumpy()
a_grad = input_grads[2].asnumpy()
assert np.all(a_grad == 1), a_grad
assert np.all(b_grad == 2), b_grad
assert np.all(c_grad == 3), c_grad
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 lfw_test(nbatch):
print('testing lfw..')
embeddings_list = []
for i in xrange( len(lfw_data_list) ):
lfw_data = lfw_data_list[i]
embeddings = None
ba = 0
while ba<lfw_data.shape[0]:
bb = min(ba+args.batch_size, lfw_data.shape[0])
_data = nd.slice_axis(lfw_data, axis=0, begin=ba, end=bb)
_label = nd.ones( (bb-ba,) )
db = mx.io.DataBatch(data=(_data,), label=(_label,))
model.forward(db, is_train=False)
net_out = model.get_outputs()
_embeddings = net_out[0].asnumpy()
if embeddings is None:
embeddings = np.zeros( (lfw_data.shape[0], _embeddings.shape[1]) )
embeddings[ba:bb,:] = _embeddings
ba = bb
embeddings_list.append(embeddings)
acc_list = []
embeddings = embeddings_list[0]
_, _, accuracy, val, val_std, far = lfw.evaluate(embeddings, issame_list, nrof_folds=10)
acc_list.append(np.mean(accuracy))
print('[%d]Accuracy: %1.3f+-%1.3f' % (nbatch, np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
embeddings = np.concatenate(embeddings_list, axis=1)
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
_, _, accuracy, val, val_std, far = lfw.evaluate(embeddings, issame_list, nrof_folds=10)
acc_list.append(np.mean(accuracy))
print('[%d]Accuracy-Flip: %1.3f+-%1.3f' % (nbatch, np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
pca = PCA(n_components=128)
embeddings = pca.fit_transform(embeddings)
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
_, _, accuracy, val, val_std, far = lfw.evaluate(embeddings, issame_list, nrof_folds=10)
acc_list.append(np.mean(accuracy))
print('[%d]Accuracy-PCA: %1.3f+-%1.3f' % (nbatch, np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
return max(*acc_list)
def test_badcase(data_set, mx_model, batch_size, name='', data_extra = None, label_shape = None):
print('testing verification badcase..')
data_list = data_set[0]
issame_list = data_set[1]
model = mx_model
embeddings_list = []
if data_extra is not None:
_data_extra = nd.array(data_extra)
time_consumed = 0.0
if label_shape is None:
_label = nd.ones( (batch_size,) )
else:
_label = nd.ones( label_shape )
for i in xrange( len(data_list) ):
data = data_list[i]
embeddings = None
ba = 0
while ba<data.shape[0]:
bb = min(ba+batch_size, data.shape[0])
count = bb-ba
_data = nd.slice_axis(data, axis=0, begin=bb-batch_size, end=bb)
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
if data_extra is None:
db = mx.io.DataBatch(data=(_data,), label=(_label,))
else:
db = mx.io.DataBatch(data=(_data,_data_extra), label=(_label,))
model.forward(db, is_train=False)
net_out = model.get_outputs()
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed+=diff.total_seconds()
if embeddings is None:
embeddings = np.zeros( (data.shape[0], _embeddings.shape[1]) )
embeddings[ba:bb,:] = _embeddings[(batch_size-count):,:]
ba = bb
embeddings_list.append(embeddings)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
thresholds = np.arange(0, 4, 0.01)
actual_issame = np.asarray(issame_list)
nrof_folds = 10
embeddings1 = embeddings[0::2]
embeddings2 = embeddings[1::2]
assert(embeddings1.shape[0] == embeddings2.shape[0])
assert(embeddings1.shape[1] == embeddings2.shape[1])
nrof_pairs = min(len(actual_issame), embeddings1.shape[0])
nrof_thresholds = len(thresholds)
k_fold = LFold(n_splits=nrof_folds, shuffle=False)
tprs = np.zeros((nrof_folds,nrof_thresholds))
fprs = np.zeros((nrof_folds,nrof_thresholds))
accuracy = np.zeros((nrof_folds))
indices = np.arange(nrof_pairs)
diff = np.subtract(embeddings1, embeddings2)
dist = np.sum(np.square(diff),1)
data = data_list[0]
pouts = []
nouts = []
for fold_idx, (train_set, test_set) in enumerate(k_fold.split(indices)):
# Find the best threshold for the fold
acc_train = np.zeros((nrof_thresholds))
#print(train_set)
#print(train_set.__class__)
for threshold_idx, threshold in enumerate(thresholds):
p2 = dist[train_set]
p3 = actual_issame[train_set]
_, _, acc_train[threshold_idx] = calculate_accuracy(threshold, p2, p3)
best_threshold_index = np.argmax(acc_train)
for threshold_idx, threshold in enumerate(thresholds):
tprs[fold_idx,threshold_idx], fprs[fold_idx,threshold_idx], _ = calculate_accuracy(threshold, dist[test_set], actual_issame[test_set])
_, _, accuracy[fold_idx] = calculate_accuracy(thresholds[best_threshold_index], dist[test_set], actual_issame[test_set])
best_threshold = thresholds[best_threshold_index]
for iid in test_set:
ida = iid*2
idb = ida+1
asame = actual_issame[iid]
_dist = dist[iid]
violate = _dist - best_threshold
if not asame:
violate *= -1.0
if violate>0.0:
imga = data[ida].asnumpy().transpose( (1,2,0) )[...,::-1] #to bgr
imgb = data[idb].asnumpy().transpose( (1,2,0) )[...,::-1]
#print(imga.shape, imgb.shape, violate, asame, _dist)
if asame:
pouts.append( (imga, imgb, _dist, best_threshold, ida) )
else:
nouts.append( (imga, imgb, _dist, best_threshold, ida) )
tpr = np.mean(tprs,0)
fpr = np.mean(fprs,0)
acc = np.mean(accuracy)
pouts = sorted(pouts, key = lambda x: x[2], reverse=True)
nouts = sorted(nouts, key = lambda x: x[2], reverse=False)
print(len(pouts), len(nouts))
print('acc', acc)
gap = 10
image_shape = (112,224,3)
out_dir = "./badcases"
if not os.path.exists(out_dir):
os.makedirs(out_dir)
if len(nouts)>0:
threshold = nouts[0][3]
else:
threshold = pouts[-1][3]
for item in [(pouts, 'positive(false_negative).png'), (nouts, 'negative(false_positive).png')]:
cols = 4
rows = 8000
outs = item[0]
if len(outs)==0:
continue
#if len(outs)==9:
# cols = 3
# rows = 3
_rows = int(math.ceil(len(outs)/cols))
rows = min(rows, _rows)
hack = {}
if name.startswith('cfp') and item[1].startswith('pos'):
hack = {0:'manual/238_13.jpg.jpg', 6:'manual/088_14.jpg.jpg', 10:'manual/470_14.jpg.jpg', 25:'manual/238_13.jpg.jpg', 28:'manual/143_11.jpg.jpg'}
filename = item[1]
if len(name)>0:
filename = name+"_"+filename
filename = os.path.join(out_dir, filename)
img = np.zeros( (image_shape[0]*rows+20, image_shape[1]*cols+(cols-1)*gap, 3), dtype=np.uint8 )
img[:,:,:] = 255
text_color = (0,0,153)
text_color = (255,178,102)
text_color = (153,255,51)
for outi, out in enumerate(outs):
row = outi//cols
col = outi%cols
if row==rows:
break
imga = out[0].copy()
imgb = out[1].copy()
if outi in hack:
idx = out[4]
print('noise idx',idx)
aa = hack[outi]
imgb = cv2.imread(aa)
#if aa==1:
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 1)
#elif aa==3:
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 0)
#else:
# for ii in xrange(2):
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 1)
dist = out[2]
_img = np.concatenate( (imga, imgb), axis=1 )
k = "%.3f"%dist
#print(k)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(_img,k,(80,image_shape[0]//2+7), font, 0.6, text_color, 2)
#_filename = filename+"_%d.png"%outi
#cv2.imwrite(_filename, _img)
img[row*image_shape[0]:(row+1)*image_shape[0], (col*image_shape[1]+gap*col):((col+1)*image_shape[1]+gap*col),:] = _img
#threshold = outs[0][3]
font = cv2.FONT_HERSHEY_SIMPLEX
k = "threshold: %.3f"%threshold
cv2.putText(img,k,(img.shape[1]//2-70,img.shape[0]-5), font, 0.6, text_color, 2)
cv2.imwrite(filename, img)
def trainNet(net, trainer, train_data, loss, train_metric, epoch, config,
logger, ctx):
if not logger:
assert False, 'require a logger'
train_data.reset() # reset and re-shuffle
if train_metric:
train_metric.reset()
trainer.set_learning_rate(config.TRAIN.lr *
pow(config.TRAIN.decay_rate, epoch))
w = config.TRAIN.w
batchsize = config.TRAIN.batchsize
UseMetric = config.TRAIN.UseMetric
seqLength = config.DATASET.seqLength
nJoints = config.NETWORK.nJoints
loss1, loss2, n1, n2 = [0] * len(ctx), [0] * len(ctx), 0.000001, 0.000001
RecordTime = {'load': 0, 'forward': 0, 'backward': 0, 'post': 0}
for batch_i, batch in enumerate(train_data):
beginT = time.time()
data_list = gluon.utils.split_and_load(batch.data[0],
ctx_list=ctx,
batch_axis=1)
label_list = gluon.utils.split_and_load(
batch.label[0], ctx_list=ctx,
batch_axis=1) # [[seqLength x 64 x 48] , 4]
RecordTime['load'] += time.time() - beginT
# forward
beginT = time.time()
Ls, Ls1, Ls2, output_list = [], [], [], []
with autograd.record():
for data, label, cx in zip(data_list, label_list, ctx):
initial_state = [
nd.zeros(shape=(batchsize, config.NETWORK.hidden_dim),
ctx=cx) for _ in range(2)
]
start_token = nd.ones(shape=(batchsize, 3 * nJoints), ctx=cx)
preds = net(data, initial_state, start_token)
output_list.append(preds) # pred=[5, 64x48]
L1, L2 = 0, 0
for pd, lb in zip(preds, label):
L1 = L1 + loss(pd, lb)
if seqLength > 1:
for i in range(1, seqLength):
deltaP = preds[i] - preds[i - 1]
deltaG = label[i] - label[i - 1]
L2 = L2 + loss(deltaP, deltaG)
Ls1.append(L1)
Ls2.append(L2) if seqLength > 1 else Ls2.append(nd.zeros(1))
Ls.append(L1 + w * L2)
RecordTime['forward'] += time.time() - beginT
# backward
beginT = time.time()
for L in Ls:
L.backward()
trainer.step(len(ctx) * batchsize)
RecordTime['backward'] += time.time() - beginT
beginT = time.time()
# number
n1 = n1 + len(ctx) * batchsize * seqLength
n2 = n2 + len(ctx) * batchsize * (seqLength - 1)
# loss
for i in range(len(loss1)):
loss1[i] += Ls1[i]
loss2[i] += Ls2[i]
# metric, save time
if UseMetric:
for pred_batch, label_batch in zip(
output_list, label_list): # for each timestamp
for t_pred, t_label in zip(pred_batch, label_batch):
train_metric.update(t_label, t_pred)
RecordTime['post'] += time.time() - beginT
totalT = nd.array([RecordTime[k] for k in RecordTime]).sum().asscalar()
for key in RecordTime:
print("%-s: %.1fs %.1f%% " %
(key, RecordTime[key], RecordTime[key] / totalT * 100),
end=" ")
print(" ")
nd.waitall()
loss1 = sum([item.sum().asscalar() for item in loss1])
loss2 = sum([item.sum().asscalar() for item in loss2])
TotalLoss = loss1 / n1 + w * loss2 / n2
MPJPE = train_metric.get()[-1].sum(
axis=0).asscalar() / 17 if UseMetric else 0
logger.info(
"TRAIN - Epoch:%2d LR:%.2e Loss1:%.2e Loss2(%2d):%.2e TotalLoss:%.2e MPJPE:%.1f"
% (epoch + 1, trainer.learning_rate, loss1 / n1, w, loss2 / n2,
TotalLoss, MPJPE))
if ((epoch + 1) % (config.end_epoch / 4) == 0
or epoch == 0): # save checkpoint
saveModel(net, logger, config, isCKP=True, epoch=epoch + 1)
if (epoch + 1 == config.end_epoch): # save final model
saveModel(net, logger, config, isCKP=False, epoch=epoch + 1)
#coding:utf-8
from mxnet import ndarray as nd
import numpy as np
z = nd.zeros((3, 4))
print('zeros:z = ', z)
o = nd.ones((3, 4))
print('o = ', o)
# 从数组直接创建
n = nd.array([[1, 2], [3, 4]])
print('n = ', n)
# 创建服从均值为0，标准差为1的正态分布随机数组
y = nd.random_normal(0, 1, shape=(3, 4))
print('random_normal:y = ', y)
# 相加
a = z + o
print('z + o = \n', a)
# 相乘
b = z * y
print('z * y =', b)
# 指数运算
e = nd.exp(y)
print('exp(y):e = ', e)
res = nd.dot(o, y.T)
print('dot = ', res)
def test(data_set, mx_model, batch_size, nfolds=10, data_extra = None, label_shape = None):
print('testing verification..')
data_list = data_set[0]
issame_list = data_set[1]
model = mx_model
embeddings_list = []
if data_extra is not None:
_data_extra = nd.array(data_extra)
time_consumed = 0.0
if label_shape is None:
_label = nd.ones( (batch_size,) )
else:
_label = nd.ones( label_shape )
for i in xrange( len(data_list) ):
data = data_list[i]
embeddings = None
ba = 0
while ba<data.shape[0]:
bb = min(ba+batch_size, data.shape[0])
count = bb-ba
_data = nd.slice_axis(data, axis=0, begin=bb-batch_size, end=bb)
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
if data_extra is None:
db = mx.io.DataBatch(data=(_data,), label=(_label,))
else:
db = mx.io.DataBatch(data=(_data,_data_extra), label=(_label,))
model.forward(db, is_train=False)
net_out = model.get_outputs()
#_arg, _aux = model.get_params()
#__arg = {}
#for k,v in _arg.iteritems():
# __arg[k] = v.as_in_context(_ctx)
#_arg = __arg
#_arg["data"] = _data.as_in_context(_ctx)
#_arg["softmax_label"] = _label.as_in_context(_ctx)
#for k,v in _arg.iteritems():
# print(k,v.context)
#exe = sym.bind(_ctx, _arg ,args_grad=None, grad_req="null", aux_states=_aux)
#exe.forward(is_train=False)
#net_out = exe.outputs
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed+=diff.total_seconds()
#print(_embeddings.shape)
if embeddings is None:
embeddings = np.zeros( (data.shape[0], _embeddings.shape[1]) )
embeddings[ba:bb,:] = _embeddings[(batch_size-count):,:]
ba = bb
embeddings_list.append(embeddings)
_xnorm = 0.0
_xnorm_cnt = 0
for embed in embeddings_list:
for i in xrange(embed.shape[0]):
_em = embed[i]
_norm=np.linalg.norm(_em)
#print(_em.shape, _norm)
_xnorm+=_norm
_xnorm_cnt+=1
_xnorm /= _xnorm_cnt
embeddings = embeddings_list[0].copy()
embeddings = sklearn.preprocessing.normalize(embeddings)
acc1 = 0.0
std1 = 0.0
#_, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=10)
#acc1, std1 = np.mean(accuracy), np.std(accuracy)
#print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
#embeddings = np.concatenate(embeddings_list, axis=1)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
print('infer time', time_consumed)
_, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=nfolds)
acc2, std2 = np.mean(accuracy), np.std(accuracy)
return acc1, std1, acc2, std2, _xnorm, embeddings_list
def main():
# Initialize problem parameters
batch_size = 1
prediction_length = 50
context_length = 5
axis = [-5, 5, -3, 3]
float_type = np.float64
num_samples = 3
ts_idx = 0
# Initialize test data to generate Gaussian Process from
lb = -5
ub = 5
dx = (ub - lb) / (prediction_length - 1)
x_test = nd.arange(lb, ub + dx, dx, dtype=float_type).reshape(-1, 1)
x_test = nd.tile(x_test, reps=(batch_size, 1, 1))
# Define the GP hyper parameters
amplitude = nd.ones((batch_size, 1, 1), dtype=float_type)
length_scale = math.sqrt(0.4) * nd.ones_like(amplitude)
sigma = math.sqrt(1e-5) * nd.ones_like(amplitude)
# Instantiate desired kernel object and compute kernel matrix
rbf_kernel = RBFKernel(amplitude, length_scale)
# Generate samples from 0 mean Gaussian process with RBF Kernel and plot it
gp = GaussianProcess(
sigma=sigma,
kernel=rbf_kernel,
prediction_length=prediction_length,
context_length=context_length,
num_samples=num_samples,
float_type=float_type,
sample_noise=False, # Returns sample without noise
)
mean = nd.zeros((batch_size, prediction_length), dtype=float_type)
covariance = rbf_kernel.kernel_matrix(x_test, x_test)
gp.plot(x_test=x_test, samples=gp.sample(mean, covariance), ts_idx=ts_idx)
# Generate training set on subset of interval using the sine function
x_train = nd.array([-4, -3, -2, -1, 1],
dtype=float_type).reshape(context_length, 1)
x_train = nd.tile(x_train, reps=(batch_size, 1, 1))
y_train = nd.sin(x_train.squeeze(axis=2))
# Predict exact GP using the GP predictive mean and covariance using the same fixed hyper-parameters
samples, predictive_mean, predictive_std = gp.exact_inference(
x_train, y_train, x_test)
assert (np.sum(np.isnan(
samples.asnumpy())) == 0), "NaNs in predictive samples!"
gp.plot(
x_train=x_train,
y_train=y_train,
x_test=x_test,
ts_idx=ts_idx,
mean=predictive_mean,
std=predictive_std,
samples=samples,
axis=axis,
)
def test(data_set,
mx_model,
batch_size,
nfolds=10,
data_extra=None,
label_shape=None):
"""
:param data_set: 测试数据
:param mx_model: 测试模型
:param batch_size: 测试批次大小
:param nfolds: K折检测的，分K份检测
:param data_extra:
:param label_shape: 标签数据的形状
:return:
"""
print('testing verification..')
data_list = data_set[0] # 两张图片的像素
issame_list = data_set[1] # 标签
model = mx_model #模型
embeddings_list = [] # 输出特征向量
# 如果存在额外数据
if data_extra is not None:
_data_extra = nd.array(data_extra)
# 记录测试消耗时间
time_consumed = 0.0
# 如果标签的形状没有设定
if label_shape is None:
_label = nd.ones((batch_size, ))
else:
_label = nd.ones(label_shape)
# 对每个测试集进行测试
for i in range(len(data_list)):
data = data_list[i]
embeddings = None
ba = 0 # 记录训练呢多少批次
while ba < data.shape[0]:
#print('data.shape[0]',data.shape[0])
# 防止超出界限，最后一次取最小的
bb = min(ba + batch_size, data.shape[0])
count = bb - ba
# 切割数据，得到一个batch_size的数据
_data = nd.slice_axis(data, axis=0, begin=bb - batch_size, end=bb)
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
# 如果有额外测试数据_data_extra，则进行添加
if data_extra is None:
db = mx.io.DataBatch(data=(_data, ), label=(_label, ))
else:
db = mx.io.DataBatch(data=(_data, _data_extra),
label=(_label, ))
# 传入数据，进行前向传播
model.forward(db, is_train=False)
# 获得输出
net_out = model.get_outputs()
# _arg, _aux = model.get_params()
# __arg = {}
# for k,v in _arg.iteritems():
# __arg[k] = v.as_in_context(_ctx)
# _arg = __arg
# _arg["data"] = _data.as_in_context(_ctx)
# _arg["softmax_label"] = _label.as_in_context(_ctx)
# for k,v in _arg.iteritems():
# print(k,v.context)
# exe = sym.bind(_ctx, _arg ,args_grad=None, grad_req="null", aux_states=_aux)
# exe.forward(is_train=False)
# net_out = exe.outputs
# 获得输出的向量
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed += diff.total_seconds()
# print(_embeddings.shape)
if embeddings is None:
embeddings = np.zeros((data.shape[0], _embeddings.shape[1]))
embeddings[ba:bb, :] = _embeddings[(batch_size - count):, :]
ba = bb
embeddings_list.append(embeddings)
_xnorm = 0.0
_xnorm_cnt = 0
# 对每个测试数据测试出来的结果进行评估
for embed in embeddings_list:
for i in range(embed.shape[0]):
_em = embed[i]
# 求向量的范数：https://blog.csdn.net/jack339083590/article/details/79171585
_norm = np.linalg.norm(_em)
# print(_em.shape, _norm)
_xnorm += _norm
_xnorm_cnt += 1
_xnorm /= _xnorm_cnt
#print(len(embeddings_list[0]))
embeddings = embeddings_list[0].copy()
embeddings = sklearn.preprocessing.normalize(embeddings)
acc1 = 0.0
std1 = 0.0
# _, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=10)
# acc1, std1 = np.mean(accuracy), np.std(accuracy)
# print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
# embeddings = np.concatenate(embeddings_list, axis=1)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
print('infer time', time_consumed)
# 对输出向量进行评估
#print(embeddings[0].shape,issame_list)
_, _, accuracy, val, val_std, far = evaluate(embeddings,
issame_list,
nrof_folds=nfolds)
# 对准确率进行平均化和标准化，标准化表示测试的稳定程度
acc2, std2 = np.mean(accuracy), np.std(accuracy)
return acc1, std1, acc2, std2, _xnorm, embeddings_list
netD.initialize(mx.init.Normal(.02), ctx=ctx)
trainerG = gluon.Trainer(netG.collect_params(), 'adam', {
'learning_rate': lr,
'beta1': beta1
})
trainerD = gluon.Trainer(netD.collect_params(), 'adam', {
'learning_rate': lr,
'beta1': beta1
})
#training loop
import time
import logging
real_label = nd.ones((batch_size, ), ctx=ctx)
fake_label = nd.zeros((batch_size, ), ctx=ctx)
#custom metric
def eveluate(pred, label):
pred = pred.flatten()
label = label.flatten()
return ((pred > .5) == label).mean()
metric = mx.metric.CustomMetric(eveluate)
logging.basicConfig(level=logging.DEBUG)
his_acc = []
his_errD = []
his_errG = []
def TestNet_Batch(net, test_data, loss, avg_metric, xyz_metric, mean3d, std3d,
config, logger, ctx):
if not logger:
assert False, 'require a logger'
if avg_metric and xyz_metric:
avg_metric.reset()
xyz_metric.reset()
test_data.reset()
batchsize = config.TEST.batchsize
seqLength = config.DATASET.seqLength
nJoints = config.NETWORK.nJoints
loss1, loss2, n1, n2 = [0] * len(ctx), [0] * len(ctx), 0.000001, 0.000001
for batch_i, batch in enumerate(test_data):
data_list = gluon.utils.split_and_load(batch.data[0],
ctx_list=ctx,
batch_axis=1)
label_list = gluon.utils.split_and_load(batch.label[0],
ctx_list=ctx,
batch_axis=1)
Ls1, Ls2, output_list = [], [], []
# forward
for data, label, cx in zip(data_list, label_list, ctx):
initial_state = [
nd.zeros(shape=(batchsize, config.NETWORK.hidden_dim), ctx=cx)
for _ in range(2)
]
start_token = nd.ones(shape=(batchsize, 3 * nJoints), ctx=cx)
preds = net(data, initial_state, start_token)
output_list.append(preds) # pred=[seqLength, 64x48]
L1, L2 = 0, 0
for pd, lb in zip(preds, label):
L1 = L1 + loss(pd, lb)
if seqLength > 1:
for i in range(1, seqLength):
deltaP = preds[i] - preds[i - 1]
deltaG = label[i] - label[i - 1]
L2 = L2 + loss(deltaP, deltaG)
Ls1.append(L1)
Ls2.append(L2) if seqLength > 1 else Ls2.append(nd.zeros(1))
# number
n1 = n1 + len(ctx) * batchsize * seqLength
n2 = n2 + len(ctx) * batchsize * (seqLength - 1)
# loss
for i in range(len(loss1)):
loss1[i] += Ls1[i]
loss2[i] += Ls2[i]
# metric, last frame
for label_batch, pred_batch in zip(label_list, output_list):
avg_metric.update(label_batch[-1], pred_batch[-1])
xyz_metric.update(label_batch[-1], pred_batch[-1])
# record
MPJPE = avg_metric.get()[-1].sum(axis=0) / 17
jntErr = avg_metric.get()[-1]
xyzErr = xyz_metric.get()[-1]
loss1 = sum([item.sum().asscalar() for item in loss1])
loss2 = sum([item.sum().asscalar() for item in loss2])
return [[n1, n2], [loss1, loss2], MPJPE, xyzErr, jntErr]
import mxnet as mx
import mxnet.ndarray as nd
x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
f = 2*x + 3*y
ex = f.bind(ctx=mx.cpu(),
args={'x': nd.array([2.]), 'y': nd.array([20.])},
args_grad={'x': nd.array([2.]), 'y': nd.array([20.])})
ex.forward(is_train=True)
ex.backward(nd.ones(1))
#print(ex.outputs)
print(ex.grad_arrays)
def DCGAN(epoch=100,
batch_size=128,
save_period=10,
load_period=100,
optimizer="adam",
beta1=0.5,
learning_rate=0.0002,
dataset="FashionMNIST",
ctx=mx.gpu(0)):
#data selection
if dataset == "CIFAR10":
train_data, test_data = CIFAR10(batch_size)
G_path = "weights/CIFAR10-G{}.params".format(load_period)
D_path = "weights/CIFAR10-D{}.params".format(load_period)
elif dataset == "FashionMNIST":
train_data, test_data = FashionMNIST(batch_size)
G_path = "weights/FashionMNIST-G{}.params".format(load_period)
D_path = "weights/FashionMNIST-D{}.params".format(load_period)
else:
return "The dataset does not exist."
#network
generator = Generator()
discriminator = Discriminator()
#for faster learning
generator.hybridize()
discriminator.hybridize()
if os.path.exists(D_path) and os.path.exists(G_path):
print("loading weights")
generator.load_params(filename=G_path, ctx=ctx) # weights load
discriminator.load_params(filename=D_path, ctx=ctx) # weights load
else:
print("initializing weights")
generator.collect_params().initialize(
mx.init.Normal(sigma=0.02), ctx=ctx) # weights initialization
discriminator.collect_params().initialize(
mx.init.Normal(sigma=0.02), ctx=ctx) # weights initialization
#net.initialize(mx.init.Normal(sigma=0.1),ctx=ctx) # weights initialization
#optimizer
G_trainer = gluon.Trainer(generator.collect_params(), optimizer, {
"learning_rate": learning_rate,
"beta1": beta1
})
D_trainer = gluon.Trainer(discriminator.collect_params(), optimizer, {
"learning_rate": learning_rate,
"beta1": beta1
})
'''The cross-entropy loss for binary classification. (alias: SigmoidBCELoss)
BCE loss is useful when training logistic regression.
.. math::
loss(o, t) = - 1/n \sum_i (t[i] * log(o[i]) + (1 - t[i]) * log(1 - o[i]))
Parameters
----------
from_sigmoid : bool, default is `False`
Whether the input is from the output of sigmoid. Set this to false will make
the loss calculate sigmoid and then BCE, which is more numerically stable through
log-sum-exp trick.
weight : float or None
Global scalar weight for loss.
batch_axis : int, default 0
The axis that represents mini-batch. '''
SBCE = gluon.loss.SigmoidBCELoss()
#learning
start_time = time.time()
#cost selection
real_label = nd.ones((batch_size, ), ctx=ctx)
fake_label = nd.zeros((batch_size, ), ctx=ctx)
for i in tqdm(range(1, epoch + 1, 1)):
for data, label in train_data:
print("\n<<D(X) , G(X)>")
data = data.as_in_context(ctx)
noise = Noise(batch_size=batch_size, ctx=ctx)
#1. Discriminator : (1)maximize Log(D(x)) + (2)Log(1-D(G(z)))
with autograd.record(train_mode=True):
output = discriminator(data)
print("real_D(X) : {}".format(
nd.mean(nd.sigmoid(output)).asscalar())),
#(1)
real = SBCE(output, real_label)
#(2)
fake_real = generator(noise)
output = discriminator(fake_real)
print("fake_real_D(X) : {}".format(
nd.mean(nd.sigmoid(output)).asscalar()))
fake_real = SBCE(output, fake_label)
# cost definition
discriminator_cost = real + fake_real
discriminator_cost.backward()
D_trainer.step(batch_size, ignore_stale_grad=True)
# 2. Generator : (3)maximize Log(D(G(z)))
with autograd.record(train_mode=True):
fake = generator(noise)
output = discriminator(fake)
print("fake_G(X) : {}".format(
nd.mean(nd.sigmoid(output)).asscalar()))
#(3)
Generator_cost = SBCE(output, real_label)
Generator_cost.backward()
G_trainer.step(batch_size, ignore_stale_grad=True)
print(" epoch : {}".format(i))
print("last batch Discriminator cost : {}".format(
nd.mean(discriminator_cost).asscalar()))
print("last batch Generator cost : {}".format(
nd.mean(Generator_cost).asscalar()))
if i % save_period == 0:
end_time = time.time()
print("-------------------------------------------------------")
print("{}_learning time : {}".format(epoch, end_time - start_time))
print("-------------------------------------------------------")
if not os.path.exists("weights"):
os.makedirs("weights")
print("saving weights")
if dataset == "FashionMNIST":
generator.save_params(
"weights/FashionMNIST-G{}.params".format(i))
discriminator.save_params(
"weights/FashionMNIST-D{}.params".format(i))
elif dataset == "CIFAR10":
generator.save_params("weights/CIFAR10-G{}.params".format(i))
discriminator.save_params(
"weights/CIFAR10-D{}.params".format(i))
#generate image
generate_image(generator, ctx, dataset)
return "optimization completed"
def train(pool_size, epochs, train_data, ctx, netEn, netDe, netD, netD2, trainerEn, trainerDe, trainerD, trainerD2, lambda1, batch_size, expname):
threewayloss =gluon.loss.SoftmaxCrossEntropyLoss()
GAN_loss = gluon.loss.SigmoidBinaryCrossEntropyLoss()
L1_loss = gluon.loss.L1Loss()
image_pool = imagePool.ImagePool(pool_size)
metric = mx.metric.CustomMetric(facc)
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
logging.basicConfig(level=logging.DEBUG)
for epoch in range(epochs):
tic = time.time()
btic = time.time()
train_data.reset()
iter = 0
for batch in train_data:
############################
# (1) Update D network: maximize log(D(x, y)) + log(1 - D(x, G(x, z)))
###########################
real_in = batch.data[0].as_in_context(ctx)
real_out = batch.data[1].as_in_context(ctx)
tempout = netEn(real_in)
fake_out = netDe(tempout)
fake_concat = fake_out
#fake_concat = image_pool.query(fake_out)
#fake_concat = image_pool.query(nd.concat(real_in, fake_out, dim=1))
with autograd.record():
# Train with fake image
# Use image pooling to utilize history images
output = netD(fake_concat)
fake_label = nd.zeros(output.shape, ctx=ctx)
errD_fake = GAN_loss(output, fake_label)
metric.update([fake_label, ], [output, ])
output2 = netD2(fake_concat)
errD2_fake = GAN_loss(output2, fake_label)
# Train with real image
real_concat = real_out
output = netD(real_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errD_real = GAN_loss(output, real_label)
metric.update([real_label, ], [output, ])
#train with abnormal image
abinput = nd.random.uniform(-1,1,tempout.shape,ctx=ctx)
aboutput =netD2( netDe(abinput))
#print(aboutput.shape)
#print(output.shape)
ab_label = nd.ones(aboutput.shape, ctx=ctx)
errD2_ab = GAN_loss(aboutput, ab_label)
errD2 = ( errD2_fake + errD2_ab) * 0.5
errD = errD2+0.5*(errD_real+errD_fake)
errD.backward()
trainerD.step(batch.data[0].shape[0])
trainerD2.step(batch.data[0].shape[0])
############################
# (2) Update G network: maximize log(D(x, G(x, z))) - lambda1 * L1(y, G(x, z))
###########################
with autograd.record():
fake_out = netDe(netEn(real_in))
fake_concat = fake_out
output = netD(fake_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errG = GAN_loss(output, real_label) + L1_loss(real_out, fake_out) * lambda1
errR = L1_loss(real_out, fake_out)
errG.backward()
trainerEn.step(batch.data[0].shape[0])
trainerDe.step(batch.data[0].shape[0])
# Print log infomation every ten batches
if iter % 10 == 0:
name, acc = metric.get()
logging.info('speed: {} samples/s'.format(batch_size / (time.time() - btic)))
logging.info(
'discriminator loss = %f, generator loss = %f, latent error = %f, binary training acc = %f, reconstruction error= %f at iter %d epoch %d'
% (nd.mean(errD).asscalar(),
nd.mean(errG).asscalar(), nd.mean(errD2).asscalar() , acc,nd.mean(errR).asscalar() ,iter, epoch))
iter = iter + 1
btic = time.time()
name, acc = metric.get()
metric.reset()
logging.info('\nbinary training acc at epoch %d: %s=%f' % (epoch, name, acc))
logging.info('time: %f' % (time.time() - tic))
if epoch%10 ==0:
filename = "checkpoints/"+expname+"_"+str(epoch)+"_D.params"
netD.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_D2.params"
netD2.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_En.params"
netEn.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_De.params"
netDe.save_params(filename)
# Visualize one generated image for each epoch
fake_img = nd.concat(real_in[0],real_out[0], fake_out[0], dim=1)
visual.visualize(fake_img)
plt.savefig('outputs/'+expname+'_'+str(epoch)+'.png')
def test(lfw_set, mx_model, batch_size):
print('testing lfw..')
lfw_data_list = lfw_set[0]
issame_list = lfw_set[1]
model = mx_model
embeddings_list = []
for i in xrange(len(lfw_data_list)):
lfw_data = lfw_data_list[i]
embeddings = None
ba = 0
while ba < lfw_data.shape[0]:
bb = min(ba + batch_size, lfw_data.shape[0])
_data = nd.slice_axis(lfw_data, axis=0, begin=ba, end=bb)
_label = nd.ones((bb - ba, ))
#print(_data.shape, _label.shape)
db = mx.io.DataBatch(data=(_data, ), label=(_label, ))
model.forward(db, is_train=False)
net_out = model.get_outputs()
#_arg, _aux = model.get_params()
#__arg = {}
#for k,v in _arg.iteritems():
# __arg[k] = v.as_in_context(_ctx)
#_arg = __arg
#_arg["data"] = _data.as_in_context(_ctx)
#_arg["softmax_label"] = _label.as_in_context(_ctx)
#for k,v in _arg.iteritems():
# print(k,v.context)
#exe = sym.bind(_ctx, _arg ,args_grad=None, grad_req="null", aux_states=_aux)
#exe.forward(is_train=False)
#net_out = exe.outputs
_embeddings = net_out[0].asnumpy()
#print(_embeddings.shape)
if embeddings is None:
embeddings = np.zeros(
(lfw_data.shape[0], _embeddings.shape[1]))
embeddings[ba:bb, :] = _embeddings
ba = bb
embeddings_list.append(embeddings)
_xnorm = 0.0
_xnorm_cnt = 0
for embed in embeddings_list:
for i in xrange(embed.shape[0]):
_em = embed[i]
_norm = np.linalg.norm(_em)
#print(_em.shape, _norm)
_xnorm += _norm
_xnorm_cnt += 1
_xnorm /= _xnorm_cnt
embeddings = embeddings_list[0].copy()
embeddings = sklearn.preprocessing.normalize(embeddings)
_, _, accuracy, val, val_std, far = evaluate(embeddings,
issame_list,
nrof_folds=10)
acc1, std1 = np.mean(accuracy), np.std(accuracy)
#print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
#embeddings = np.concatenate(embeddings_list, axis=1)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
_, _, accuracy, val, val_std, far = evaluate(embeddings,
issame_list,
nrof_folds=10)
acc2, std2 = np.mean(accuracy), np.std(accuracy)
return acc1, std1, acc2, std2, _xnorm, embeddings_list
def ones(shape, dtype, ctx):
return nd.ones(shape, dtype=dtype, ctx=ctx)
def forward(self, inputs, loss=None, training=True, commtype='maxpooling'):
assert len(inputs) == self.slots + 1
if self.non_local_mode:
return self.forward_non_local(inputs, loss, training)
if self.message_embedding:
return self.forward_message_embedding(inputs, loss, training)
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.forward(inputs[i], training=training))
results.append(self.global_trans.forward(inputs[-1], training=training))
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], training=training) * 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], training=training) * 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], training=training) * comm_rate[j][-1]
norm = norm + comm_rate[j][-1]
if nd.sum(norm) > 1e-5:
results[-1] = results[-1] + tmp / norm
else:
if commtype == 'average':
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], training=training)
tmp = tmp + self.global2local_comm(inputs[-1], training=training)
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], training=training)
results[-1] = results[-1] + (tmp / float(self.slots))
elif commtype == 'maxpooling':
for i in range(self.slots):
tmp = []
for j in range(self.slots):
if j != i:
tmp.append(self.local2local_share_comm.forward(inputs[j], training=training))
tmp.append(self.global2local_comm.forward(inputs[-1], training=training))
for k in range(len(tmp)):
tmp[k] = tmp[k].reshape((tmp[k].shape[0], 1, tmp[k].shape[1]))
tmp = nd.concat(*tmp, dim=1)
maxcomm = nd.max(tmp, axis=1)
results[i] = results[i] + maxcomm
tmp = []
for i in range(self.slots):
tmp.append(self.local2global_comm.forward(inputs[i], training=training))
for k in range(len(tmp)):
tmp[k] = tmp[k].reshape((tmp[k].shape[0], 1, tmp[k].shape[1]))
tmp = nd.concat(*tmp, dim=1)
maxcomm = nd.max(tmp, axis=1)
results[-1] = results[-1] + maxcomm
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], training=training) + inputs[i]
results[-1] = self.yz_weight_global(results[-1], training=training) + inputs[-1]
return results
def nd_ones(*args, **kwargs):
return nd.ones(*args, dtype="float64", **kwargs)
def test(lfw_set, mx_model, batch_size):
print('testing lfw..')
lfw_data_list = lfw_set[0]
issame_list = lfw_set[1]
model = mx_model
embeddings_list = []
for i in xrange( len(lfw_data_list) ):
lfw_data = lfw_data_list[i]
embeddings = None
ba = 0
while ba<lfw_data.shape[0]:
bb = min(ba+batch_size, lfw_data.shape[0])
_data = nd.slice_axis(lfw_data, axis=0, begin=ba, end=bb)
_label = nd.ones( (bb-ba,) )
#print(_data.shape, _label.shape)
db = mx.io.DataBatch(data=(_data,), label=(_label,))
model.forward(db, is_train=False)
net_out = model.get_outputs()
#_arg, _aux = model.get_params()
#__arg = {}
#for k,v in _arg.iteritems():
# __arg[k] = v.as_in_context(_ctx)
#_arg = __arg
#_arg["data"] = _data.as_in_context(_ctx)
#_arg["softmax_label"] = _label.as_in_context(_ctx)
#for k,v in _arg.iteritems():
# print(k,v.context)
#exe = sym.bind(_ctx, _arg ,args_grad=None, grad_req="null", aux_states=_aux)
#exe.forward(is_train=False)
#net_out = exe.outputs
_embeddings = net_out[0].asnumpy()
#print(_embeddings.shape)
if embeddings is None:
embeddings = np.zeros( (lfw_data.shape[0], _embeddings.shape[1]) )
embeddings[ba:bb,:] = _embeddings
ba = bb
embeddings_list.append(embeddings)
_xnorm = 0.0
_xnorm_cnt = 0
for embed in embeddings_list:
for i in xrange(embed.shape[0]):
_em = embed[i]
_norm=np.linalg.norm(_em)
#print(_em.shape, _norm)
_xnorm+=_norm
_xnorm_cnt+=1
_xnorm /= _xnorm_cnt
embeddings = embeddings_list[0].copy()
embeddings = sklearn.preprocessing.normalize(embeddings)
_, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=10)
acc1, std1 = np.mean(accuracy), np.std(accuracy)
#print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
#embeddings = np.concatenate(embeddings_list, axis=1)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
_, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=10)
acc2, std2 = np.mean(accuracy), np.std(accuracy)
return acc1, std1, acc2, std2, _xnorm, embeddings_list
def validNet(net, valid_data, loss, eval_metric, epoch, config, logger, ctx):
if not logger:
assert False, 'require a logger'
valid_data.reset()
if eval_metric:
eval_metric.reset()
w = config.TRAIN.w
batchsize = config.TRAIN.batchsize
UseMetric = config.TRAIN.UseMetric
seqLength = config.DATASET.seqLength
nJoints = config.NETWORK.nJoints
loss1, loss2, n1, n2 = [0] * len(ctx), [0] * len(ctx), 0.000001, 0.000001
for batch_i, batch in enumerate(valid_data):
data_list = gluon.utils.split_and_load(batch.data[0],
ctx_list=ctx,
batch_axis=1)
label_list = gluon.utils.split_and_load(batch.label[0],
ctx_list=ctx,
batch_axis=1)
Ls1, Ls2, output_list = [], [], []
# forward
for data, label, cx in zip(data_list, label_list, ctx):
initial_state = [
nd.zeros(shape=(batchsize, config.NETWORK.hidden_dim), ctx=cx)
for _ in range(2)
]
start_token = nd.ones(shape=(batchsize, 3 * nJoints), ctx=cx)
preds = net(data, initial_state, start_token)
output_list.append(preds) # pred=[seqLength, 64x48]
L1, L2 = 0, 0
for pd, lb in zip(preds, label):
L1 = L1 + loss(pd, lb)
if seqLength > 1:
for i in range(1, seqLength):
deltaP = preds[i] - preds[i - 1]
deltaG = label[i] - label[i - 1]
L2 = L2 + loss(deltaP, deltaG)
Ls1.append(L1)
Ls2.append(L2) if seqLength > 1 else Ls2.append(nd.zeros(1))
# number
n1 = n1 + len(ctx) * batchsize * seqLength
n2 = n2 + len(ctx) * batchsize * (seqLength - 1)
# loss
for i in range(len(loss1)):
loss1[i] += Ls1[i]
loss2[i] += Ls2[i]
# metric, save time
if UseMetric:
for pred_batch, label_batch in zip(
output_list, label_list): # for each timestamp
for t_pred, t_label in zip(pred_batch, label_batch):
eval_metric.update(t_label, t_pred)
nd.waitall()
loss1 = sum([item.sum().asscalar() for item in loss1])
loss2 = sum([item.sum().asscalar() for item in loss2])
validloss = loss1 / n1 + w * loss2 / n2
MPJPE = eval_metric.get()[-1].sum(axis=0) / 17 if UseMetric else 0
logger.info(
"VALID - Epoch:%2d Loss1:%.2e Loss2(%2d):%.2e TotalLoss:%.2e MPJPE:%.1f"
% (epoch + 1, loss1 / n1, w, loss2 / n2, validloss, MPJPE))
def train():
"""training"""
image_pool = ImagePool(pool_size)
metric = mx.metric.CustomMetric(facc)
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
logging.basicConfig(level=logging.DEBUG)
# define a summary writer that logs data and flushes to the file every 5 seconds
sw = SummaryWriter(logdir='%s' % dir_out_sw, flush_secs=5, verbose=False)
global_step = 0
for epoch in range(epochs):
if epoch == 0:
netG.hybridize()
netD.hybridize()
# sw.add_graph(netG)
# sw.add_graph(netD)
tic = time.time()
btic = time.time()
train_data.reset()
val_data.reset()
iter = 0
for local_step, batch in enumerate(train_data):
############################
# (1) Update D network: maximize log(D(x, y)) + log(1 - D(x, G(x, z)))
###########################
tmp = mx.nd.concat(batch.data[0],
batch.data[1],
batch.data[2],
dim=1)
tmp = augmenter(tmp,
patch_size=128,
offset=offset,
aug_type=1,
aug_methods=aug_methods,
random_crop=False)
real_in = tmp[:, :1].as_in_context(ctx)
real_out = tmp[:, 1:2].as_in_context(ctx)
m = tmp[:, 2:3].as_in_context(ctx) # mask
fake_out = netG(real_in) * m
# loss weight based on mask, applied on L1 loss
if no_loss_weights:
loss_weight = m
else:
loss_weight = m.asnumpy()
loss_weight[loss_weight == 0] = .1
loss_weight = mx.nd.array(loss_weight, ctx=m.context)
fake_concat = image_pool.query(nd.concat(real_in, fake_out, dim=1))
with autograd.record():
# Train with fake image
# Use image pooling to utilize history images
output = netD(fake_concat)
fake_label = nd.zeros(output.shape, ctx=ctx)
errD_fake = GAN_loss(output, fake_label)
metric.update([
fake_label,
], [
output,
])
# Train with real image
real_concat = nd.concat(real_in, real_out, dim=1)
output = netD(real_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errD_real = GAN_loss(output, real_label)
errD = (errD_real + errD_fake) * 0.5
errD.backward()
metric.update([
real_label,
], [
output,
])
trainerD.step(batch.data[0].shape[0])
############################
# (2) Update G network: maximize log(D(x, G(x, z))) - lambda1 * L1(y, G(x, z))
###########################
with autograd.record():
fake_out = netG(real_in)
fake_concat = nd.concat(real_in, fake_out, dim=1)
output = netD(fake_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errG = GAN_loss(output, real_label) + loss_2nd(
real_out, fake_out, loss_weight) * lambda1
errG.backward()
trainerG.step(batch.data[0].shape[0])
sw.add_scalar(tag='loss',
value=('d_loss', errD.mean().asscalar()),
global_step=global_step)
sw.add_scalar(tag='loss',
value=('g_loss', errG.mean().asscalar()),
global_step=global_step)
global_step += 1
if epoch + local_step == 0:
sw.add_graph((netG))
img_in_list, img_out_list, m_val = val_data.next().data
m_val = m_val.as_in_context(ctx)
sw.add_image('first_minibatch_train_real', norm3(real_out))
sw.add_image('first_minibatch_val_real',
norm3(img_out_list.as_in_context(ctx)))
netG.export('%snetG' % dir_out_checkpoints)
if local_step == 0:
# Log the first batch of images of each epoch (training)
sw.add_image('first_minibatch_train_fake',
norm3(fake_out * m) * m, epoch)
sw.add_image(
'first_minibatch_val_fake',
norm3(netG(img_in_list.as_in_context(ctx)) * m_val) *
m_val, epoch)
# norm3(netG(img_in_list.as_in_context(ctx)) * m_val.as_in_context(ctx)), epoch)
if (iter + 1) % 10 == 0:
name, acc = metric.get()
logging.info('speed: {} samples/s'.format(
batch_size / (time.time() - btic)))
logging.info(
'discriminator loss = %f, generator loss = %f, binary training acc = %f at iter %d epoch %d'
% (nd.mean(errD).asscalar(), nd.mean(errG).asscalar(), acc,
iter, epoch))
iter += 1
btic = time.time()
sw.add_scalar(tag='binary_training_acc',
value=('acc', acc),
global_step=epoch)
name, acc = metric.get()
metric.reset()
fake_val = netG(val_data.data[0][1].as_in_context(ctx))
loss_val = loss_2nd(val_data.data[1][1].as_in_context(ctx), fake_val,
val_data.data[2][1].as_in_context(ctx)) * lambda1
sw.add_scalar(tag='loss_val',
value=('g_loss', loss_val.mean().asscalar()),
global_step=epoch)
if (epoch % check_point_interval == 0) | (epoch == epochs - 1):
netD.save_params('%snetD-%04d' % (dir_out_checkpoints, epoch))
netG.save_params('%snetG-%04d' % (dir_out_checkpoints, epoch))
logging.info('\nbinary training acc at epoch %d: %s=%f' %
(epoch, name, acc))
logging.info('time: %f' % (time.time() - tic))
sw.export_scalars('scalar_dict.json')
sw.close()
def nd_ones(*args, **kwargs):
""" MRT wrapper method for mxnet.NDArray.ones.
"""
return nd.ones(*args, dtype="float64", **kwargs)
import cv2
from mxnet import ndarray as nd
from mxnet import autograd
from mxnet import gluon
import mxnet as mx
num_train = 20
num_test = 100
num_inputs = 200
true_w = nd.ones((num_inputs, 1)) * 0.01
true_b = 0.05
X = nd.random.normal(shape=(num_train + num_test, num_inputs))
y = nd.dot(X, true_w) + true_b
y += .01 * nd.random.normal(shape=y.shape)
X_train, X_test = X[:num_train, :], X[num_train:, :]
y_train, y_test = y[:num_train], y[num_train:]
import random
batch_size = 1
def data_iter(num_examples):
idx = list(range(num_examples))
random.shuffle(idx)
for i in range(0, num_examples, batch_size):
j = nd.array(idx[i:min(i + batch_size, num_examples)])
yield X.take(j), y.take(j)
def train(opt):
sw = SummaryWriter(logdir='./logs', flush_secs=5)
decay_every = int(opt.n_epoch / 2)
if opt.experiment is None:
opt.experiment = 'samples'
os.system('mkdir {}'.format(opt.experiment))
if opt.gpu_ids == '-1':
context = [mx.cpu()]
else:
#context = mx.gpu(7)
context = [mx.gpu(int(i)) for i in opt.gpu_ids.split(',') if i.strip()]
print("context: {}".format(context))
features = load_vgg_model_features(ctx_list=context, last_layer=28)
##### Prapare data for training or validation #####
dataset = DataSet(
opt.dataroot, RandomCrop(opt.fineSize),
transforms.Resize(int(opt.fineSize / 4), interpolation=3),
transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
dataloader = DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers),
last_batch='rollover')
##### Build Network #####
netG = SRGenerator()
netG.initialize(ctx=context[0])
netD = SRDiscriminator()
netD.initialize(ctx=context[0])
# Enforce non-deferred initialization by one forward pass computation
dummy_in = nd.random.uniform(
0,
1, (1, 3, int(opt.fineSize / 4), int(opt.fineSize / 4)),
ctx=context[0])
netD(netG(dummy_in))
# Our own re-setting on parameters
weights_init(netG.collect_params())
netG.collect_params().reset_ctx(context)
weights_init(netD.collect_params())
netD.collect_params().reset_ctx(context)
optimizer_G = gluon.Trainer(params=netG.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': opt.lr_init,
'beta1': opt.beta1
},
kvstore='local')
optimizer_D = gluon.Trainer(params=netD.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': opt.lr_init,
'beta1': opt.beta1
},
kvstore='local')
##### Stage 1/2 of Training Process #####
# Pre-train Generator G to avoid undesired local optima when training SRGAN.
print("Start pre-train Generator ...")
param_file = os.path.join(opt.experiment, 'netG_init_epoch.param')
if os.path.exists(param_file):
print(
"Load existed parameter file pre-trained: {}, skip the pre-train process."
.format(param_file))
netG.load_parameters(param_file, ctx=context)
else:
print("No existed parameter file, keep going to pre-train.")
for epoch in range(opt.n_epoch_init):
start = time.time()
batch = 0
for hr_img_iter, lr_img_iter in dataloader:
#hr_img = hr_img.as_in_context(context)
#lr_img = lr_img.as_in_context(context)
hr_imgs = gluon.utils.split_and_load(hr_img_iter,
ctx_list=context)
lr_imgs = gluon.utils.split_and_load(lr_img_iter,
ctx_list=context)
with autograd.record():
ls = [
mse_loss(hr_img, netG(lr_img))
for hr_img, lr_img in zip(hr_imgs, lr_imgs)
]
for l in ls:
l.backward()
# with autograd.record():
# hr_img_pred = netG(mx.nd.array(lr_img))
# loss = mse_loss(mx.nd.array(hr_img), hr_img_predit)
# autograd.backward(loss)
optimizer_G.step(opt.batchSize)
print("Epoch %d: Batch %d: mse: %.8f" %
(epoch, batch, ls[-1].mean().asscalar()))
batch += opt.batchSize
nd.waitall()
train_time = time.time() - start
print("Epoch %d: mse: %.8f trainning time:%.1f sec" %
(epoch, ls[-1].mean().asscalar(), train_time))
if epoch % 20 == 0:
netG.save_parameters('{0}/netG_init_epoch_{1}.param'.format(
opt.experiment, epoch))
if epoch == opt.n_epoch_init - 1:
netG.save_parameters('{0}/netG_init_epoch.param'.format(
opt.experiment))
print("Pre-train Generator finished ...")
##### Stage 2/2 of Training Process #####
# Jointly optimize G and D, namely train SRGAN.
print("Start to train SRGAN ...")
mean_mask = nd.zeros((opt.batchSize, 3, opt.fineSize, opt.fineSize),
ctx=context[0])
mean_mask[:, 0, :, :] = 0.485
mean_mask[:, 1, :, :] = 0.456
mean_mask[:, 2, :, :] = 0.406
std_mask = nd.zeros((opt.batchSize, 3, opt.fineSize, opt.fineSize),
ctx=context[0])
std_mask[:, 0, :, :] = 0.229
std_mask[:, 1, :, :] = 0.224
std_mask[:, 2, :, :] = 0.225
real_label = nd.ones((opt.batchSize, ), ctx=context[0])
fake_label = nd.zeros((opt.batchSize, ), ctx=context[0])
mean_masks = mx.gluon.utils.split_and_load(mean_mask, ctx_list=context)
std_masks = mx.gluon.utils.split_and_load(std_mask, ctx_list=context)
real_labels = mx.gluon.utils.split_and_load(real_label, ctx_list=context)
fake_labels = mx.gluon.utils.split_and_load(fake_label, ctx_list=context)
loss_d = gluon.loss.SigmoidBinaryCrossEntropyLoss()
losses_log = loss_dict()
for epoch in range(0, opt.n_epoch):
start = time.time()
batch = 0
train_errD = 0
train_errG = 0
for hr_img_iter, lr_img_iter in dataloader:
losses_log.reset()
hr_imgs = gluon.utils.split_and_load(hr_img_iter, ctx_list=context)
lr_imgs = gluon.utils.split_and_load(lr_img_iter, ctx_list=context)
hr_fake_imgs = []
# Step1. Optimize D
# Step2. Optimize G
batch_errD = []
batch_errG = []
print("Optimize D in a Batch...")
with autograd.record():
for hr_img, lr_img, mean_mask, std_mask, real_label, fake_label in zip(
hr_imgs, lr_imgs, mean_masks, std_masks, real_labels,
fake_labels):
# errD computation
output = netD(hr_img).reshape((-1, 1))
errD_real = loss_d(output, real_label)
hr_img_fake = netG(lr_img)
hr_fake_imgs.append(hr_img_fake)
output = netD(hr_img_fake.detach()).reshape((-1, 1))
errD_fake = loss_d(output, fake_label)
errD = errD_real + errD_fake
batch_errD.append(errD)
losses_log.add(lr_img=lr_img,
hr_img=hr_img,
hr_img_fake=hr_img_fake)
# run backward on batch errD and update parameters
autograd.backward(batch_errD)
optimizer_D.step(opt.batchSize)
print("Optimize G in a Batch...")
with autograd.record():
for hr_img, lr_img, hr_img_fake, mean_mask, std_mask, real_label, fake_label in zip(
hr_imgs, lr_imgs, hr_fake_imgs, mean_masks, std_masks,
real_labels, fake_labels):
# errG computation
errM = mse_loss(hr_img_fake, hr_img)
input_fake = ((hr_img_fake + 1) / 2 - mean_mask) / std_mask
fake_emb = vgg_feature(input_fake, features)
input_real = ((hr_img + 1) / 2 - mean_mask) / std_mask
real_emb = vgg_feature(input_real, features)
errV = 6e-3 * mse_loss(fake_emb, real_emb)
output = netD(hr_img_fake).reshape((-1, 1))
errA = 1e-3 * loss_d(output, real_label)
errG = errM + errV + errA
batch_errG.append(errG)
# run backward on batch errG and update parameters
autograd.backward(batch_errG)
# for errG in batch_errG:
# errG.backward()
# losses_log.add(errG=errG, errM=errM, errV=errV, errA=errA)
optimizer_G.step(opt.batchSize)
# sum losses over all devices
train_errD += sum([errD.sum().asscalar() for errD in batch_errD])
train_errG += sum([errG.sum().asscalar() for errG in batch_errG])
print(
"Epoch:%d, Batch:%d ----- D-Loss = %.3f, G-Loss = %.3f (Time %.1f sec)"
% (epoch, batch * opt.batchSize, train_errD, train_errG,
time.time() - start))
batch += 1
plot_loss(sw, losses_log,
epoch * len(dataloader) + batch, epoch, batch)
if epoch != 0 and (epoch % decay_every == 0):
optimizer_G.set_learning_rate(optimizer_G.learning_rate *
opt.lr_decay)
optimizer_D.set_learning_rate(optimizer_D.learning_rate *
opt.lr_decay)
if (epoch != 0) and (epoch % 10 == 0):
plot_img(sw, losses_log)
netG.save_parameters('{0}/netG_epoch_{1}.param'.format(
opt.experiment, epoch))
netD.save_parameters('{0}/netD_epoch_{1}.param'.format(
opt.experiment, epoch))
print("Train SRGAN finished ...")
#欠拟合：机器学习模型无法得到较低训练误差。
#过拟合：机器学习模型的训练误差远小于其在测试数据集上的误差。
#高维线性回归
# y = 0.05 + sum(0.01*xi) + noise # 这里噪音服从均值0和标准差为0.01的正态分布。
from mxnet import ndarray as nd
from mxnet import autograd
from mxnet import gluon
import mxnet as mx
num_train = 20#训练集大小
num_test = 100#测试集大小
num_inputs = 200#输入神经元个数 xi的个数
#真实模型参数
true_w = nd.ones((num_inputs, 1)) * 0.01# 权重
true_b = 0.05#偏置
#生成 数据集
X = nd.random.normal(shape=(num_train + num_test, num_inputs))#输入
y = nd.dot(X, true_w) + true_b # y = 0.05 + sum(0.01*xi)
y += .01 * nd.random.normal(shape=y.shape)#噪声 y = 0.05 + sum(0.01*xi) + noise
X_train, X_test = X[:num_train, :], X[num_train:, :]# 0~19 行 20~99行
y_train, y_test = y[:num_train], y[num_train:]
# 不断读取数据块
import random
batch_size = 1
def data_iter(num_examples):
idx = list(range(num_examples))
def train(pool_size, epochs, train_data, val_data, ctx, netEn, netDe, netD, netD2, trainerEn, trainerDe, trainerD, trainerD2, lambda1, batch_size, expname, append=True, useAE = False):
tp_file = open(expname + "_trainloss.txt", "w")
tp_file.close()
text_file = open(expname + "_validtest.txt", "w")
text_file.close()
#netGT, netDT, _, _ = set_test_network(opt.depth, ctx, opt.lr, opt.beta1,opt.ndf, opt.ngf, opt.append)
GAN_loss = gluon.loss.SigmoidBinaryCrossEntropyLoss()
L1_loss = gluon.loss.L2Loss()
image_pool = imagePool.ImagePool(pool_size)
metric = mx.metric.CustomMetric(facc)
metric2 = mx.metric.CustomMetric(facc)
metricMSE = mx.metric.MSE()
loss_rec_G = []
loss_rec_D = []
loss_rec_R = []
acc_rec = []
acc2_rec = []
loss_rec_D2 = []
loss_rec_G2 = []
lr = 0.002
#mu = nd.random_normal(loc=0, scale=1, shape=(batch_size/2,64,1,1), ctx=ctx)
mu = nd.random.uniform(low= -1, high=1, shape=(batch_size/2,64,1,1),ctx=ctx)
#mu = nd.zeros((batch_size/2,64,1,1),ctx=ctx)
sigma = nd.ones((64,1,1),ctx=ctx)
mu.attach_grad()
sigma.attach_grad()
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
logging.basicConfig(level=logging.DEBUG)
for epoch in range(epochs):
tic = time.time()
btic = time.time()
train_data.reset()
iter = 0
#print('learning rate : '+str(trainerD.learning_rate ))
for batch in train_data:
############################
# (1) Update D network: maximize log(D(x, y)) + log(1 - D(x, G(x, z)))
###########################
real_in = batch.data[0].as_in_context(ctx)
real_out = batch.data[1].as_in_context(ctx)
fake_latent= netEn(real_in)
#real_latent = nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx)
#real_latent = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx))
real_latent = nd.random.uniform( low=-1, high=1, shape=fake_latent.shape, ctx=ctx)
fake_out = netDe(fake_latent)
eps2 = (fake_latent+nd.shuffle(fake_latent))*0.5
fake_concat = nd.concat(real_in, fake_out, dim=1) if append else fake_out
with autograd.record():
# Train with fake image
# Use image pooling to utilize history imagesi
output = netD(fake_concat)
output2 = netD2(fake_latent)
fake_label = nd.zeros(output.shape, ctx=ctx)
fake_latent_label = nd.zeros(output2.shape, ctx=ctx)
noiseshape = (fake_latent.shape[0]/2,fake_latent.shape[1],fake_latent.shape[2],fake_latent.shape[3])
#eps2 = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx))
#eps2 = nd.random_normal(loc=0, scale=sigma.asscalar(), shape=fake_latent.shape, ctx=ctx) #
#eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx)
#eps2 = (fake_latent+nd.shuffle(fake_latent))*0.5
rec_output = netD(netDe(eps2))
errD_fake = GAN_loss(rec_output, fake_label)
errD_fake2 = GAN_loss(output, fake_label)
errD2_fake = GAN_loss(output2, fake_latent_label)
metric.update([fake_label, ], [output, ])
metric2.update([fake_latent_label, ], [output2, ])
real_concat = nd.concat(real_in, real_out, dim=1) if append else real_out
output = netD(real_concat)
output2 = netD2(real_latent)
real_label = nd.ones(output.shape, ctx=ctx)
real_latent_label = nd.ones(output2.shape, ctx=ctx)
errD_real = GAN_loss(output, real_label)
errD2_real = GAN_loss(output2, real_latent_label)
#errD = (errD_real + 0.5*(errD_fake+errD_fake2)) * 0.5
errD = (errD_real + errD_fake) * 0.5
errD2 = (errD2_real + errD2_fake) * 0.5
totalerrD = errD+errD2
totalerrD.backward()
#errD2.backward()
metric.update([real_label, ], [output, ])
metric2.update([real_latent_label, ], [output2, ])
trainerD.step(batch.data[0].shape[0])
trainerD2.step(batch.data[0].shape[0])
############################
# (2) Update G network: maximize log(D(x, G(x, z))) - lambda1 * L1(y, G(x, z))
###########################
with autograd.record():
sh = fake_latent.shape
#eps2 = (fake_latent+nd.shuffle(fake_latent))*0.5
#eps2 = (fake_latent+nd.array(np.roll(fake_latent.asnumpy(), 0, axis=1),ctx=ctx))*0.5
#eps2 = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx))
#eps2 = nd.random_normal(loc=0, scale=sigma.asscalar(), shape=fake_latent.shape, ctx=ctx) #
#eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx)
rec_output = netD(netDe(eps2))
fake_latent= (netEn(real_in))
output2 = netD2(fake_latent)
fake_out = netDe(fake_latent)
fake_concat = nd.concat(real_in, fake_out, dim=1) if append else fake_out
output = netD(fake_concat)
real_label = nd.ones(output.shape, ctx=ctx)
real_latent_label = nd.ones(output2.shape, ctx=ctx)
errG2 = GAN_loss(rec_output, real_label)
errR = L1_loss(real_out, fake_out) * lambda1
errG = 10.0*GAN_loss(output2, real_latent_label)+errG2+errR#+nd.mean(nd.power(sigma,2))
errG.backward()
#if epoch>50:
#sigma -= lr / sigma.shape[0] * sigma.grad
#print(sigma)
trainerDe.step(batch.data[0].shape[0])
trainerEn.step(batch.data[0].shape[0])
loss_rec_G2.append(nd.mean(errG2).asscalar())
loss_rec_G.append(nd.mean(nd.mean(errG)).asscalar()-nd.mean(errG2).asscalar()-nd.mean(errR).asscalar())
loss_rec_D.append(nd.mean(errD).asscalar())
loss_rec_R.append(nd.mean(errR).asscalar())
loss_rec_D2.append(nd.mean(errD2).asscalar())
_, acc2 = metric2.get()
name, acc = metric.get()
acc_rec.append(acc)
acc2_rec.append(acc2)
# Print log infomation every ten batches
if iter % 10 == 0:
_, acc2 = metric2.get()
name, acc = metric.get()
logging.info('speed: {} samples/s'.format(batch_size / (time.time() - btic)))
#print(errD)
logging.info('discriminator loss = %f, D2 loss = %f, generator loss = %f, G2 loss = %f, binary training acc = %f , D2 acc = %f, reconstruction error= %f at iter %d epoch %d'
% (nd.mean(errD).asscalar(),nd.mean(errD2).asscalar(),
nd.mean(errG-errG2-errR).asscalar(),nd.mean(errG2).asscalar(), acc,acc2,nd.mean(errR).asscalar() ,iter, epoch))
iter = iter + 1
btic = time.time()
name, acc = metric.get()
_, acc2 = metric2.get()
tp_file = open(expname + "_trainloss.txt", "a")
tp_file.write(str(nd.mean(errG2).asscalar()) + " " + str(
nd.mean(nd.mean(errG)).asscalar() - nd.mean(errG2).asscalar() - nd.mean(errR).asscalar()) + " " + str(
nd.mean(errD).asscalar()) + " " + str(nd.mean(errD2).asscalar()) + " " + str(nd.mean(errR).asscalar()) +" "+str(acc) + " " + str(acc2)+"\n")
tp_file.close()
metric.reset()
metric2.reset()
train_data.reset()
logging.info('\nbinary training acc at epoch %d: %s=%f' % (epoch, name, acc))
logging.info('time: %f' % (time.time() - tic))
if epoch%10 ==0:# and epoch>0:
text_file = open(expname + "_validtest.txt", "a")
filename = "checkpoints/"+expname+"_"+str(epoch)+"_D.params"
netD.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_D2.params"
netD2.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_En.params"
netEn.save_params(filename)
filename = "checkpoints/"+expname+"_"+str(epoch)+"_De.params"
netDe.save_params(filename)
fake_img1 = nd.concat(real_in[0],real_out[0], fake_out[0], dim=1)
fake_img2 = nd.concat(real_in[1],real_out[1], fake_out[1], dim=1)
fake_img3 = nd.concat(real_in[2],real_out[2], fake_out[2], dim=1)
fake_img4 = nd.concat(real_in[3],real_out[3], fake_out[3], dim=1)
val_data.reset()
text_file = open(expname + "_validtest.txt", "a")
for vbatch in val_data:
real_in = vbatch.data[0].as_in_context(ctx)
real_out = vbatch.data[1].as_in_context(ctx)
fake_latent= netEn(real_in)
y = netDe(fake_latent)
fake_out = y
metricMSE.update([fake_out, ], [real_out, ])
_, acc2 = metricMSE.get()
text_file.write("%s %s %s\n" % (str(epoch), nd.mean(errR).asscalar(), str(acc2)))
metricMSE.reset()
images = netDe(eps2)
fake_img1T = nd.concat(images[0],images[1], images[2], dim=1)
fake_img2T = nd.concat(images[3],images[4], images[5], dim=1)
fake_img3T = nd.concat(images[6],images[7], images[8], dim=1)
fake_img = nd.concat(fake_img1T,fake_img2T, fake_img3T,dim=2)
visual.visualize(fake_img)
plt.savefig('outputs/'+expname+'_fakes_'+str(epoch)+'.png')
text_file.close()
# Do 10 iterations of sampler update
fake_img1T = nd.concat(real_in[0],real_out[0], fake_out[0], dim=1)
fake_img2T = nd.concat(real_in[1],real_out[1], fake_out[1], dim=1)
fake_img3T = nd.concat(real_in[2],real_out[2], fake_out[2], dim=1)
#fake_img4T = nd.concat(real_in[3],real_out[3], fake_out[3], dim=1)
fake_img = nd.concat(fake_img1,fake_img2, fake_img3,fake_img1T,fake_img2T, fake_img3T,dim=2)
visual.visualize(fake_img)
plt.savefig('outputs/'+expname+'_'+str(epoch)+'.png')
'''if epoch > 100:
for ep2 in range(10):
with autograd.record():
#eps = nd.random_normal(loc=0, scale=1, shape=noiseshape, ctx=ctx) #
eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx)
eps2 = nd.random_normal(loc=0, scale=0.02, shape=noiseshape, ctx=ctx)
eps2 = nd.tanh(eps2*sigma+mu)
eps2 = nd.concat(eps,eps2,dim=0)
rec_output = netD(netDe(eps2))
fake_label = nd.zeros(rec_output.shape, ctx=ctx)
errGS = GAN_loss(rec_output, fake_label)
errGS.backward()
mu -= lr / mu.shape[0] * mu.grad
sigma -= lr / sigma.shape[0] * sigma.grad
print('mu ' + str(mu[0,0,0,0].asnumpy())+ ' sigma '+ str(sigma[0,0,0,0].asnumpy()))
'''
images = netDe(eps2)
fake_img1T = nd.concat(images[0],images[1], images[2], dim=1)
fake_img2T = nd.concat(images[3],images[4], images[5], dim=1)
fake_img3T = nd.concat(images[6],images[7], images[8], dim=1)
fake_img = nd.concat(fake_img1T,fake_img2T, fake_img3T,dim=2)
visual.visualize(fake_img)
plt.savefig('outputs/'+expname+'_fakespost_'+str(epoch)+'.png')
return([loss_rec_D,loss_rec_G, loss_rec_R, acc_rec, loss_rec_D2, loss_rec_G2, acc2_rec])
print 'encoder'
print '=========='
print o.asnumpy()
print h[0].asnumpy()
print '=========='
attn_decoder = AttnDecoderRNN(2, 5, 1, 10, 0.1)
attn_decoder.initialize()
for i in attn_decoder.collect_params().values():
i.data()[:] = 1.0
input = F.array([0])
hidden = attn_decoder.initHidden(ctx=mx.cpu())
o, h, a = attn_decoder(input, hidden, 0.5*F.ones((10, 2)))
print 'attn_decoder'
print '=========='
print o.asnumpy()
print h[0].asnumpy()
print '=========='
assert False
encoder = EncoderRNN(input_lang.n_words, opt.hidden_size, opt.num_layers)
attn_decoder = AttnDecoderRNN(opt.hidden_size, output_lang.n_words,
opt.num_layers, opt.max_length, dropout_p=0.1)
trainIters(encoder, attn_decoder, ctx, opt)
def test(data_set,
mx_model,
batch_size,
nfolds=10,
data_extra=None,
label_shape=None,
use_bgr=False):
print('testing verification..')
data_list = data_set[0]
issame_list = data_set[1]
if all(issame_list):
NvN = True
else:
NvN = False
model = mx_model
embeddings_list = []
if data_extra is not None:
_data_extra = nd.array(data_extra)
time_consumed = 0.0
if label_shape is None:
_label = nd.ones((batch_size, 1))
else:
_label = nd.ones(label_shape)
for i in range(len(data_list)):
data = data_list[i]
embeddings = None
ba = 0
while ba < data.shape[0]:
bb = min(ba + batch_size, data.shape[0])
count = bb - ba
_data = nd.slice_axis(data, axis=0, begin=bb - batch_size, end=bb)
if use_bgr:
_data = _data[:, ::-1, :, :]
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
if data_extra is None:
db = mx.io.DataBatch(data=(_data, ), label=(_label, ))
else:
db = mx.io.DataBatch(data=(_data, _data_extra),
label=(_label, ))
model.forward(db, is_train=False)
net_out = model.get_outputs()
#_arg, _aux = model.get_params()
#__arg = {}
#for k,v in _arg.iteritems():
# __arg[k] = v.as_in_context(_ctx)
#_arg = __arg
#_arg["data"] = _data.as_in_context(_ctx)
#_arg["softmax_label"] = _label.as_in_context(_ctx)
#for k,v in _arg.iteritems():
# print(k,v.context)
#exe = sym.bind(_ctx, _arg ,args_grad=None, grad_req="null", aux_states=_aux)
#exe.forward(is_train=False)
#net_out = exe.outputs
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed += diff.total_seconds()
#print(_embeddings.shape)
if embeddings is None:
embeddings = np.zeros((data.shape[0], _embeddings.shape[1]))
embeddings[ba:bb, :] = _embeddings[(batch_size - count):, :]
ba = bb
embeddings_list.append(embeddings)
_xnorm = 0.0
_xnorm_cnt = 0
for embed in embeddings_list:
for i in range(embed.shape[0]):
_em = embed[i]
_norm = np.linalg.norm(_em)
#print(_em.shape, _norm)
_xnorm += _norm
_xnorm_cnt += 1
_xnorm /= _xnorm_cnt
embeddings = embeddings_list[0].copy()
#embeddings = sklearn.preprocessing.normalize(embeddings)
acc1 = 0.0
std1 = 0.0
#_, _, accuracy, val, val_std, far = evaluate(embeddings, issame_list, nrof_folds=10)
#acc1, std1 = np.mean(accuracy), np.std(accuracy)
#print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
#embeddings = np.concatenate(embeddings_list, axis=1)
if NvN:
#embeddings = sklearn.preprocessing.normalize(embeddings)
scores = calc_cos(embeddings[0::2, :], embeddings[1::2, :])
fp_rates, fp_dict, thred_dict, recale_dict = calc_pr(scores)
return fp_rates, fp_dict, thred_dict, recale_dict
else:
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
print(embeddings.shape)
print('infer time', time_consumed)
_, _, accuracy, val, val_std, far = evaluate(embeddings,
issame_list,
nrof_folds=nfolds)
acc2, std2 = np.mean(accuracy), np.std(accuracy)
return acc1, std1, acc2, std2, _xnorm, embeddings_list
def forward_non_local(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))
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)))
f = [[None] * (self.slots + 1)] * (self.slots + 1)
if self.use_comm:
# local
for i in range(self.slots):
norm_fac = None
for j in range(self.slots):
if i != j:
f[i][j] = nd.sum(self.f_rec_local(inputs[i], training=training) * self.f_emit_local2local(inputs[j], training=training), axis=1)
f[i][j] = nd.exp(f[i][j]).reshape((f[i][j].shape[0], 1))
f[i][j] = f[i][j] * comm_rate[j][i]
if norm_fac is None:
norm_fac = nd.zeros_like(f[i][j])
norm_fac = norm_fac + f[i][j]
f[i][-1] = nd.sum(self.f_rec_local(inputs[i], training=training) * self.f_emit_global2local(inputs[-1], training=training), axis=1)
f[i][-1] = nd.exp(f[i][-1]).reshape((f[i][-1].shape[0], 1))
f[i][-1] = f[i][-1] * comm_rate[-1][i]
if norm_fac is None:
norm_fac = nd.zeros_like(f[i][-1])
norm_fac = norm_fac + f[i][-1]
for j in range(self.slots):
if i != j:
results[i] = results[i] + (1. / norm_fac) * f[i][j] * self.g_local2local(inputs[j], training=training)
results[i] = results[i] + (1. / norm_fac) * f[i][-1] * self.g_global2local(inputs[-1], training=training)
# global
norm_fac = None
for i in range(self.slots):
f[-1][i] = nd.sum(self.f_rec_global(inputs[-1], training=training) * self.f_emit_local2global(inputs[i], training=training), axis=1)
f[-1][i] = nd.exp(f[-1][i]).reshape((f[-1][i].shape[0], 1))
f[-1][i] = f[-1][i] * comm_rate[i][-1]
if norm_fac is None:
norm_fac = nd.zeros_like(f[-1][i])
norm_fac = norm_fac + f[-1][i]
for i in range(self.slots):
results[-1] = results[-1] + (1. / norm_fac) * f[-1][i] * self.g_local2global(inputs[i], training=training)
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], training=training) + inputs[i]
results[-1] = self.yz_weight_global(results[-1], training=training) + inputs[-1]
return results
def test_badcase(data_set,
mx_model,
batch_size,
name='',
data_extra=None,
label_shape=None):
print('testing verification badcase..')
data_list = data_set[0]
issame_list = data_set[1]
model = mx_model
embeddings_list = []
if data_extra is not None:
_data_extra = nd.array(data_extra)
time_consumed = 0.0
if label_shape is None:
_label = nd.ones((batch_size, ))
else:
_label = nd.ones(label_shape)
for i in range(len(data_list)):
data = data_list[i]
embeddings = None
ba = 0
while ba < data.shape[0]:
bb = min(ba + batch_size, data.shape[0])
count = bb - ba
_data = nd.slice_axis(data, axis=0, begin=bb - batch_size, end=bb)
#print(_data.shape, _label.shape)
time0 = datetime.datetime.now()
if data_extra is None:
db = mx.io.DataBatch(data=(_data, ), label=(_label, ))
else:
db = mx.io.DataBatch(data=(_data, _data_extra),
label=(_label, ))
model.forward(db, is_train=False)
net_out = model.get_outputs()
_embeddings = net_out[0].asnumpy()
time_now = datetime.datetime.now()
diff = time_now - time0
time_consumed += diff.total_seconds()
if embeddings is None:
embeddings = np.zeros((data.shape[0], _embeddings.shape[1]))
embeddings[ba:bb, :] = _embeddings[(batch_size - count):, :]
ba = bb
embeddings_list.append(embeddings)
embeddings = embeddings_list[0] + embeddings_list[1]
embeddings = sklearn.preprocessing.normalize(embeddings)
thresholds = np.arange(0, 4, 0.01)
actual_issame = np.asarray(issame_list)
nrof_folds = 10
embeddings1 = embeddings[0::2]
embeddings2 = embeddings[1::2]
assert (embeddings1.shape[0] == embeddings2.shape[0])
assert (embeddings1.shape[1] == embeddings2.shape[1])
nrof_pairs = min(len(actual_issame), embeddings1.shape[0])
nrof_thresholds = len(thresholds)
k_fold = LFold(n_splits=nrof_folds, shuffle=False)
tprs = np.zeros((nrof_folds, nrof_thresholds))
fprs = np.zeros((nrof_folds, nrof_thresholds))
accuracy = np.zeros((nrof_folds))
indices = np.arange(nrof_pairs)
diff = np.subtract(embeddings1, embeddings2)
dist = np.sum(np.square(diff), 1)
data = data_list[0]
pouts = []
nouts = []
for fold_idx, (train_set, test_set) in enumerate(k_fold.split(indices)):
# Find the best threshold for the fold
acc_train = np.zeros((nrof_thresholds))
#print(train_set)
#print(train_set.__class__)
for threshold_idx, threshold in enumerate(thresholds):
p2 = dist[train_set]
p3 = actual_issame[train_set]
_, _, acc_train[threshold_idx] = calculate_accuracy(
threshold, p2, p3)
best_threshold_index = np.argmax(acc_train)
for threshold_idx, threshold in enumerate(thresholds):
tprs[fold_idx,
threshold_idx], fprs[fold_idx,
threshold_idx], _ = calculate_accuracy(
threshold, dist[test_set],
actual_issame[test_set])
_, _, accuracy[fold_idx] = calculate_accuracy(
thresholds[best_threshold_index], dist[test_set],
actual_issame[test_set])
best_threshold = thresholds[best_threshold_index]
for iid in test_set:
ida = iid * 2
idb = ida + 1
asame = actual_issame[iid]
_dist = dist[iid]
violate = _dist - best_threshold
if not asame:
violate *= -1.0
if violate > 0.0:
imga = data[ida].asnumpy().transpose(
(1, 2, 0))[..., ::-1] #to bgr
imgb = data[idb].asnumpy().transpose((1, 2, 0))[..., ::-1]
#print(imga.shape, imgb.shape, violate, asame, _dist)
if asame:
pouts.append((imga, imgb, _dist, best_threshold, ida))
else:
nouts.append((imga, imgb, _dist, best_threshold, ida))
tpr = np.mean(tprs, 0)
fpr = np.mean(fprs, 0)
acc = np.mean(accuracy)
pouts = sorted(pouts, key=lambda x: x[2], reverse=True)
nouts = sorted(nouts, key=lambda x: x[2], reverse=False)
print(len(pouts), len(nouts))
print('acc', acc)
gap = 10
image_shape = (112, 224, 3)
out_dir = "./badcases"
if not os.path.exists(out_dir):
os.makedirs(out_dir)
if len(nouts) > 0:
threshold = nouts[0][3]
else:
threshold = pouts[-1][3]
for item in [(pouts, 'positive(false_negative).png'),
(nouts, 'negative(false_positive).png')]:
cols = 4
rows = 8000
outs = item[0]
if len(outs) == 0:
continue
#if len(outs)==9:
# cols = 3
# rows = 3
_rows = int(math.ceil(len(outs) / cols))
rows = min(rows, _rows)
hack = {}
if name.startswith('cfp') and item[1].startswith('pos'):
hack = {
0: 'manual/238_13.jpg.jpg',
6: 'manual/088_14.jpg.jpg',
10: 'manual/470_14.jpg.jpg',
25: 'manual/238_13.jpg.jpg',
28: 'manual/143_11.jpg.jpg'
}
filename = item[1]
if len(name) > 0:
filename = name + "_" + filename
filename = os.path.join(out_dir, filename)
img = np.zeros((image_shape[0] * rows + 20, image_shape[1] * cols +
(cols - 1) * gap, 3),
dtype=np.uint8)
img[:, :, :] = 255
text_color = (0, 0, 153)
text_color = (255, 178, 102)
text_color = (153, 255, 51)
for outi, out in enumerate(outs):
row = outi // cols
col = outi % cols
if row == rows:
break
imga = out[0].copy()
imgb = out[1].copy()
if outi in hack:
idx = out[4]
print('noise idx', idx)
aa = hack[outi]
imgb = cv2.imread(aa)
#if aa==1:
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 1)
#elif aa==3:
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 0)
#else:
# for ii in range(2):
# imgb = cv2.transpose(imgb)
# imgb = cv2.flip(imgb, 1)
dist = out[2]
_img = np.concatenate((imga, imgb), axis=1)
k = "%.3f" % dist
#print(k)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(_img, k, (80, image_shape[0] // 2 + 7), font, 0.6,
text_color, 2)
#_filename = filename+"_%d.png"%outi
#cv2.imwrite(_filename, _img)
img[row * image_shape[0]:(row + 1) * image_shape[0],
(col * image_shape[1] +
gap * col):((col + 1) * image_shape[1] + gap * col), :] = _img
#threshold = outs[0][3]
font = cv2.FONT_HERSHEY_SIMPLEX
k = "threshold: %.3f" % threshold
cv2.putText(img, k, (img.shape[1] // 2 - 70, img.shape[0] - 5), font,
0.6, text_color, 2)
cv2.imwrite(filename, img)
def train():
image_pool = ImagePool(pool_size)
metric = mx.metric.CustomMetric(facc)
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
logging.basicConfig(level=logging.DEBUG)
# define a summary writer that logs data and flushes to the file every 5 seconds
sw = SummaryWriter(logdir='./logs_', flush_secs=5)
global_step = 0
# paramsG = netG.collect_params()
# param_namesG = paramsG.keys()
#
# paramsD = netD.collect_params()
# param_namesD = paramsD.keys()
for epoch in range(epochs):
if epoch == 0:
netG.hybridize()
netD.hybridize()
# sw.add_graph(netG)
# sw.add_graph(netD)
tic = time.time()
btic = time.time()
train_data.reset()
iter = 0
for local_step, batch in enumerate(train_data):
############################
# (1) Update D network: maximize log(D(x, y)) + log(1 - D(x, G(x, z)))
###########################
real_in = batch.data[0].as_in_context(ctx)
real_out = batch.data[1].as_in_context(ctx)
fake_out = netG(real_in)
fake_concat = image_pool.query(nd.concat(real_in, fake_out, dim=1))
with autograd.record():
# Train with fake image
# Use image pooling to utilize history images
output = netD(fake_concat)
fake_label = nd.zeros(output.shape, ctx=ctx)
errD_fake = GAN_loss(output, fake_label)
metric.update([
fake_label,
], [
output,
])
# Train with real image
real_concat = nd.concat(real_in, real_out, dim=1)
output = netD(real_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errD_real = GAN_loss(output, real_label)
errD = (errD_real + errD_fake) * 0.5
errD.backward()
metric.update([
real_label,
], [
output,
])
trainerD.step(batch.data[0].shape[0])
sw.add_graph((netG))
############################
# (2) Update G network: maximize log(D(x, G(x, z))) - lambda1 * L1(y, G(x, z))
###########################
with autograd.record():
fake_out = netG(real_in)
fake_concat = nd.concat(real_in, fake_out, dim=1)
output = netD(fake_concat)
real_label = nd.ones(output.shape, ctx=ctx)
errG = GAN_loss(
output, real_label) + L1_loss(real_out, fake_out) * lambda1
errG.backward()
trainerG.step(batch.data[0].shape[0])
sw.add_scalar(tag='loss',
value=('d_loss', errD.mean().asscalar()),
global_step=global_step)
sw.add_scalar(tag='loss',
value=('g_loss', errG.mean().asscalar()),
global_step=global_step)
global_step += 1
# Log the first batch of images of each epoch
if local_step == 0:
fake_out = ((fake_out + 1) * 127.5) / 255
sw.add_image('minist_first_minibatch', fake_out, epoch)
if iter % 10 == 0:
name, acc = metric.get()
logging.info('speed: {} samples/s'.format(
batch_size / (time.time() - btic)))
logging.info(
'discriminator loss = %f, generator loss = %f, binary training acc = %f at iter %d epoch %d'
% (nd.mean(errD).asscalar(), nd.mean(errG).asscalar(), acc,
iter, epoch))
iter = iter + 1
btic = time.time()
sw.add_scalar(tag='binary_training_acc',
value=('acc', acc),
global_step=epoch)
# gradsG = [i.grad() for i in netG.collect_params().values()]
# gradsD = [i.grad() for i in netD.collect_params().values()]
# # logging the gradients of parameters for checking convergence
# for i, name in enumerate(param_namesG):
# sw.add_histogram(tag=name + 'G', values=gradsG[i], global_step=epoch, bins=1000)
# for i, name in enumerate(param_namesD):
# sw.add_histogram(tag=name + 'D', values=gradsD[i], global_step=epoch, bins=1000)
name, acc = metric.get()
metric.reset()
logging.info('\nbinary training acc at epoch %d: %s=%f' %
(epoch, name, acc))
logging.info('time: %f' % (time.time() - tic))
# # Visualize one generated image for each epoch
# fake_img = fake_out[0]
# visualize(fake_img)
# plt.show()
sw.export_scalars('scalar_dict.json')
sw.close()
