def dump_result(name, ckpt, image_pack_name=None): if image_pack_name is None: data = None else: data = load_data(image_pack_name.split(',')) outputs = [] gts = [] with get_session() as sess: fcn = FCN(sess=sess, name=name) fcn.load(ckpt) _, _, outputs, gts = fcn.test(scales=[0.5], summary=True, summary_key=123, data=data) result = { 'outputs': np.array(outputs), 'gts': np.array(gts), } pickle.dump( result, open("outputs/%s-%s-%s.pkl" % (name, ckpt, image_pack_name), "wb"))
def eva_model(testfile, nb_class, model_path, model_name, result_path, all_res_file): x, y_true, w2vmat = load_data(testfile, maxlen, nb_class, False, w2v, i2v, w2vdim, w2idic, train=False) if not os.path.isdir(result_path): os.mkdir(result_path) ouf = open(result_path + '/' + model_name + '_score.txt', 'w') model = load_model(model_path + '/' + model_name + '.model') print('Model successfully loaded: {}'.format(model_name)) all_res_file = open(all_res_file, 'a') all_res_file.write(model_name + '\n') y_true = np.argmax(y_true, axis=1) y_pred = np.argmax(model.predict(x), axis=1) res = {} res['Acc'] = round(accuracy_score(y_true=y_true, y_pred=y_pred), 3) res['Precision'] = round(precision_score(y_true=y_true, y_pred=y_pred), 3) res['Recall'] = round(recall_score(y_true=y_true, y_pred=y_pred), 3) res['F-score'] = round(f1_score(y_true=y_true, y_pred=y_pred), 3) print(res) for key in res: string = '{}: {}\t'.format(key, res[key]) ouf.write(string) all_res_file.write(string) ouf.write('\n') all_res_file.write('\n\n')
def test_network(self, summary=False, summary_key=0): records = load_data(['m']) for r in records: scale = 1 a = 1 img = np.clip((r.img / r.img.max()), 0, 1) img = np.power(img, 2.2) img[:, :img.shape[1] // 2:, 0] *= 3 #img = np.pad(img, ((112, 112), (112, 112), (0, 0)), 'constant') if scale != 1.0: img = cv2.resize(img, (0, 0), fx=scale, fy=scale) shape = img.shape[:2] if shape not in self.test_nets: test_net = {} test_net['images'] = tf.placeholder(tf.float32, shape=(None, shape[0], shape[1], 3), name='test_images') with tf.variable_scope("FCN", reuse=True): test_net['pixels'] = FCN.build_branches( test_net['images'], 1.0) self.test_nets[shape] = test_net test_net = self.test_nets[shape] pixels = self.sess.run(test_net['pixels'], feed_dict={ test_net['images']: img[None, :, :, :], }) pixels = pixels[0].astype(np.float32) #pixels = cv2.resize(pixels, image.shape[0:2][::-1]) pixels /= np.linalg.norm(pixels, axis=2)[:, :, None] #pixels = pixels[:,:,::-1] cv2.imshow('pixels', cv2.resize(pixels, (0, 0), fx=10, fy=10)) cv2.imshow('image', cv2.resize(img, (0, 0), fx=0.5, fy=0.5)) cv2.waitKey(0)
def test_input_gamma(name, ckpt, input_gamma, image_pack_name=None, output_filename=None): config_set_input_gamma(float(input_gamma)) if image_pack_name is None: data = None else: data = load_data(image_pack_name.split(',')) with get_session() as sess: fcn = FCN(sess=sess, name=name) fcn.load(ckpt) _, _, _, _, ret = fcn.test(scales=[0.5], summary=True, summary_key=123, data=data) if output_filename is not None: with open('outputs/%s.pkl' % output_filename, 'wb') as f: pickle.dump(ret, f) print ret print 'results dumped'
test_corr = numpy.mean(test_correlations) test_mean = numpy.mean(test_mean) running_time = time.time() - start_time logging.info('test correlation {0:.2f} (mean {1:.2f}), time {2:.2f}s' \ .format(-test_corr, test_mean, running_time)) if __name__ == "__main__": logging.basicConfig(format='%(asctime)-15s %(levelname)s: %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO) # load dataset dataset = './mnist.pkl.gz' datasets = load_data(dataset, shared=True) # set configuration cfg = Config() cfg.set_data_config(datasets) # build model model = ParallelDNN(cfg, datasets) # train train(cfg, model) test(cfg, model) # THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32,force_device=True python ./deep_cca.py
def test(self, summary=False, scales=[1.0], weights=[], summary_key=0, data=None, eval_speed=False, visualize=False): if not TEST_FOLDS: return [0] if data is None: records = load_data(TEST_FOLDS) else: records = data avg_errors = [] median_errors = [] t = time.time() summaries = [] if weights == []: weights = [1.0] * len(scales) outputs = [] ground_truth = [] avg_confidence = [] errors = [] for r in records: all_pixels = [] for scale, weight in zip(scales, weights): img = r.img if scale != 1.0: img = cv2.resize(img, (0, 0), fx=scale, fy=scale) shape = img.shape[:2] if shape not in self.test_nets: aspect_ratio = 1.0 * shape[1] / shape[0] if aspect_ratio < 1: target_shape = (MERGED_IMAGE_SIZE, MERGED_IMAGE_SIZE * aspect_ratio) else: target_shape = (MERGED_IMAGE_SIZE / aspect_ratio, MERGED_IMAGE_SIZE) target_shape = tuple(map(int, target_shape)) test_net = {} test_net['illums'] = tf.placeholder(tf.float32, shape=(None, 3), name='test_illums') test_net['images'] = tf.placeholder(tf.float32, shape=(None, shape[0], shape[1], 3), name='test_images') with tf.variable_scope("FCN", reuse=True): test_net['pixels'] = FCN.build_branches( test_net['images'], 1.0) test_net['est'] = tf.reduce_sum(test_net['pixels'], axis=(1, 2)) test_net['merged'] = get_visualization( test_net['images'], test_net['pixels'], test_net['est'], test_net['illums'], target_shape) self.test_nets[shape] = test_net test_net = self.test_nets[shape] pixels, est, merged = self.sess.run( [test_net['pixels'], test_net['est'], test_net['merged']], feed_dict={ test_net['images']: img[None, :, :, :], test_net['illums']: r.illum[None, :] }) if eval_speed: eval_batch_size = 1 eval_packed_input = img[None, :, :, :].copy() eval_packed_input = np.concatenate( [eval_packed_input for i in range(eval_batch_size)], axis=0) eval_packed_input = np.ascontiguousarray(eval_packed_input) eval_start_t = time.time() print(eval_packed_input.shape) eval_rounds = 100 images_variable = tf.Variable( tf.random_normal(eval_packed_input.shape, dtype=tf.float32, stddev=1e-1)) print(images_variable) for eval_t in range(eval_rounds): print(eval_t) pixels, est = self.sess.run( [test_net['pixels'], test_net['est']], feed_dict={ test_net['images']: #images_variable, eval_packed_input, }) eval_elapsed_t = time.time() - eval_start_t print('per image evaluation time', eval_elapsed_t / (eval_rounds * eval_batch_size)) pixels = pixels[0] #est = est[0] merged = merged[0] all_pixels.append(weight * pixels.reshape(-1, 3)) all_pixels = np.sum(np.concatenate(all_pixels, axis=0), axis=0) est = all_pixels / (np.linalg.norm(all_pixels) + 1e-7) outputs.append(est) ground_truth.append(r.illum) error = math.degrees(angular_error(est, r.illum)) errors.append(error) avg_confidence.append(np.mean(np.linalg.norm(all_pixels))) summaries.append((r.fn, error, merged)) print("Full Image:") ret = print_angular_errors(errors) ppt = (time.time() - t) / len(records) print('Test time:', time.time() - t, 'per image:', ppt) if summary: for fn, error, merged in summaries: folder = self.get_ckpt_folder() + '/test%04dsummaries_%4f/' % ( summary_key, scale) try: os.mkdir(folder) except: pass summary_fn = '%s/%5.3f-%s.png' % (folder, error, fn) cv2.imwrite(summary_fn, merged[:, :, ::-1] * 255) if visualize: for fn, error, merged in summaries: cv2.imshow('Testing', merged[:, :, ::-1]) cv2.waitKey(0) return errors, ppt, outputs, ground_truth, ret, avg_confidence
args.input_dir = os.path.normpath(args.input_dir) len_input_dir = len(args.input_dir) assert os.path.exists(args.input_dir), "Input directory not found" input_glob = os.path.join(args.input_dir, args.input_pattern) files = pc_io.get_files(input_glob) assert len(files) > 0, "No input files found" filenames = [x[len_input_dir + 1:] for x in files] output_files = [ os.path.join(args.output_dir, x + '.bin') for x in filenames ] output_infs = [ os.path.join(args.output_dir, x + '.inf.bin') for x in filenames ] pcQueue_512, pcQueue_1024, pcQueue_2048 = data_provider.load_data( args.input_dir, args.source_extension) centroid_list = [] furthest_distance_list = [] meta_matrix, nor_pc_512, nor_pc_1024, nor_pc_2048 = data_provider.gen_meta( centroid_list, furthest_distance_list, pcQueue_512, pcQueue_1024, pcQueue_2048) compressed_bytes = fpzip.compress(meta_matrix.astype(np.float32), precision=0, order='C') with open(output_infs[0], 'wb') as f: f.write(compressed_bytes) f.close() def patch_compress(points, model, checkpoint): estimator = tf.estimator.Estimator(model_fn=model.model_fn,
#clear dir shutil.rmtree(directory, ignore_errors=True) #create dir try: os.mkdir(directory) except OSError as e: print("Couldn't create directory {0}, {1}".format(directory, e)) #save ouputs in new dir i = 0 for m in mix: i += 1 file_name = ("{0:02d}. {1}.mp3").format(i, m[0]) song_path = os.path.join(directory, file_name) song = m[1] #, tags={'artist': 'Various artists', 'album': 'Best of 2011', 'comments': 'This album is awesome!'}) song.export(song_path, format="mp3", tags={'album': set_name, '#': i}) print(file_name) ds = data_provider.load_data('/home/wojtek/VBoxShared/Mixes') for data in ds: mix = split_audio(*data[:2]) set_name = data[2] root = data[3] save_outputs(root, set_name, mix)
if __name__ == '__main__': parser = setup_arguments() args = parser.parse_args() # model_info = describe_arguments(args) from data_provider import filter_by_user_info, get_solo_only, \ get_data_last_only, map_user_tasks, extract_data, calc_velocity, extract_simple_features, extract_data_distance, \ load_data from training import train_model, train_simple_model np.random.seed(args.seed) random.seed(args.seed) user_info, data_nc_with_km_sr = load_data() users_tasks, _ = map_user_tasks(data_nc_with_km_sr, user_info) pre_train_time = time.time() if args.only_solo: data_nc_with_km_sr_solo = get_solo_only(data_nc_with_km_sr) data_nc_with_km_sr_solo_filtered = filter_by_user_info( user_info, data_nc_with_km_sr_solo, users_tasks) dfs = data_nc_with_km_sr_solo_filtered train_data_km_solo = extract_data(data_nc_with_km_sr_solo_filtered, users_tasks, user_info, args.max_events, args.min_events, args.standardize, args.normalize, args.reset_origin, args.norm_time) data = train_data_km_solo
def eva_model(train_split_file, nb_class, model_path, model_name, result_path, rel_dic): x, x_w, x_jcd, x_med, y, c2vmat, w2vmat = load_data(train_split_file, maxlen, nb_class, rel_dic, mode, input_num, False, w2v, ci2v, wi2v, w2vdim, w2idic, c2idic, info, train=True) model = load_model(model_path + '/' + model_name + '.model') print('Model successfully loaded: {}'.format(model_name)) time_start = time.time() if mode == 'charword': res = model.evaluate([x[0], x_w[0]], y, batch_size=batch_size) else: res = model.evaluate(x, y, batch_size=batch_size) time_end = time.time() print('Average time cost per sample: ', 1000 * (time_end - time_start) / len(y), 'ms') print('Loss and acc: ', res) if mode == 'charword': pred = model.predict([x[0], x_w[0]]) else: pred = model.predict(x) y_true = np.argmax(y, axis=1) y_pred = np.argmax(pred, axis=1) f_score = round(f1_score(y_true=y_true, y_pred=y_pred, average='macro'), 4) print('fscore:', f_score) n = 0 num_top1, num_top3, num_topN = 0, 0, 0 err_top1, err_top3, err_topN = [], [], [] real_lab = defaultdict(int) err_mat = defaultdict(int) rel_dic_rev = dict(zip(rel_dic.values(), rel_dic.keys())) if not os.path.isdir(result_path): os.mkdir(result_path) with open(train_split_file, 'r') as inf, open(result_path + '/' + model_name + '_score.txt', 'w') as ouf1,\ open(result_path + '/' + model_name + '_matrix.txt', 'w') as ouf2: ouf1.write('\t'.join( ['Sentence', 'True_label', 'Pred_label', 'Score', 'Correct']) + '\n') for line in inf: line = line.strip('\n').split('\t')[1:] q, l, pr = line[0], rel_dic[line[1]], pred[n] n += 1 real_lab[line[1]] += 1 if l != np.argmax(pr): cor = 0 else: cor = 1 pr_dic = dict(zip([rel_dic_rev[i] for i in range(len(pr))], pr)) pr_top = sorted(pr_dic.items(), key=operator.itemgetter(1), reverse=True)[0] ouf1.write( '\t'.join([q, line[1], pr_top[0], str(pr_top[1]), str(cor)]) + '\n') if l != np.argmax(pr): err_top1.append(line[1]) err_mat[(line[1], str(pr_top[0]))] += 1 err_mat = sorted(err_mat.items(), key=operator.itemgetter(1), reverse=True) ouf2.write( '\t'.join(['True_label', 'Pred_label', 'Err_count', 'Err_ratio']) + '\n') for pair, count in err_mat: ouf2.write('\t'.join([ pair[0], pair[1], str(count), str(count / Counter(err_top1)[pair[0]]) ]) + '\n') err_top1 = sorted(Counter(err_top1).items(), key=operator.itemgetter(1), reverse=True) ouf2.write( '\n' + '\t'.join(['True_label', 'Err_count', 'All_count', 'Accuracy']) + '\n') for rela, count in err_top1: ouf2.write('\t'.join([ rela, str(count), str(real_lab[rela]), str(1 - count / real_lab[rela]) ]) + '\n') ouf2.write('\n' + 'Overall Accuracy:' + '\t' + str(res[1]))
def train_model(nb_class, trainfile, valfile, model_path, model_name, epoch): x, y, w2vmat = load_data(trainfile, maxlen, nb_class, shuffle, w2v, i2v, w2vdim, w2idic, train=True) if valfile: x_v, y_v, w2vmat_v = load_data(valfile, maxlen, nb_class, shuffle, w2v, i2v, w2vdim, w2idic, train=True) val = [x_v, y_v] else: val = None print('Building base model: {}'.format(model_name)) model = model_structure.create_model(model_name, model_type, nb_class, nb_filter, kernel_size, vocab_size, maxlen, denseuni, dropout, l2, lr, w2v, w2vdim, w2vmat) plot_model(model, show_shapes=True, to_file='model_diagram/' + model_name + '.png') if not os.path.isdir(model_path): os.mkdir(model_path) checkpoint = ModelCheckpoint(model_path + '/' + model_name + '.model', monitor=monitor, verbose=1, save_weights_only=False, save_best_only=True, mode='auto') earlystop = EarlyStopping(monitor=monitor, patience=patience, verbose=1, mode='auto') print('Begin training model: {}'.format(model_name)) history = model.fit(x, y, validation_data=val, batch_size=batch_size, epochs=epoch, callbacks=[checkpoint, earlystop], validation_split=split, class_weight=get_class_weights(y, smooth_factor), verbose=2) print('Model successfully trained: {}'.format(model_name)) return model, history
def train_model(gpu, input_num, nb_class, rel_dic, trainfile, valfile, model_path, model_name, epoch): x, x_w, x_jcd, x_med, y, c2vmat, w2vmat = load_data(trainfile, maxlen, nb_class, rel_dic, mode, input_num, shuffle, w2v, ci2v, wi2v, w2vdim, w2idic, c2idic, info, train=True) if valfile: x_v, x_w_v, x_jcd_v, x_med_v, y_v, c2vmat_v, w2vmat_v = load_data( valfile, maxlen, nb_class, rel_dic, mode, input_num, shuffle, w2v, ci2v, wi2v, w2vdim, w2idic, c2idic, info, train=True) val = [x_v, y_v] else: val = None print('Building base model: {}'.format(model_name)) model = multi_cgru_keras.creat_model(gpu, model_name, mode, nb_class, nb_filter, wsize, maxlen, cvsize, wvsize, denseuni, cnn_dropout, l2, lr, w2v, w2vdim, c2vmat, w2vmat) plot_model(model, show_shapes=True, to_file='model_cgru_cw.png') if not os.path.isdir(model_path): os.mkdir(model_path) checkpoint = ModelCheckpoint(model_path + '/' + model_name + '.model', monitor=monitor, verbose=1, save_weights_only=False, save_best_only=True, mode='auto') earlystop = EarlyStopping(monitor=monitor, patience=patience, verbose=1, mode='auto') print('Begin training model: {}'.format(model_name)) if mode == 'charword': history = model.fit([x[0], x_w[0]], y, validation_data=val, batch_size=batch_size, epochs=epoch, callbacks=[checkpoint, earlystop], validation_split=split, class_weight=get_class_weights(y, smooth_factor)) else: print(x[0][0]) history = model.fit(x, y, validation_data=val, batch_size=batch_size, epochs=epoch, callbacks=[checkpoint, earlystop], validation_split=split, class_weight=get_class_weights(y, smooth_factor)) print('Model successfully trained: {}'.format(model_name)) return model, history