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()