def bbox_overlaps(anchors: mx.nd.NDArray, gt: mx.nd.NDArray): """ Get IoU of the anchors and ground truth bounding boxes. The shape of anchors and gt should be (N, 4) and (M, 4) So the shape of return value is (N, M) """ ret = [] for i in range(gt.shape[0]): cgt = gt[i].reshape((1, 4)).broadcast_to(anchors.shape) # inter x0 = nd.max(nd.stack(anchors[:, 0], cgt[:, 0]), axis=0) y0 = nd.max(nd.stack(anchors[:, 1], cgt[:, 1]), axis=0) x1 = nd.min(nd.stack(anchors[:, 2], cgt[:, 2]), axis=0) y1 = nd.min(nd.stack(anchors[:, 3], cgt[:, 3]), axis=0) inter = _get_area( nd.concatenate([ x0.reshape((-1, 1)), y0.reshape((-1, 1)), x1.reshape((-1, 1)), y1.reshape((-1, 1)) ], axis=1)) outer = _get_area(anchors) + _get_area(cgt) - inter iou = inter / outer ret.append(iou.reshape((-1, 1))) ret = nd.concatenate(ret, axis=1) return ret
def validate(self): """Perform validation""" l = [] input_list, pred_list, wp_list = [], [], [] for i, (A_rp, wp) in enumerate(self.val_iter): # Inputs to GPUs (or CPUs) self.set_inputs(A_rp_val=A_rp, wp_val=wp) pred = [self.netG(A_rp_val) for A_rp_val in self.A_rp_val] # Split segmentation and regression outputs if multitask learning is used pred = nd.concatenate(pred) # merge data across all used GPUs self.A_rp_val, self.wp_val = [ nd.concatenate(list(x)) for x in [ self.A_rp_val, self.wp_val] ] input_list.append(self.A_rp_val.asnumpy()) pred_list.append(pred.asnumpy()) wp_list.append(self.wp_val.asnumpy()) l.append(self.seg_val(pred, self.wp_val).asnumpy()) self.running_loss_seg_val = np.concatenate([*l]).mean() return input_list, pred_list, wp_list
def evaluate(net,test_data,ctx): feature_true_list=[] feature_label_list=[] p_feature_list=[] p_label_list=[] for i,(data,label) in enumerate(test_data): data=data.as_in_context(ctx) label=label.as_in_context(ctx) if i<67: feature_true=net(data) feature_true_list.append(feature_true) feature_label=label feature_label_list.append(feature_label) elif i>=67 and i<134: p_data=data p_feature = net(p_data) p_feature_list.append(p_feature) p_label=label p_label_list.append(p_label) else: break feature_true=nd.concatenate(feature_true_list,0) feature_label=nd.concatenate(feature_label_list,0) p_feature=nd.concatenate(p_feature_list,0) p_label=nd.concatenate(p_label_list,0).reshape(-1) acc=accuracy_metric(feature_true,feature_label,p_feature,p_label) return acc
def preEventsDataset(fs, T, C): deltat = T / 2 #1#2.5#3#5 onesecslice = [(65232, 69327), (65178, 69273), (66142, 70237), (66134, 70229), (65902, 69997), (65928, 70023), (65281, 69376), (65294, 69389)] llLIGOevents = [ file for file in os.listdir('Data_LIGO_Totural') if 'strain' in file ] llLIGOevents.sort() aroundEvents = np.concatenate([np.load('./Data_LIGO_Totural/'+file).reshape(1,-1)[:,onesecslice[index][0]-int((deltat-0.5)*fs):onesecslice[index][1]+int((deltat-0.5)*fs)+1] \ for index, file in enumerate(llLIGOevents)]) logger.debug('Loaded aroundEvents: {}', aroundEvents.shape) # (8, T*fs) logger.debug('Loaded list of Events: \n{}', np.array(llLIGOevents)) aroundEvents = nd.array(aroundEvents).expand_dims(1) if C == 1: aroundEvent_psd_block = nd.concatenate( [EquapEvent(fs, data) for data in aroundEvents], axis=0) elif C == 2: aroundEvent_psd_block_H1 = nd.concatenate( [EquapEvent(fs, data) for data in aroundEvents[::2]], axis=0) # (4, 2, 1, 102400) aroundEvent_psd_block_L1 = nd.concatenate( [EquapEvent(fs, data) for data in aroundEvents[1::2]], axis=0) # (4, 2, 1, 102400) aroundEvent_psd_block = nd.concat( aroundEvent_psd_block_H1.swapaxes(1, 0).expand_dims(2), aroundEvent_psd_block_L1.swapaxes(1, 0).expand_dims(2), dim=2).swapaxes(1, 0) logger.debug('aroundEvent_psd_block: {}', aroundEvent_psd_block.shape) return aroundEvent_psd_block
def predict_all(X, net, ctx, dfeat, batch_size=64, cnn_flag=False): ''' :param X: an ndarray containing the data. The first axis is over examples :param net: trained model :param dfeat: the dimensionality of the vectorized feature :param batchsize: batchsize used in iterators. default is 64. :return: Two ndarrays containing the soft and hard predictions of the classifier. ''' data_iterator = mx.io.NDArrayIter(X, None, batch_size, shuffle=False) ypred_soft = [] ypred = [] for i, batch in enumerate(data_iterator): if cnn_flag: data = batch.data[0].as_in_context(ctx) else: data = batch.data[0].as_in_context(ctx).reshape((-1, dfeat)) output = net(data) softpredictions = nd.softmax(output, axis=1) predictions = nd.argmax(output, axis=1) ypred_soft.append(softpredictions) ypred.append(predictions) ypred_soft_all = nd.concatenate(ypred_soft, axis=0) ypred_all = nd.concatenate(ypred, axis=0) # iterator automatically pads the last minibatch, so the length of the vectors might be different. ypred_all = ypred_all[:X.shape[0]] ypred_soft_all = ypred_soft_all[:X.shape[0], ] return ypred_all, ypred_soft_all
def validate(nfolds=10): metric = FaceVerification(nfolds) metric_flip = FaceVerification(nfolds) for loader, name in zip(val_datas, targets.split(",")): metric.reset() for i, batch in enumerate(loader): data0s = gluon.utils.split_and_load(batch[0][0][0], ctx, even_split=False) data1s = gluon.utils.split_and_load(batch[0][1][0], ctx, even_split=False) data0s_flip = gluon.utils.split_and_load(batch[0][0][1], ctx, even_split=False) data1s_flip = gluon.utils.split_and_load(batch[0][1][1], ctx, even_split=False) issame_list = gluon.utils.split_and_load(batch[1], ctx, even_split=False) embedding0s = [test_net(X) for X in data0s] embedding1s = [test_net(X) for X in data1s] embedding0s_flip = [test_net(X) for X in data0s_flip] embedding1s_flip = [test_net(X) for X in data1s_flip] emb0s = [ nd.L2Normalization(e, mode='instance') for e in embedding0s ] emb1s = [ nd.L2Normalization(e, mode='instance') for e in embedding1s ] for embedding0, embedding1, issame in zip(emb0s, emb1s, issame_list): metric.update(issame, embedding0, embedding1) emb0s_flip = [ nd.L2Normalization(nd.concatenate([e, ef], 1), mode='instance') for e, ef in zip(embedding0s, embedding0s_flip) ] emb1s_flip = [ nd.L2Normalization(nd.concatenate([e, ef], 1), mode='instance') for e, ef in zip(embedding1s, embedding1s_flip) ] for embedding0, embedding1, issame in zip(emb0s_flip, emb1s_flip, issame_list): metric_flip.update(issame, embedding0, embedding1) tpr, fpr, accuracy, val, val_std, far, accuracy_std = metric.get() print("{}: \t{:.6f}+-{:.6f}".format(name, accuracy, accuracy_std)) _, _, accuracy, _, _, _, accuracy_std = metric_flip.get() print("{}-flip: {:.6f}+-{:.6f}".format(name, accuracy, accuracy_std))
def test(ctx): """Test a model.""" val_data.reset() outputs = [] labels = [] for batch in val_data: data = gluon.utils.split_and_load(batch.data[0], ctx_list=ctx, batch_axis=0) label = gluon.utils.split_and_load(batch.label[0], ctx_list=ctx, batch_axis=0) for x in data: outputs.append(net(x)[-1]) labels += label outputs = nd.concatenate(outputs, axis=0)[:val_data.n_test] labels = nd.concatenate(labels, axis=0)[:val_data.n_test] return evaluate_emb(outputs, labels)
def load_data(data_path, batch_size, reverse=False): img_in_list, img_out_list = [], [] for path, _, files in os.walk(data_path): for file in files: if not file[-4:] in ['.jpg']: continue img_arr = mx.image.imread(join(path, file)).astype(np.float32)/127.5 - 1 img_in, img_out = preprocess_single_img(img_arr) if not reverse: img_in_list.append(img_in) img_out_list.append(img_out) else: img_in_list.append(img_out) img_out_list.append(img_in) return mx.io.NDArrayIter(data = [nd.concatenate(img_in_list), nd.concatenate(img_out_list)], batch_size=batch_size)
def bbox_overlaps(anchors: mx.nd.NDArray, gt: mx.nd.NDArray): """ Get IoU of the anchors and ground truth bounding boxes. The shape of anchors and gt should be (N, 4) and (M, 4) So the shape of return value is (N, M) """ N, M = anchors.shape[0], gt.shape[0] anchors_mat = anchors.reshape((N, 1, 4)).broadcast_to((N, M, 4)).reshape( (-1, 4)) gt_mat = gt.reshape((1, M, 4)).broadcast_to((N, M, 4)).reshape((-1, 4)) # inter x0 = nd.max(nd.stack(anchors_mat[:, 0], gt_mat[:, 0]), axis=0) y0 = nd.max(nd.stack(anchors_mat[:, 1], gt_mat[:, 1]), axis=0) x1 = nd.min(nd.stack(anchors_mat[:, 2], gt_mat[:, 2]), axis=0) y1 = nd.min(nd.stack(anchors_mat[:, 3], gt_mat[:, 3]), axis=0) inter = _get_area( nd.concatenate([ x0.reshape((-1, 1)), y0.reshape((-1, 1)), x1.reshape((-1, 1)), y1.reshape((-1, 1)) ], axis=1)) outer = _get_area(anchors_mat) + _get_area(gt_mat) - inter iou = inter / outer iou = iou.reshape((N, M)) return iou
def extract_feature(): """ extract data feature vector and save :param model: :param dataloader: :return: """ global net deepfashion_csv = 'checkpoints/deepfashion.csv' # write vector to this file net.initialize() net.collect_params().reset_ctx(context) net.load_parameters(opt.load_model_path,ctx=context) import csv f = open(deepfashion_csv,'w') writer = csv.writer(f,dialect='excel') for i,batch in tqdm(enumerate(val_dataloader)): batch_size = batch[0].shape[0] data = gluon.utils.split_and_load(batch[0], ctx_list=context, batch_axis=0) label = gluon.utils.split_and_load(batch[1], ctx_list=context, batch_axis=0) # after split data is list of two data batch small_batch_feature = [] for x in data: feature = net.extract(x) small_batch_feature.append(feature) image_id = np.arange(i*batch_size,(i+1)*batch_size).reshape(-1,1) # prepare the image_id vector = nd.concatenate(small_batch_feature,axis=0).asnumpy() # concatenate the feature label = np.array([x.asnumpy() for x in label]).reshape(-1,1) result = np.hstack((image_id,label,vector)) writer.writerows(result) print("finished extract feature") f.close() return "True finished"
def get_test_batch(self): """Sample a testing batch (data and label).""" batch_size = self.batch_size batch = [self.get_image(self.test_image_files[(self.test_count*batch_size + i) % len(self.test_image_files)], is_train=False) for i in range(batch_size)] labels = [self.test_labels[(self.test_count*batch_size + i) % len(self.test_image_files)] for i in range(batch_size)] return nd.concatenate(batch, axis=0), labels
def test(ctx): """Test a model.""" if opt.use_viz: viz.log("begin to valid") outputs = [] labels = [] for i,batch in enumerate(val_dataloader): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0) # after split data is list of two data batch for x in data: outputs.append(net(x)[-1]) labels +=label if (i+1)%(opt.log_interval*2) ==0: viz.log("valid iter {0}".format(i)) outputs = nd.concatenate(outputs, axis=0) labels = nd.concatenate(labels, axis=0) viz.log("begin to eval embedding search") return evaluate_emb(outputs, labels)
def evaluate_net(self, base_net, val_data): triplet_loss = gluon.loss.TripletLoss(margin=0) rate = 0.0 sum_correct, sum_all = 0, 0 for i, batch in enumerate(val_data): data, labels = batch[0], batch[1].astype('float32') data = split_and_load(data, ctx_list=self.ctx, batch_axis=0, even_split=False) # 多GPU labels = split_and_load(labels, ctx_list=self.ctx, batch_axis=0, even_split=False) for X in data: anchor_ins, pos_ins, neg_ins = [], [], [] for b_X in X: anchor_ins.append(nd.expand_dims(b_X[0], axis=0)) pos_ins.append(nd.expand_dims(b_X[1], axis=0)) neg_ins.append(nd.expand_dims(b_X[2], axis=0)) anchor_ins = nd.concatenate(anchor_ins, axis=0) pos_ins = nd.concatenate(pos_ins, axis=0) neg_ins = nd.concatenate(neg_ins, axis=0) inter1 = base_net(anchor_ins) inter2 = base_net(pos_ins) inter3 = base_net(neg_ins) loss = triplet_loss(inter1, inter2, inter3) # TripletLoss n_correct = np.sum(np.where(loss == 0, 1, 0)) sum_all += loss.shape[0] sum_correct += n_correct rate = safe_div(sum_correct, sum_all) self.print_info('验证Batch: {}, 准确率: {:.4f} ({} / {})'.format( i, rate, sum_correct, sum_all)) rate = safe_div(sum_correct, sum_all) self.print_info('验证准确率: %.4f (%s / %s)' % (rate, sum_correct, sum_all)) return rate
def __call__(self, src): """Augmenter body""" assert src.shape[-2:] == (self.C, self.N) # (nsample, C, N) if self.ori_peak is None: self.ori_peak = int( src.argmax(axis=2)[0, 0].asscalar()) # first+H1 as bench logger.debug('self.ori_peak: {}', self.ori_peak) # myrelu = lambda x: x if (x>0) and (x<=self.ori_peak*2) else None # (nsample, C, 2*(N-margin)) # full = nd.concatenate([src, nd.zeros(shape=src.shape[:2]+(self.ori_peak*2-self.N,))], axis=2)[:,:,myrelu(self.ori_peak-(self.N-self.margin)):myrelu(self.ori_peak+(self.N-self.margin))] full = nd.concat(src, nd.zeros(shape=src.shape[:2] + (self.ori_peak - self.margin, )), dim=2)[:, :, self.ori_peak - (self.N - self.margin):] assert (nd.sum(full[:, :1].argmax(-1) / full[:, :1].shape[-1]) / full[:, :1].shape[0]).asscalar() == 0.5 if self.margin == (self.T * self.fs) // 2: return full if self.rand_jitter: # for every sample """ RP = RandomPeakAug(margin=0.1, fs = fs, C = 2, ori_peak=0.9, rand_jitter=0) %timeit _ = RP(dataset_GW[pre]) # 505 ms ± 30.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) """ randlist = [(i, i + fs) for i in np.random.randint( low=1, high=(fs - 2 * self.margin), size=full.shape[0]) if i + fs <= full.shape[-1]] assert len(randlist) == full.shape[0] return nd.concatenate([ sample.expand_dims(axis=0)[:, :, i:j] for sample, (i, j) in zip(full, randlist) ], axis=0) # (nsample, C, N) # full = nd.concatenate([self.shape_aug(sample.swapaxes(0,1).expand_dims(axis=0)) for sample in full ], axis=0) # (nsample, N, C) # return full.swapaxes(1,2) # (nsample, C, N) else: """ RP = RandomPeakAug(margin=0.1, fs = fs, C = 2, ori_peak=0.9, rand_jitter=1) %timeit _ = RP(dataset_GW[pre]) # 808 µs ± 37.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) """ full = full.swapaxes(0, 2).expand_dims( axis=0) # (1, 2*(N-margin), C, nsample) return self.shape_aug(full.reshape(1, 0, -3)).reshape( 1, 0, self.C, -1 ).swapaxes( 1, 3 )[0] # where swapaxes from (1, 2*(N-margin), C, nsample) to (nsample, C, N)
def update_running_loss(self, first_iter=False, num_batch=None): """Compute running loss""" if num_batch is None: if first_iter: loss_fields = [field for field in self.__dict__.keys() if ('loss' in field) or ('err' in field)] self.running_loss_fields = ['running_' + field for field in loss_fields] [self.__setattr__(field, 0.) for field in self.running_loss_fields] for loss_field in self.running_loss_fields: _loss = nd.concatenate(list(self.__getattribute__(loss_field.replace('running_', '')))) self.__setattr__(loss_field, (self.__getattribute__(loss_field) + _loss.mean().asscalar())) else: for loss_field in self.running_loss_fields: self.__setattr__(loss_field, (self.__getattribute__(loss_field) / num_batch))
def update(self, labels, preds): """ :param labels: [(batch_per_device, ), (), ...] :param preds: [(batch_per_device, 1), (), ...] :return: """ # binary_label = labels # binary_cls_logits = preds[0] num_acc = 0 for lb, pd in zip(labels, preds): tp_RET = nd.concatenate([nd.expand_dims(lb, axis=1), pd], axis=1) if self.RET is None: self.RET = tp_RET else: self.RET = nd.concatenate([self.RET, tp_RET], axis=0) pred_label = nd.squeeze(pd) >= 0.5 tp = nd.sum(pred_label == lb) num_acc = num_acc + tp.asscalar() self.sum_metric += num_acc self.num_inst += self.config.batch_size
def extract_feat(ids, data, model): ctx = try_gpu() if len(ctx) > 1: _data_list = gluon.utils.split_and_load(data=data, ctx_list=ctx) _id_list = gluon.utils.split_and_load(data=ids, ctx_list=ctx) else: _data_list = [data.as_in_context(ctx[0])] _id_list = [ids.as_in_context(ctx[0])] # print(_id_list) data_list = [] id_list = [] for _ids, _data in zip(_id_list, _data_list): feats = model(_data) feats = map(lambda x: x / nd.norm(x), feats[:, :, 0, 0]) feats = [v.expand_dims(axis=0) for v in feats] feats = nd.concatenate(feats) id_list.append(_ids) data_list.append(feats) id_list = nd.concatenate(id_list) data_list = nd.concatenate(data_list) return id_list, data_list
def sample_train_batch(self): """Sample a training batch (data and label).""" batch = [] labels = [] num_groups = self.batch_size // self.batch_k # For CUB200, we use the first 100 classes for training. sampled_classes = np.random.choice(100, num_groups, replace=False) for i in range(num_groups): img_fnames = np.random.choice(self.train_image_files[sampled_classes[i]], self.batch_k, replace=False) batch += [self.get_image(img_fname, is_train=True) for img_fname in img_fnames] labels += [sampled_classes[i] for _ in range(self.batch_k)] return nd.concatenate(batch, axis=0), labels
def get_test_batch(self): """Sample a testing batch (data and label).""" batch_size = self.batch_size batch = [ self.get_image( self.test_image_files[(self.test_count * batch_size + i) % len(self.test_image_files)], is_train=False) for i in range(batch_size) ] labels = [ self.test_labels[(self.test_count * batch_size + i) % len(self.test_image_files)] for i in range(batch_size) ] return nd.concatenate(batch, axis=0), labels
def extract_feature(model, dataloaders, ctx): count = 0 features = [] for img, _ in dataloaders: n = img.shape[0] count += n print(count) ff = np.zeros((n, 256*num_parts)) for i in range(2): if(i==1): img = fliplr(img) f = nd.concatenate(model(img.as_in_context(ctx)), axis=1).as_in_context(mx.cpu()).asnumpy() ff = ff+f features.append(ff) features = np.concatenate(features) return features/np.linalg.norm(features, axis=1, keepdims=True)
def load_data(): lfw_url = 'http://vis-www.cs.umass.edu/lfw/lfw-deepfunneled.tgz' data_path = data_dir + '/lfw_dataset' if not os.path.exists(data_path): os.makedirs(data_path) data_file = utils.download(lfw_url) with tarfile.open(data_file) as tar: tar.extractall(path=data_path) img_list = [] for path, _, fnames in os.walk(data_path): for fname in fnames: if not fname.endswith('.jpg'): continue img = os.path.join(path, fname) img_arr = mx.image.imread(img) img_arr = transform(img_arr) img_list.append(img_arr) train_data = mx.io.NDArrayIter(data=nd.concatenate(img_list), batch_size=batch_size) return train_data
def predict(yolo: Yolo, x, threshold=0.5): """ return label ,C,location :param yolo: :return: """ assert len(x) == 1, "Only One image for now" ypre = yolo(x) label, preds, location = deal_output(ypre, yolo.s, b=yolo.b, c=yolo.class_num) indexs = [] for i, c in enumerate(preds[0]): if c > threshold: indexs.append(i) class_names = [] C_list = [] bos_list = [] for index in indexs: label_index = int(index / 2) location_offect = int(index % 2) class_index = nd.argmax(label[0][label_index], axis=0) C = preds[0][index] locat = location[0][label_index][location_offect] C_list.append(C.asscalar()) #######traslate the name label_name = yolo.class_names text = label_name[int(class_index.asscalar())] class_names.append(text) ###traslate the locat x, y, w, h = locat w, h = nd.power(w, 2), nd.power(h, 2) ceil = 1 / 4 row = int(label_index / 4) columns = label_index % 4 x_center = columns * ceil + x y_center = row * ceil + y x_min, y_min, x_max, y_max = x_center - 0.5 * w, y_center - 0.5 * h, x_center + 0.5 * w, y_center + 0.5 * h box = nd.concatenate([x_min, y_min, x_max, y_max], axis=0) * 256 bos_list.append(box.asnumpy()) return class_names, C_list, bos_list
def sample_train_batch(self): """Sample a training batch (data and label).""" batch = [] labels = [] num_groups = self.batch_size // self.batch_k # For CUB200, we use the first 100 classes for training. sampled_classes = np.random.choice(100, num_groups, replace=False) for i in range(num_groups): img_fnames = np.random.choice( self.train_image_files[sampled_classes[i]], self.batch_k, replace=False) batch += [ self.get_image(img_fname, is_train=True) for img_fname in img_fnames ] labels += [sampled_classes[i] for _ in range(self.batch_k)] return nd.concatenate(batch, axis=0), labels
def concat_and_load(data, use_cpu=True, gpu_id=0): """Splits an NDArray into `len(ctx_list)` slices along `batch_axis` and loads each slice to one context in `ctx_list`. Parameters ---------- data : NDArray A batch of data in different gpu. use_cpu : bool, default True Use cpu or gpu. gpu_id : int, default 0 Which gpu to use. Returns ------- NDArray All data in one device. """ if isinstance(data, list): if use_cpu: ctx = mx.cpu() else: ctx = mx.gpu(gpu_id) data = [x.as_in_context(ctx) for x in data] return nd.concatenate(data)
def read_image(dir_path): path_list = [path for path in os.listdir(dir_path)] path_list = [os.path.join(dir_path, path) for path in path_list] p = multiprocessing.Pool(NUM_THREADS) print('Check if the path is valid...') check_result = [] for path in tqdm(path_list): check_result.append(p.apply_async(_check_img, args=(path, ))) p.close() p.join() valid_path_list = [] ids = [] for path, check in tqdm(zip(path_list, check_result)): if check.get(): valid_path_list.append(path) ids.append(path.split('/')[-1].split('.')[0]) else: continue print('Reading images...') n = len(valid_path_list) num_batches = n // BATCH_SIZE ids = nd.array(ids) for i in range(num_batches + 1): _path_list = valid_path_list[i * BATCH_SIZE:min((i + 1) * BATCH_SIZE, n)] _ids = ids[i * BATCH_SIZE:min((i + 1) * BATCH_SIZE, n)] _data = [] for path in _path_list: img = mx.image.imread(path) _data.append(img) _data = [img for img in map(transform, _data)] _data = nd.concatenate(_data) yield _data, _ids.astype('int')
def Gen_noise(fs, T, C, fixed=None): tNoiseKEY = 'Event' noise_address = os.path.join('./', 'data', 'LIGO_O1_noise_ndarray') root = os.path.expanduser(noise_address) ll = [ file for file in os.listdir(root) if '_bug' not in file if tNoiseKEY in file ] if fixed: r = 2 noise = nd.concatenate([ readnpy(noise_address, file)[1][:, :C, ::4] for file in ll[r:r + T] ], axis=0).astype('float32') # (4096*T, C, 4096) noise_gps = nd.concatenate([ readnpy(noise_address, file)[0, :, :1, ::4] for file in ll[r:r + T] ], axis=0).astype( 'float32') # (4096*T, C, 4096) noise = noise.swapaxes(1, 0).reshape(0, -1, fs * T).swapaxes(1, 0) noise_gps = noise_gps.swapaxes(1, 0).reshape(0, -1, fs * T).swapaxes(1, 0) noise = nd.concatenate([noise, noise_gps], axis=1) return noise[:, :2], (ll[r:r + T], noise_gps.asnumpy()) r = np.random.randint(len(ll) - T) noise = nd.concatenate( [readnpy(noise_address, file)[1][:, :C, ::4] for file in ll[r:r + T]], axis=0).astype('float32') # (4096*T, C, 4096) noise_gps = nd.concatenate( [readnpy(noise_address, file)[0, :, :1, ::4] for file in ll[r:r + T]], axis=0).astype('float32') # (4096*T, C, 4096) noise = noise.swapaxes(1, 0).reshape(0, -1, fs * T).swapaxes(1, 0) noise_gps = noise_gps.swapaxes(1, 0).reshape(0, -1, fs * T).swapaxes(1, 0) noise = nd.concatenate([noise, noise_gps], axis=1) noise = nd.shuffle(noise) if T != 1: return noise[:, :2], (ll[r:r + T], noise[:, 2].asnumpy()) return noise, (ll[r:r + T], noise[:, 2, 0].asnumpy()) # (nsample, C, N)
utils.visualize(utils.img_list_clock[i][0]) plt.suptitle('clock') plt.show() fig = plt.figure(figsize=(3.5,3.5)) for i in range(9): plt.subplot(3,3,i+1) utils.visualize(utils.img_list_crocodile[i][0]) plt.suptitle('crocodile') plt.show() #======================shuffle data and set some params====================== batch_size = 50 ctx = utils.try_gpu() label = nd.stack(nd.zeros([int(len(utils.img_list)/2),1],ctx=ctx),nd.ones([int(len(utils.img_list)/2),1],ctx=ctx)).reshape([len(utils.img_list)]) data = nd.concatenate(utils.img_list) mx.random.seed(2) data = random.shuffle(data) mx.random.seed(2) label = random.shuffle(label) epochs = 200 loss = gluon.loss.SoftmaxCrossEntropyLoss() k_cross = 10 path_net = 'net' if not os.path.exists(path_net): os.makedirs(path_net)
def MultiBoxTarget(anchors, class_predictions, labels, hard_neg_ratio=3, ctx=gpu(), verbose=False): '''將真實方框(ground truth boxes)和預設錨框(default anchor boxes)做配對。 labels: 真實方框 (ground truth boxes)。 anchors: 預設錨框 (default anchor boxes)。 hard_neg_ratio: 負樣本(背景)和正樣本(有物體的錨框數)的比例。預設是3:1。 ''' if verbose: print("anchors shape=", anchors.shape) assert anchors.shape[0] == 1 batch_size = len(labels) num_priors = anchors.shape[1] if verbose: print("batch size=\t", batch_size) print("num priors=\t", num_priors) anchor_shifts = nd.zeros((batch_size, anchors.shape[1] * 4), ctx=ctx) box_mask = nd.zeros((batch_size, anchors.shape[1] * 4), ctx=ctx) anchor_classes = nd.zeros((batch_size, num_priors), ctx=ctx) - 1 anchor_indices = nd.zeros((batch_size, num_priors), ctx=ctx) - 1 classes_mask = nd.zeros((batch_size, anchors.shape[1]), ctx=ctx) shifts_tmp = nd.zeros_like(anchors[0]) mask_tmp = nd.zeros_like(anchors[0]) for i in range(batch_size): label_locs = labels[i][:, 1:] label_classes = labels[i][:, 0] class_preds = class_predictions[i] # obtain IoU ious = iou(label_locs, anchors[0]) # identify how many ground truth objects are there in this batch if -1 in label_classes: num_obj = label_classes.argmin(axis=0).astype("int32").asscalar() else: num_obj = label_classes.size if num_obj == 0: continue # matching anchor boxes with ground truth boxes ious_flag = ious > 0.5 # find locations of the best priors best_prior_idx = ious[0:num_obj, :].argmax(axis=1) idx_row = [*range(best_prior_idx.size)] ious_flag[idx_row, best_prior_idx] += 1 if_negative = label_classes != -1 label_classes = label_classes + if_negative * 1 # add the -1 class to the end label_classes = nd.concat(label_classes, nd.array([-1], ctx=label_classes.context), dim=0) if verbose: print("label classes=\t", label_classes) if_matched = ious_flag.sum(axis=0) != 0 label_classes_last_idx = len(label_classes) - 1 anchor_indices[i] = (ious_flag.argmax(axis=0) - label_classes_last_idx ) * if_matched + label_classes_last_idx anchor_classes[i] = label_classes[anchor_indices[i]] # find indices of the negative anchors neg_indices, = np.where(anchor_classes[i].asnumpy() == -1) # count number of positive/negative/hard negative anchors num_neg_anchors = len(neg_indices) num_pos_anchors = num_priors - num_neg_anchors num_hard_neg_anchors = num_pos_anchors * hard_neg_ratio # hard negative mining #conf_loss_indices = nd.argsort( (-nd.softmax( class_preds[neg_indices] ) )[:,0], is_ascend=False ).astype("int32") conf_loss_indices = nd.argsort((-class_preds[neg_indices])[:, 0], is_ascend=False).astype("int32") neg_indices_sorted = nd.array(neg_indices, ctx=class_preds.context, dtype="int32")[conf_loss_indices] hard_neg_indices = neg_indices_sorted[:num_hard_neg_anchors] anchor_classes[i][hard_neg_indices] = 0 # find indices of the positive anchors pos_indices, = np.where( anchor_indices[i].asnumpy() < label_classes_last_idx) pos_indices = nd.array(pos_indices, ctx=hard_neg_indices.context).astype("int32") cls_indices = nd.concatenate([hard_neg_indices, pos_indices ]) # store indices for classification. classes_mask[i][cls_indices] = 1 if verbose: print("========================================") display( pd.DataFrame(anchor_classes[i].asnumpy()).groupby(0).indices) df = pd.DataFrame( anchor_classes[i].asnumpy()).reset_index().groupby(0).count() df.index.name = "class" df.index = df.index.astype("int32") df.columns = ["number of default anchor boxes"] display(df) print("========================================") # obtain locations of the positve anchors pos_anchors_loc = anchors[0][pos_indices] # obtain indices of the ground truth labels idx_gt = anchor_indices[i][pos_indices] # obtain locations of the ground truth labels labels_loc = label_locs[idx_gt] assert len(pos_anchors_loc) == len(labels_loc) # calculate location differences between ground truth labels and positive anchors shifts_tmp[pos_indices] = loc_difference_calculator( pos_anchors_loc, labels_loc) mask_tmp[pos_indices] = 1. anchor_shifts[i] = shifts_tmp.reshape(-1) box_mask[i] = mask_tmp.reshape(-1) return anchor_shifts, box_mask, anchor_classes, classes_mask
def pose_nms(pose_preds, pose_scores, bbox_preds, bbox_scores, ori_bbox): ''' Parametric Pose NMS algorithm pose_preds: pose locations nd array (n, 17, 2) pose_scores: pose scores nd array (n, 17, 1) bboxes: bbox locations list (n, 4) bbox_scores: bbox scores list (n,) return: pred_coords: pose locations array (n_new, 17, 2) confidence: pose scores array (n_new, 17, 1) ''' np_bbox_preds = np.array(bbox_preds) np_ori_bbox = np.array(ori_bbox) np_bbox_scores = np.array(bbox_scores) pose_preds = pose_preds.asnumpy() pose_scores = pose_scores.asnumpy() pose_scores[pose_scores < scoreThreds] == 1e-5 ori_pose_preds = pose_preds.copy() ori_pose_scores = pose_scores.copy() ori_bbox = np_ori_bbox.copy() final_result = [] pred_coords, confidence, pred_bbox = [], [], [] xmax = np_bbox_preds[:, 2] xmin = np_bbox_preds[:, 0] ymax = np_bbox_preds[:, 3] ymin = np_bbox_preds[:, 1] widths = xmax - xmin heights = ymax - ymin ref_dists = alpha * np.maximum(widths, heights) nsamples = np_bbox_preds.shape[0] human_scores = np.mean(pose_scores, axis=1) + np.max( pose_scores, axis=1) + np_bbox_scores human_ids = np.arange(nsamples) # Do pPose-NMS pick = [] merge_ids = [] while (human_scores.shape[0] != 0): pick_id = np.argmax(human_scores) pick.append(human_ids[pick_id]) # Get numbers of match keypoints by calling PCK_match ref_dist = ref_dists[human_ids[pick_id]] simi = get_parametric_distance(pick_id, pose_preds, pose_scores, ref_dist) num_match_keypoints = PCK_match(pose_preds[pick_id], pose_preds, ref_dist) # Delete humans who have more than matchThreds keypoints overlap and high similarity delete_ids = np.arange( human_scores.shape[0])[(simi > gamma) | (num_match_keypoints >= matchThreds)] if delete_ids.shape[0] == 0: delete_ids = pick_id merge_ids.append(human_ids[delete_ids]) pose_preds = np.delete(pose_preds, delete_ids, axis=0) pose_scores = np.delete(pose_scores, delete_ids, axis=0) human_ids = np.delete(human_ids, delete_ids) human_scores = np.delete(human_scores, delete_ids, axis=0) assert len(merge_ids) == len(pick) preds_pick = ori_pose_preds[pick] scores_pick = ori_pose_scores[pick] ori_bbox_pick = ori_bbox[pick] for j in range(len(pick)): ids = np.arange(17) max_score = np.max(scores_pick[j, ids, 0]) if max_score < scoreThreds: continue # Merge poses merge_id = merge_ids[j] merge_pose, merge_score = p_merge_fast(preds_pick[j], ori_pose_preds[merge_id], ori_pose_scores[merge_id], ref_dists[pick[j]]) max_score = np.max(merge_score[ids]) if max_score < scoreThreds: continue xmax = max(merge_pose[:, 0]) xmin = min(merge_pose[:, 0]) ymax = max(merge_pose[:, 1]) ymin = min(merge_pose[:, 1]) if (1.5**2 * (xmax - xmin) * (ymax - ymin) < 40 * 40): continue pred_coords.append(nd.array(merge_pose[None, :, :])) confidence.append(nd.array(merge_score[None, :, :])) pred_bbox.append(nd.array(ori_bbox_pick[j][None, :])) final_result.append({ 'keypoints': merge_pose, 'kp_score': merge_score, 'proposal_score': np.mean(merge_score) + 1.25 * np.max(merge_score) }) if len(pred_coords) == 0: return None, None, None pred_coords = nd.concatenate(pred_coords) confidence = nd.concatenate(confidence) pred_bbox = nd.concatenate(pred_bbox) return pred_coords, confidence, pred_bbox
def train_model_for_tl(self): """ 训练Triplet Loss模型 :return: 当前模型 """ net_path = os.path.join( DATA_DIR, 'model', 'epoch-24-0.54-20180920182658.params-symbol.json') params_path = os.path.join( DATA_DIR, 'model', 'epoch-24-0.54-20180920182658.params-0024.params') hash_num = 128 # base_net = gluon.nn.SymbolBlock.imports(net_path, ['data'], params_path) base_net = self.get_base_net() with base_net.name_scope(): base_net.output = Dense(units=hash_num) # 全连接层 base_net.output.initialize(Xavier(), ctx=self.ctx) # 初始化 base_net.collect_params().reset_ctx(self.ctx) base_net.hybridize() train_data, train_len = self.get_tl_train_data(self.batch_size) val_data, val_len = self.get_tl_val_data(self.batch_size) self.print_info("Triplet Loss 训练样本数: {}".format(train_len)) self.print_info("Triplet Loss 验证样本数: {}".format(val_len)) triplet_loss = gluon.loss.TripletLoss(margin=10.0) trainer = Trainer(base_net.collect_params(), 'rmsprop', {'learning_rate': 1e-4}) for epoch in range(self.epochs): e_loss, final_i = 0, 0 for i, batch in enumerate(train_data): data, labels = batch[0], batch[1].astype('float32') data = split_and_load(data, ctx_list=self.ctx, batch_axis=0, even_split=False) labels = split_and_load(labels, ctx_list=self.ctx, batch_axis=0, even_split=False) data_loss = [] with autograd.record(): # 梯度求导 for X in data: anchor_ins, pos_ins, neg_ins = [], [], [] for b_X in X: anchor_ins.append(nd.expand_dims(b_X[0], axis=0)) pos_ins.append(nd.expand_dims(b_X[1], axis=0)) neg_ins.append(nd.expand_dims(b_X[2], axis=0)) anchor_ins = nd.concatenate(anchor_ins, axis=0) pos_ins = nd.concatenate(pos_ins, axis=0) neg_ins = nd.concatenate(neg_ins, axis=0) inter1 = base_net(anchor_ins) inter2 = base_net(pos_ins) inter3 = base_net(neg_ins) loss = triplet_loss(inter1, inter2, inter3) # TripletLoss data_loss.append(loss) for l in data_loss: l.backward() curr_loss = np.mean( [mx.nd.mean(loss).asscalar() for loss in data_loss]) self.print_info("batch: {}, loss: {}".format(i, curr_loss)) e_loss += curr_loss final_i = i + 1 trainer.step(self.batch_size) self.print_info("epoch: {}, loss: {}".format( epoch, safe_div(e_loss, final_i))) dist_acc = self.evaluate_net(base_net, val_data) # 评估epoch的性能 self.save_net_and_params(base_net, epoch, dist_acc, name='tripletloss') # 存储网络
def preDataset2(SNR, data, batch_size, shuffle=True, fixed=None, debug=True): dataset, _, RP, keys, fs, T, C, margin, _ = data # Window function dwindow = tukey(fs * T, alpha=1. / 8) data_block, label_block, chiMkeys_block, Mratiokeys_block, datasets, iterator = {}, {}, {}, {}, {}, {} for pre in ['train', 'test']: data_block[pre] = RP(dataset[pre]) # (nsample, C, T*fs) # data_block[pre] = nd.concat(RP(dataset[pre]), RP(dataset[pre]), dim=0) # 3150x1x4096 cpu nd.array if margin != 0.5: # global assert nd.sum( nd.abs(data_block[pre].argmax(-1) - fs // 2) > fs / 10).asscalar() == 0 # Check the peaks nsample = data_block[pre].shape[0] noise, noise_m_gps = Gen_noise( fs, T, C, fixed=fixed) # (4096, C, fs*T) cpu ndarray sigma = data_block[pre].max(axis=-1) / SNR / nd_std(noise[:nsample], axis=-1) signal = nd.divide(data_block[pre], sigma[:, 0].reshape( (nsample, 1, 1))) # taking H1 as leading data_block[pre] = signal + noise[:nsample] # (nsample, C, T*fs) if fixed: noise_m, noise_p_gps = noise, noise_m_gps else: noise_m, noise_p_gps = Gen_noise( fs, T, C, fixed=fixed) # (4096, C, fs*T) cpu ndarray data_block[pre] = nd.concat(data_block[pre], noise_m[:nsample], dim=0) # (nsample, 1, T*fs) cpu nd.array # (nsample, C, T*fs) # Note: use mixed data to gen PSD spsd_block_channel = [] for c in range(C): spsd_block = np.concatenate([ np.real(np.fft.ifft( 1 / np.sqrt(power_vec(i[c].asnumpy(), fs)))).reshape( 1, -1) for i in data_block[pre] ]) # (nsample, T*fs) np.array spsd_block_channel.append( nd.array(spsd_block).expand_dims(1).expand_dims( 1)) # (nsample, 1, 1, T*fs) nd.array cpu spsd_block = nd.concatenate(spsd_block_channel, axis=1) # (nsample, C, 1, T*fs) if debug: logger.debug('spsd_block for {}: {}', pre, spsd_block.shape) # data * dwindow data_block[pre] = (data_block[pre] * nd.array(dwindow)).expand_dims( 2) # (nsample, C, 1, T*fs) nd.array cpu if debug: logger.debug('data_block for {}: {}', pre, data_block[pre].shape) data_block[pre] = nd.concat(data_block[pre].expand_dims(1), spsd_block.expand_dims(1), dim=1) if debug: logger.debug( 'data_block(psd,nd) for {}: {}', pre, data_block[pre].shape) # (nsmaple, 2, C, 1, T*fs) cpu nd.array label_block[pre] = nd.array([1] * nsample + [0] * nsample) chiMkeys_block[pre] = nd.array( getchiM(keys[pre]).tolist() + [0] * nsample) Mratiokeys_block[pre] = nd.array( getMratio(keys[pre]).tolist() + [0] * nsample) datasets[pre] = gluon.data.ArrayDataset(data_block[pre], label_block[pre], chiMkeys_block[pre], Mratiokeys_block[pre]) iterator[pre] = gdata.DataLoader(datasets[pre], batch_size, shuffle=shuffle, last_batch='keep', num_workers=0) if debug: logger.debug('\nNoise from: {} | {}', noise_m_gps[0], noise_p_gps[0]) return dataset, iterator, (noise_m_gps[0] + noise_p_gps[0], np.concatenate((noise_m_gps[1][:nsample], noise_p_gps[1][:nsample]), axis=0))
def fit(self, data_dir_path, model_dir_path, epochs=2, batch_size=64, learning_rate=0.0002, beta1=0.5, extension='.jpg'): config = dict() config['random_input_size'] = self.random_input_size np.save(self.get_config_file_path(model_dir_path), config) img_list = load_images(data_dir_path, extension=extension) img_list = [ img_arr.reshape((1, ) + img_arr.shape) for img_arr in img_list ] train_data = mx.io.NDArrayIter(data=nd.concatenate(img_list), batch_size=batch_size) loss = gluon.loss.SigmoidBinaryCrossEntropyLoss() self.netG, self.netD = self.create_model() self.netG.initialize(mx.init.Normal(0.02), ctx=self.model_ctx) self.netD.initialize(mx.init.Normal(0.02), ctx=self.model_ctx) trainerG = gluon.Trainer(self.netG.collect_params(), 'adam', { 'learning_rate': learning_rate, 'beta1': beta1 }) trainerD = gluon.Trainer(self.netD.collect_params(), 'adam', { 'learning_rate': learning_rate, 'beta1': beta1 }) real_label = nd.ones((batch_size, ), ctx=self.model_ctx) fake_label = nd.zeros((batch_size, ), ctx=self.model_ctx) metric = mx.metric.CustomMetric(facc) logging.basicConfig(level=logging.DEBUG) fake = [] for epoch in range(epochs): tic = time.time() btic = time.time() train_data.reset() iter = 0 for batch in train_data: # Step 1: Update netD data = batch.data[0].as_in_context(self.model_ctx) random_input = nd.random_normal(0, 1, shape=(data.shape[0], self.random_input_size, 1, 1), ctx=self.model_ctx) with autograd.record(): # train with real image output = self.netD(data).reshape((-1, 1)) errD_real = loss(output, real_label) metric.update([ real_label, ], [ output, ]) # train with fake image fake = self.netG(random_input) output = self.netD(fake).reshape((-1, 1)) errD_fake = loss(output, fake_label) errD = errD_real + errD_fake errD.backward() metric.update([ fake_label, ], [ output, ]) trainerD.step(batch.data[0].shape[0]) # Step 2: Update netG with autograd.record(): fake = self.netG(random_input) output = self.netD(fake).reshape((-1, 1)) errG = loss(output, real_label) errG.backward() trainerG.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, 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() 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)) self.checkpoint(model_dir_path) # Visualize one generated image for each epoch fake_img = fake[0] fake_img = ((fake_img.asnumpy().transpose(1, 2, 0) + 1.0) * 127.5).astype(np.uint8) save_image( fake_img, os.path.join(model_dir_path, DCGan.model_name + '-training-') + str(epoch) + '.png')