def main(): phone_res = (100, 100) camera_res = (100, 100) num_images_per_step = 100 data_generator = datagen.DataGenerator(train_data_folder, phone, phone_res, camera_res, batch_size=30, training=True) main_model = model.WESPE(phone_res, camera_res) epochs = 110 test_generator = datagen.DataGenerator(test_data_folder, phone, phone_res, camera_res) train_data = [] test_data = [] for j in range(epochs): print('Epoch_' + str(j + 1) + '/' + str(epochs)) data_generator.on_epoch_end() data_list = tqdm.tqdm( range(min(num_images_per_step, len(data_generator)))) try: epoch_data = [] for i in data_list: x, y, y_coupled = data_generator[i] losses, y_generated = main_model.train_step(x, y) losses['avg_psnr'], losses['avg_ssim'] = compare_imgs( postprocess(y_generated.numpy()), postprocess(y_coupled)) epoch_data.append(losses) data_list.set_description(str(losses)) data_list.refresh() time.sleep(0.01) train_data.append(epoch_data) if j % 2 == 0: epoch_data = {} for i in tqdm.tqdm(range(len(data_generator))): x, _, _ = data_generator[i] for j in range(len(x)): cv2.imwrite( './drive/My Drive/dataset/dped/org' + str(i + j) + '.jpg', postprocess(x[j])) img = main_model.predict(x).numpy() for j in range(len(x)): cv2.imwrite( './drive/My Drive/dataset/dped/pred' + str(i + j) + '.jpg', postprocess(img[j])) epoch_data['avg_psnr'], epoch_data[ 'avg_ssim'] = compare_imgs(postprocess(img), postprocess(x)) test_data.append(epoch_data) with open('data.pkl', 'wb') as file: pickle.dump((train_data, test_data), file) except Exception as e: print(str(e))
def __init__(self, tblcnt, columncnt): self.tblcnt = tblcnt self.columncnt = columncnt for i in range(self.tblcnt): datatypes = "" keycolumn = "" typearray = [] tblname = tname[i] getoption = OptSelection(random.choice(keytype)) getvalue = getoption.getMyextra() for j in range(self.columncnt): typeval = random.choice(datatype) typearray.append(typeval) if typeval == "char" or typeval == "varchar": typeval = typeval + " (" + format( random.choice(charcnt)) + ")" datatypes += cname[j] + " " + typeval + ", " for k in range(random.randint(1, columncnt)): keycolumn += cname[k] + "," keycolumn = keycolumn[:-1] print("CREATE TABLE IF NOT EXISTS " + tblname + "( " + datatypes + " " + getvalue + " (" + keycolumn + ") );") for i in range(10): datavalue = "" for typeval in typearray: dvalue = datagen.DataGenerator(typeval) datavalue += "'" + dvalue.getData() + "', " datavalue = datavalue[:-2] print("INSERT INTO " + tblname + " values (" + datavalue + ");")
def get_val_data(working_dir, get_sound=False): print("loading validation data from '%s'" % working_dir) _, _, _, partition, _ = utils.load_data(working_dir=working_dir) validation_ids = partition['validation'] total_num_samples = len(validation_ids) print("Number of val instances: %s" % total_num_samples) val_data_generator = datagen.DataGenerator(working_dir=working_dir) if get_sound: (val_instances_mat, val_queries_mat), val_labels_mat = ( val_data_generator.get_sound_samples(validation_ids) ) else: (val_instances_mat, val_queries_mat), val_labels_mat = ( val_data_generator.get_samples(validation_ids) ) y_true = np.argmax(val_labels_mat, axis=1) print("Label counts:") labels, counts = np.unique(y_true, return_counts=True) print(labels) print(counts) total_num_queries = sum(counts) print("total: %s" % total_num_queries) queries_per_sample = total_num_queries / total_num_samples print("Average queries per sample: %s" % queries_per_sample) return val_instances_mat, val_queries_mat, y_true
def train(model_name): keras.backend.clear_session() model = get_model() inp = model.input # input placeholder outputs = [(layer.input, layer.output) for layer in model.layers] # all layer outputs print('\n'.join(map(str, outputs))) train_generator = datagen.DataGenerator(constants.TRAIN_PROCESSED_DIR, constants.SEQUENCE_SIZE, constants.BATCH_SIZE, constants.CONTEXT_WINDOW_SIZE, 'x_[0-9]+.npy', 'y_[0-9]+.npy') model.fit_generator(generator=train_generator.__getitem__(), use_multiprocessing=False, epochs=constants.EPOCHS, steps_per_epoch=train_generator.__len__()) model.save(model_name)
print("Number of training/validation steps per epoch: %d/%d" % (training_steps_per_epoch, validation_steps_per_epoch)) # In[ ]: import models optimizer = RMSprop(learning_rate) model = models.unet((256, 256, 4), 8, optimizer, loss) #model.summary() # In[ ]: import datagen training_generator = datagen.DataGenerator(training_patches, batch_size, training_steps_per_epoch, 256, 256, 4) validation_generator = datagen.DataGenerator(validation_patches, batch_size, validation_steps_per_epoch, 256, 256, 4) # In[ ]: model_checkpoint_callback = ModelCheckpoint(os.path.join( log_dir, "model_{epoch:02d}.h5"), verbose=verbose, save_best_only=True, save_weights_only=False, period=1) results = model.fit_generator(
dim_embed=100, dim1=vsize, dim2=vsize, dim3=vsize / 2, class_size=kind) else: print "net_arch error" return learner pro_no = range(1, 5) + range(6, 16) #[13,14,15]#range(4,16) vec_size = [400, 600] net_arch = ["sp2", "simple", "bigram"] for pno in pro_no: data = datagen.DataGenerator('../on-line/' + str(pno) + '.spice.train') test_data = TestDataGenerator( data.kind, '../on-line/prefixes/' + str(pno) + '.spice.prefix.public', '../on-line/targets/' + str(pno) + '.spice.target.public') for vsize, arch in ite.product(vec_size, net_arch): model_names_old = glob.glob('%s/model_45_%d_%s_????_????.hdf5' % (str(pno).zfill(2), vsize, arch)) model_names_new = glob.glob('../%s/model_45_%d_%s_????_????.hdf5' % (str(pno).zfill(2), vsize, arch)) model_names = model_names_old + model_names_new if len(model_names) == 0: print "glob error:model_final_p_" + str(pno).zfill(2) + "_*.hdf5" print model_names else: print len(model_names), '×', model_names[0][:-15]
def plot_amplitude_phase_meas_retreival(retrieved_obj, title, plot_spherical_aperture=False, ACTUAL=False, m_index=None, mask=False): if ACTUAL: RETRIEVED = "ACTUAL" RECONSTRUCTED = "ACTUAL" else: RETRIEVED = "retrieved" RECONSTRUCTED = "reconstructed" # coefficients and scale if 'coefficients' in retrieved_obj.keys(): retrieved_obj['coefficients'] = np.squeeze( retrieved_obj['coefficients']) assert len(np.shape(retrieved_obj['coefficients'])) == 1 retrieved_obj['scale'] = np.squeeze(retrieved_obj['scale']) assert len(np.shape(retrieved_obj['scale'])) == 0 # get axes for retrieved object and diffraction pattern N = np.shape(np.squeeze(retrieved_obj['measured_pattern']))[0] simulation_axes, amplitude_mask = get_amplitude_mask_and_imagesize( N, int(params.params.wf_ratio * N)) # normalize complex retrieved retrieved_complex_normalized = retrieved_obj[ 'real_output'] + 1j * retrieved_obj['imag_output'] retrieved_complex_normalized *= 1 / (np.max( np.abs(retrieved_complex_normalized))) retrieved_obj['real_output'] = np.real(retrieved_complex_normalized) retrieved_obj['imag_output'] = np.imag(retrieved_complex_normalized) # object x = simulation_axes['object']['x'] # meters x *= 1e6 f = simulation_axes['diffraction_plane']['f'] # 1/meters f *= 1e-6 fig = plt.figure(figsize=(10, 10)) # fig.subplots_adjust(wspace=0.5, left=0.5, top=0.95, bottom=0.10) fig.subplots_adjust(wspace=0.1, left=0.3) gs = fig.add_gridspec(4, 2) fig.text(0.5, 0.95, title, ha="center", size=15) # run the constructor to get z n, m vector datagenerator = datagen.DataGenerator(1024, 256) if 'coefficients' in retrieved_obj.keys(): fig.text(0.05, 0.9, 'Zernike Coefficients:', size=20, color='red') c_str = "" for _c, _z in zip(retrieved_obj['coefficients'], datagenerator.zernike_cvector): c_str += r"$Z^{" + str(_z.m) + "}_{" + str(_z.n) + "}$" c_str += " " c_str += "%.2f" % _c + '\n' fig.text(0.03, 0.85, c_str, ha='left', va='top', size=20) fig.text(0.05, 0.15, 'Scale:', size=20, color='red') fig.text(0.03, 0.10, 'S:' + "%.2f" % retrieved_obj['scale'], ha='left', va='top', size=20) axes = {} axes["measured"] = fig.add_subplot(gs[0, 0]) axes["reconstructed"] = fig.add_subplot(gs[0, 1]) axes["real"] = fig.add_subplot(gs[1, 0]) axes["imag"] = fig.add_subplot(gs[1, 1]) axes["intensity"] = fig.add_subplot(gs[2, 0]) axes["phase"] = fig.add_subplot(gs[2, 1]) axes["phase_vertical"] = fig.add_subplot(gs[3, 0]) axes["phase_horizontal"] = fig.add_subplot(gs[3, 1]) # calculate the intensity complex_obj = np.squeeze(retrieved_obj["real_output"]) + 1j * np.squeeze( retrieved_obj["imag_output"]) I = np.abs(complex_obj)**2 # calculate the phase # subtract phase at intensity peak if not m_index: m_index = unravel_index(I.argmax(), I.shape) phase_Imax = np.angle(complex_obj[m_index[0], m_index[1]]) complex_obj *= np.exp(-1j * phase_Imax) obj_phase = np.angle(complex_obj) # not using the amplitude_mask, use the absolute value of the intensity nonzero_intensity = np.array(np.abs(complex_obj)) nonzero_intensity[nonzero_intensity < 0.01 * np.max(nonzero_intensity)] = 0 nonzero_intensity[nonzero_intensity >= 0.01 * np.max(nonzero_intensity)] = 1 obj_phase *= nonzero_intensity # for testing # obj_phase[10:20, :] = np.max(obj_phase) # obj_phase[:, 10:20] = np.max(obj_phase) # obj_phase[:, -30:-20] = np.max(obj_phase) if mask: obj_phase_softmask = np.array(obj_phase) obj_phase_softmask[amplitude_mask > 0] *= 0.7 im = axes["phase"].pcolormesh(x, x, obj_phase_softmask, vmin=-np.pi, vmax=np.pi, cmap='jet') else: im = axes["phase"].pcolormesh(x, x, obj_phase, vmin=-np.pi, vmax=np.pi, cmap='jet') axes["phase"].text(0.2, 0.9, "phase(" + RETRIEVED + ")", fontsize=10, ha='center', transform=axes["phase"].transAxes, backgroundcolor="cyan") fig.colorbar(im, ax=axes["phase"]) axes["phase"].axvline(x=x[m_index[1]], color="red", alpha=0.8) axes["phase"].axhline(y=x[m_index[0]], color="blue", alpha=0.8) axes["phase_horizontal"].plot(x, obj_phase[m_index[0], :], color="blue") axes["phase_horizontal"].set_ylim(-np.pi, np.pi) axes["phase_horizontal"].text(0.2, -0.25, "phase(horizontal)", fontsize=10, ha='center', transform=axes["phase_horizontal"].transAxes, backgroundcolor="blue") axes["phase_vertical"].plot(x, obj_phase[:, m_index[1]], color="red") axes["phase_vertical"].set_ylim(-np.pi, np.pi) axes["phase_vertical"].text(0.2, -0.25, "phase(vertical)", fontsize=10, ha='center', transform=axes["phase_vertical"].transAxes, backgroundcolor="red") if mask: I_softmask = np.array(I) I_softmask[amplitude_mask > 0] *= 0.7 im = axes["intensity"].pcolormesh(x, x, I_softmask, vmin=0.0, vmax=1.0, cmap='jet') else: im = axes["intensity"].pcolormesh(x, x, I, vmin=0, vmax=1.0, cmap='jet') # plot the spherical aperture if plot_spherical_aperture: # circle to show where the wavefront originates circle = plt.Circle((0, 0), 2.7, color='r', fill=False, linewidth=2.0) axes["intensity"].add_artist(circle) axes["intensity"].text(0.8, 0.7, "Spherical\nAperture\n2.7 um", fontsize=10, ha='center', transform=axes["intensity"].transAxes, color="red") axes["intensity"].text(0.2, 0.9, "intensity(" + RETRIEVED + ")", fontsize=10, ha='center', transform=axes["intensity"].transAxes, backgroundcolor="cyan") axes["intensity"].set_ylabel("position [um]") fig.colorbar(im, ax=axes["intensity"]) # plt.figure(13); plt.pcolormesh(np.squeeze(retrieved_obj["measured_pattern"]));plt.savefig('test.png') # import ipdb; ipdb.set_trace() # BREAKPOINT # print("BREAKPOINT") im = axes["measured"].pcolormesh( f, f, np.log(np.squeeze(retrieved_obj["measured_pattern"])), vmin=-10, vmax=0, cmap='jet') # axes["measured"].set_ylim(-0.25,0.25);axes["measured"].set_xlim(-0.25,0.25) axes["measured"].set_ylabel(r"frequency [1/m]$\cdot 10^{6}$") axes["measured"].text(0.2, 0.9, "measured", fontsize=10, ha='center', transform=axes["measured"].transAxes, backgroundcolor="cyan") fig.colorbar(im, ax=axes["measured"]) im = axes["reconstructed"].pcolormesh( f, f, np.log(np.squeeze(retrieved_obj["tf_reconstructed_diff"])), vmin=-10, vmax=0, cmap='jet') # axes["reconstructed"].set_ylim(-0.25,0.25);axes["reconstructed"].set_xlim(-0.25,0.25) axes["reconstructed"].text(0.2, 0.9, RECONSTRUCTED, fontsize=10, ha='center', transform=axes["reconstructed"].transAxes, backgroundcolor="cyan") # calc mse A = retrieved_obj["measured_pattern"].reshape(-1) B = retrieved_obj["tf_reconstructed_diff"].reshape(-1) mse = (np.square(A - B)).mean() mse = str(mse) axes["reconstructed"].text(0.2, 1.1, "mse(" + RECONSTRUCTED + ", measured): " + mse, fontsize=10, ha='center', transform=axes["reconstructed"].transAxes, backgroundcolor="cyan") fig.colorbar(im, ax=axes["reconstructed"]) if mask: real_output_softmask = np.array( np.squeeze(retrieved_obj["real_output"])) real_output_softmask[amplitude_mask > 0] *= 0.7 im = axes["real"].pcolormesh(x, x, real_output_softmask, vmin=-1.0, vmax=1.0, cmap='jet') else: im = axes["real"].pcolormesh(x, x, np.squeeze(retrieved_obj["real_output"]), vmin=-1.0, vmax=1.0, cmap='jet') axes["real"].text(0.2, 0.9, "real(" + RETRIEVED + ")", fontsize=10, ha='center', transform=axes["real"].transAxes, backgroundcolor="cyan") axes["real"].set_ylabel("position [um]") fig.colorbar(im, ax=axes["real"]) if mask: imag_output_softmask = np.array( np.squeeze(retrieved_obj["imag_output"])) imag_output_softmask[amplitude_mask > 0] *= 0.7 im = axes["imag"].pcolormesh(x, x, imag_output_softmask, vmin=-1.0, vmax=1.0, cmap='jet') else: im = axes["imag"].pcolormesh(x, x, np.squeeze(retrieved_obj["imag_output"]), vmin=-1.0, vmax=1.0, cmap='jet') axes["imag"].text(0.2, 0.9, "imag(" + RETRIEVED + ")", fontsize=10, ha='center', transform=axes["imag"].transAxes, backgroundcolor="cyan") fig.colorbar(im, ax=axes["imag"]) return fig
def main(): prog_name = sys.argv[0] args = do_args(sys.argv[1:], prog_name) verbose = args.verbose output = args.output name = args.name data_dir = args.data_dir training_states = args.training_states validation_states = args.validation_states superres_states = args.superres_states num_epochs = args.epochs model_type = args.model_type batch_size = args.batch_size learning_rate = args.learning_rate time_budget = args.time_budget loss = args.loss do_color_aug = args.color do_superres = loss == "superres" log_dir = os.path.join(output, name) assert os.path.exists(log_dir), "Output directory doesn't exist" f = open(os.path.join(log_dir, "args.txt"), "w") for k, v in args.__dict__.items(): f.write("%s,%s\n" % (str(k), str(v))) f.close() print("Starting %s at %s" % (prog_name, str(datetime.datetime.now()))) start_time = float(time.time()) #------------------------------ # Step 1, load data #------------------------------ training_patches = [] for state in training_states: print("Adding training patches from %s" % (state)) fn = os.path.join(data_dir, "%s_extended-train_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: training_patches.append((os.path.join(data_dir, fn), state)) validation_patches = [] for state in validation_states: print("Adding validation patches from %s" % (state)) fn = os.path.join(data_dir, "%s_extended-val_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: validation_patches.append((os.path.join(data_dir, fn), state)) print("Loaded %d training patches and %d validation patches" % (len(training_patches), len(validation_patches))) if do_superres: print("Using %d states in superres loss:" % (len(superres_states))) print(superres_states) #------------------------------ # Step 2, run experiment #------------------------------ #training_steps_per_epoch = len(training_patches) // batch_size #validation_steps_per_epoch = len(validation_patches) // batch_size training_steps_per_epoch = 300 validation_steps_per_epoch = 39 print("Number of training/validation steps per epoch: %d/%d" % (training_steps_per_epoch, validation_steps_per_epoch)) # Build the model optimizer = RMSprop(learning_rate) if model_type == "unet": model = models.unet((240, 240, 4), 5, optimizer, loss) elif model_type == "unet_large": model = models.unet_large((240, 240, 4), 5, optimizer, loss) elif model_type == "fcdensenet": model = models.fcdensenet((240, 240, 4), 5, optimizer, loss) elif model_type == "fcn_small": model = models.fcn_small((240, 240, 4), 5, optimizer, loss) model.summary() validation_callback = utils.LandcoverResults(log_dir=log_dir, time_budget=time_budget, verbose=verbose) learning_rate_callback = LearningRateScheduler(utils.schedule_stepped, verbose=verbose) model_checkpoint_callback = ModelCheckpoint(os.path.join( log_dir, "model_{epoch:02d}.h5"), verbose=verbose, save_best_only=False, save_weights_only=False, period=20) training_generator = datagen.DataGenerator( training_patches, batch_size, training_steps_per_epoch, 240, 240, 4, do_color_aug=do_color_aug, do_superres=do_superres, superres_only_states=superres_states) validation_generator = datagen.DataGenerator(validation_patches, batch_size, validation_steps_per_epoch, 240, 240, 4, do_color_aug=do_color_aug, do_superres=do_superres, superres_only_states=[]) model.fit_generator( training_generator, steps_per_epoch=training_steps_per_epoch, #epochs=10**6, epochs=num_epochs, verbose=verbose, validation_data=validation_generator, validation_steps=validation_steps_per_epoch, max_queue_size=256, workers=4, use_multiprocessing=True, callbacks=[ validation_callback, #learning_rate_callback, model_checkpoint_callback ], initial_epoch=0) #------------------------------ # Step 3, save models #------------------------------ model.save(os.path.join(log_dir, "final_model.h5")) model_json = model.to_json() with open(os.path.join(log_dir, "final_model.json"), "w") as json_file: json_file.write(model_json) model.save_weights(os.path.join(log_dir, "final_model_weights.h5")) print("Finished in %0.4f seconds" % (time.time() - start_time)) del model, training_generator, validation_generator
im=ax.pcolormesh(x,x,phase,vmin=-np.pi,vmax=np.pi,cmap='jet') ax.yaxis.set_ticks_position('right'); ax.yaxis.set_label_position('right') if not i==1: ax.yaxis.set_ticks([]) else:ax.set_ylabel(("position [um]")) ax.xaxis.set_ticks([]) ax.text(0.05,0.95,name+'Phase',transform=ax.transAxes,color='black',weight='bold',va='top') place_colorbar(im,ax,offsetx=0.015,offsety=0.005,ticks=[-3.14,0,3.14],color='black',labels=['-pi','0','+pi']) # draw zernike coefficients coefficients=np.squeeze(files['out_'+_ct]['actual']['coefficients']); assert len(np.shape(coefficients))==1 scale=np.squeeze(files['out_'+_ct]['actual']['scale']); assert len(np.shape(scale))==0 fig.text(0.05,0.34,'Zernike Coefficients:',size=20,color='red') c_str="" for _i, _c, _z in zip(range(len(coefficients)), coefficients, datagen.DataGenerator(1024,256).zernike_cvector): c_str += '\n' if (_i%3==0) else ' ' c_str += r"$Z^{"+str(_z.m)+"}_{"+str(_z.n)+"}$" c_str+=" " c_str += "%.2f"%_c # c_str+="%.2f"%_c+'\n' fig.text(0.03,0.34,c_str,ha='left',va='top',size=20) fig.text(0.05,0.07,'Scale:',size=20,color='red') fig.text(0.03,0.05,'S:'+"%.2f"%scale,ha='left',va='top',size=20) fig.savefig('./wfs_'+str(args.wfsensor)+'_iterative_nn_compared_noise_'+_ct+'.png')
def run_experiments(num_experiments=10, models_dir=None): """ Args: num_experiments (int): how many separate models to train models_dir (str): if a path to a directory is given, save each model there To load: custom_objects = {'PositionEncode': juliet_memnet.PositionEncode} mod = keras.models.load_model(path, custom_objects=custom_objects) """ # get train params steps_per_epoch = data_generator.get_num_batches(len(partition['train'])) validation_steps = data_generator.get_num_batches( len(partition['validation'])) # get validation data val_data_generator = datagen.DataGenerator(batch_size=1000, working_dir=working_dir) (val_instances_mat, val_queries_mat), val_labels_mat = next( val_data_generator.generate_balanced(partition['validation'])) y_true = np.argmax(val_labels_mat, axis=1) cnf_matrices = np.zeros((num_experiments, num_classes, num_classes)) for experiment_num in range(num_experiments): print("=====Beginning experiment %s of %s=====" % (experiment_num + 1, num_experiments)) # get untrained model model = juliet_memnet.get_model() model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.001)) # train model.fit_generator(data_generator.generate_balanced( partition['train']), steps_per_epoch=steps_per_epoch, validation_data=data_generator.generate_balanced( partition['validation']), validation_steps=validation_steps, epochs=30) # predict predics = model.predict([val_instances_mat, val_queries_mat]) predics = np.argmax(predics, axis=1) # metrics cnf_matrix = sklearn.metrics.confusion_matrix(y_true, predics) print(cnf_matrix) cnf_matrices[experiment_num] = cnf_matrix # save model if models_dir: if not os.path.isdir(models_dir): print("Invalid models directory '{}', could not save " "model".format(models_dir)) else: fname = "model_{}.h5".format(experiment_num) path = os.path.join(models_dir, fname) print(path) model.save(path) print("Confusion matrix mean:") print(np.mean(cnf_matrices, axis=0)) print("Confusion matrix standard deviation:") print(np.std(cnf_matrices, axis=0))
import constants import datagen import utils import juliet_memnet # other options: constants.WORKING_DIR_CHOI_DATA # constants.WORKING_DIR_JULIET_DATA working_dir = constants.WORKING_DIR_SA_DATA instances_mat, labels_mat, _, partition, _ = utils.load_data( working_dir=working_dir) _, max_numlines, _ = instances_mat.shape data_generator = datagen.DataGenerator(batch_size=36, working_dir=working_dir) num_classes = data_generator.num_classes def run_experiments(num_experiments=10, models_dir=None): """ Args: num_experiments (int): how many separate models to train models_dir (str): if a path to a directory is given, save each model there To load: custom_objects = {'PositionEncode': juliet_memnet.PositionEncode} mod = keras.models.load_model(path, custom_objects=custom_objects) """
def get_memnet_predics(working_dir, models_dir, fnames=None, line_num=None): """Get memory network predictions Args: working_dir (str): path to working dir with data in .npy files models_dir (str): path to models dir with models in .h5 files fnames (str or list of str): filenames to get predictions from if None, then get them for all validation files line_num (int): line number to predict if None, then get predictions for all lines """ inst, lab, _, part, paths = utils.load_data(working_dir) models = get_models(models_dir) if fnames is None: fnames = [paths[idx] for idx in part['validation']] elif isinstance(fnames, str): fnames = [fnames] elif not isinstance(fnames, list): raise ValueError("fnames must be str, list, or None") if line_num is not None: # -1 for line numbers starting at 1 # -1 for excluding the #include line_num = line_num - 2 val_data_generator = datagen.DataGenerator(working_dir=working_dir) total_accuracy = 0 accuracy = 0 num = 0 for fname in fnames: num = num + 1 accuracy = 0 print("fname: {}".format(fname)) # get file number file_num = None for idx, path in enumerate(paths): if fname in path: file_num = idx if file_num is None: raise ValueError("Could not find file {}".format(fname)) if line_num is not None: line_nums = np.array([line_num]) else: line_nums = np.where(lab[file_num])[0] num_queries = line_nums.shape[0] print("Querying {} lines".format(num_queries)) # get data matrices (instances_mat, queries_mat), labels_mat = (val_data_generator.get_samples([file_num ])) y_true = np.argmax(labels_mat, axis=1) # get predictions separate_predics = [] for predic_num in range(NUM_MODELS_PER_EXPERIMENT): predic = models[predic_num].predict([instances_mat, queries_mat]) separate_predics.append(predic) # convert to labels separate_predics = [ np.argmax(y_pred, axis=1) for y_pred in separate_predics ] print("labels: {}".format(y_true)) print("predics: {}".format(separate_predics)) #list_true = list(y_true) for item in separate_predics: if not (y_true - np.array(item)).all(): accuracy = accuracy + 0.1 total_accuracy = ((total_accuracy * (num - 1)) + accuracy) / num print("accuracy for this file: {}".format(accuracy)) print( "----------------------------------finally-----------------------------------" ) print("total test accuracy: {}".format(total_accuracy))
def load_data(self) -> Tuple[datagen.DataGenerator, datagen.DataGenerator]: """Load patches from csv file for training and validation. Returns ------- Tuple[datagen.DataGenerator, datagen.DataGenerator] Generator of data for training [0] and validation [1] """ training_patches = [] for state in self.training_states: logger.info("Adding training patches from %s" % (state)) fn = os.path.join(self.data_dir, "%s_extended-train_patches.csv" % (state)) if not os.path.isfile(fn): fn = os.path.join(self.data_dir, "%s-train_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: training_patches.append((os.path.join(self.data_dir, fn), state)) validation_patches = [] for state in self.validation_states: logger.info("Adding validation patches from %s" % (state)) fn = os.path.join(self.data_dir, "%s_extended-val_patches.csv" % (state)) if not os.path.isfile(fn): fn = os.path.join(self.data_dir, "%s-val_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: validation_patches.append((os.path.join(self.data_dir, fn), state)) logger.info("Loaded %d training patches and %d validation patches" % (len(training_patches), len(validation_patches))) if self.training_steps_per_epoch * self.batch_size > len( training_patches): logger.info( "Number of train patches is insufficient. Assuming testing...") self.training_steps_per_epoch = 1 self.validation_steps_per_epoch = 1 if self.do_superres: logger.info("Using %d states in superres loss:" % (len(self.superres_states))) logger.info(self.superres_states) training_generator = datagen.DataGenerator( training_patches, self.batch_size, self.training_steps_per_epoch, self.input_shape[0], self.input_shape[1], self.input_shape[2], num_classes=self.classes, lr_num_classes=self.lr_num_classes, hr_labels_index=self.hr_labels_index, lr_labels_index=self.lr_labels_index, hr_key_dict=self.hr_key_dict, lr_label_key=self.lr_label_key, do_color_aug=self.do_color, do_superres=self.do_superres, superres_only_states=self.superres_states, data_type=self.data_type, ) validation_generator = datagen.DataGenerator( validation_patches, self.batch_size, self.validation_steps_per_epoch, self.input_shape[0], self.input_shape[1], self.input_shape[2], num_classes=self.classes, lr_num_classes=self.lr_num_classes, hr_labels_index=self.hr_labels_index, lr_labels_index=self.lr_labels_index, hr_key_dict=self.hr_key_dict, lr_label_key=self.lr_label_key, do_color_aug=self.do_color, do_superres=self.do_superres, superres_only_states=[], data_type=self.data_type, ) return training_generator, validation_generator
def get_memnet_predics(working_dir, models_dir, fnames=None, line_num=None): """Get memory network predictions Args: working_dir (str): path to working dir with data in .npy files models_dir (str): path to models dir with models in .h5 files fnames (str or list of str): filenames to get predictions from if None, then get them for all validation files line_num (int): line number to predict if None, then get predictions for all lines Returns: (only test one line query) y_true_list: the list of true labels of the query lines predict_list: the list of the predict labels of the query lines line_num_list: the list of the query line numbers """ # load data inst, lab, _, part, paths = utils.load_data(working_dir) # get trained model models = validate.get_models(models_dir) if fnames is None: fnames = [paths[idx] for idx in part['validation']] elif isinstance(fnames, str): fnames = [fnames] elif not isinstance(fnames, list): raise ValueError("fnames must be str, list, or None") if line_num is not None: # -1 for line numbers starting at 1 # -1 for excluding the #include line_num = line_num - 2 val_data_generator = datagen.DataGenerator(working_dir=working_dir) y_true_list = [] predict_list = [] line_num_list = [] for fname in fnames: print("fname: {}".format(fname)) # get file number file_num = None for idx, path in enumerate(paths): if fname in path: file_num = idx if file_num is None: raise ValueError("Could not find file {}".format(fname)) if line_num is not None: line_nums = np.array([line_num]) else: line_nums = np.where(lab[file_num])[0] num_queries = line_nums.shape[0] line_num_list.append(line_nums) print("Querying {} lines".format(num_queries)) # get data matrices (instances_mat, queries_mat), labels_mat = (val_data_generator.get_test_c_samples([file_num])) y_true = np.argmax(labels_mat, axis=1) y_true_list.append(y_true) # get predictions separate_predics = [] for predic_num in range(validate.NUM_MODELS_PER_EXPERIMENT): predic = models[predic_num].predict([instances_mat, queries_mat]) separate_predics.append(predic) # convert to labels separate_predics = [np.argmax(y_pred, axis=1) for y_pred in separate_predics] predict_list.append(separate_predics) return y_true_list, predict_list, line_num_list
from model import HourglassModel from normal_Unet import N_Unet from time import time import params import datagen import numpy as np import matplotlib.pyplot as plt from torch.utils.serialization import load_lua import scipy.io as sio #from visualizer_2djoint import draw2dskeleton_2 from PIL import Image generator = datagen.DataGenerator(params.train_dir, params.valid_dir, params.test_dir, params.bg_dir, params.meanRgb_dir, False, True) meanstd = load_lua(generator.meanRgb_dir) saved_visual = False visual = True if __name__ == '__main__': print('Rebuilding Model') t_start = time() # with tf.name_scope('inputs'): # x = tf.placeholder(tf.float32, [None, 256,256,3], name = 'x_train') # y = tf.placeholder(tf.float32, [None, 64,64,16], name= 'y_train') # phase = tf.placeholder(tf.bool, name="phase") # # with tf.name_scope('model'):
def main(): prog_name = sys.argv[0] args = do_args(sys.argv[1:], prog_name) verbose = args.verbose output = args.output name = args.name training_patches_fn = args.training_patches_fn validation_patches_fn = args.validation_patches_fn superres_states = args.superres_states model_type = args.model_type batch_size = args.batch_size learning_rate = args.learning_rate time_budget = args.time_budget loss = args.loss log_dir = os.path.join(output, name) assert os.path.exists(log_dir), "Output directory doesn't exist" f = open(os.path.join(log_dir, "args.txt"), "w") f.write("%s\n" % (" ".join(sys.argv))) f.close() print("Starting %s at %s" % (prog_name, str(datetime.datetime.now()))) start_time = float(time.time()) #------------------------------ # Step 1, load data #------------------------------ f = open(training_patches_fn, "r") training_patches = f.read().strip().split("\n") f.close() f = open(validation_patches_fn, "r") validation_patches = f.read().strip().split("\n") f.close() print("Loaded %d training patches and %d validation patches" % (len(training_patches), len(validation_patches))) if loss == "superres": print("Using %d states in superres loss:" % (len(superres_states))) print(superres_states) ''' highres_patches = [] for fn in training_patches: parts = fn.split("-") parts = np.array(list(map(int, parts[2].split("_")))) if parts[0] == 0: highres_patches.append(fn) ''' #------------------------------ # Step 2, run experiment #------------------------------ #training_steps_per_epoch = len(training_patches) // batch_size // 16 #validation_steps_per_epoch = len(validation_patches) // batch_size // 16 training_steps_per_epoch = 300 validation_steps_per_epoch = 39 print("Number of training/validation steps per epoch: %d/%d" % (training_steps_per_epoch, validation_steps_per_epoch)) # Build the model if model_type == "baseline": model = models.baseline_model_landcover((240, 240, 4), 5, lr=learning_rate, loss=loss) elif model_type == "extended": model = models.extended_model_landcover((240, 240, 4), 5, lr=learning_rate, loss=loss) elif model_type == "extended_bn": model = models.extended_model_bn_landcover((240, 240, 4), 5, lr=learning_rate, loss=loss) elif model_type == "extended2_bn": model = models.extended2_model_bn_landcover((240, 240, 4), 5, lr=learning_rate, loss=loss) elif model_type == "unet1": model = models.unet_landcover((240, 240, 4), out_ch=5, start_ch=64, depth=3, inc_rate=2., activation='relu', dropout=0.5, batchnorm=True, maxpool=True, upconv=True, residual=False, lr=learning_rate, loss=loss) elif model_type == "unet2": model = models.unet_landcover((240, 240, 4), out_ch=5, start_ch=32, depth=4, inc_rate=2., activation='relu', dropout=False, batchnorm=True, maxpool=True, upconv=True, residual=False, lr=learning_rate, loss=loss) model.summary() def schedule_decay(epoch, lr, decay=0.001): if epoch >= 10: lr = lr * 1 / (1 + decay * epoch) return lr def schedule_stepped(epoch, lr): if epoch < 10: return 0.003 elif epoch < 20: return 0.0003 elif epoch < 30: return 0.00015 else: return 0.00003 validation_callback = utils.LandcoverResults(log_dir=log_dir, time_budget=time_budget, verbose=False) learning_rate_callback = LearningRateScheduler(schedule_stepped, verbose=1) model_checkpoint_callback = ModelCheckpoint(os.path.join( log_dir, "model_{epoch:02d}.h5"), verbose=0, save_best_only=False, save_weights_only=False, period=1) training_generator = None validation_generator = None if loss == "superres": training_generator = datagen.DataGenerator( training_patches, batch_size, training_steps_per_epoch, 240, 240, 4, superres=True, superres_states=superres_states) validation_generator = datagen.DataGenerator( validation_patches, batch_size, validation_steps_per_epoch, 240, 240, 4, superres=True, superres_states=[]) else: training_generator = datagen.DataGenerator(training_patches, batch_size, training_steps_per_epoch, 240, 240, 4) validation_generator = datagen.DataGenerator( validation_patches, batch_size, validation_steps_per_epoch, 240, 240, 4) model.fit_generator(training_generator, steps_per_epoch=training_steps_per_epoch, epochs=10**6, verbose=1, validation_data=validation_generator, validation_steps=validation_steps_per_epoch, max_queue_size=64, workers=4, use_multiprocessing=True, callbacks=[ validation_callback, learning_rate_callback, model_checkpoint_callback ], initial_epoch=0) #------------------------------ # Step 3, save models #------------------------------ model.save(os.path.join(log_dir, "final_model.h5")) model_json = model.to_json() with open(os.path.join(log_dir, "final_model.json"), "w") as json_file: json_file.write(model_json) model.save_weights(os.path.join(log_dir, "final_model_weights.h5")) print("Finished in %0.4f seconds" % (time.time() - start_time))
#-*-coding:utf-8 -*- from CPM import CPM import Global # Thanks to wbenhibi@github # good datagen to use import datagen print('--Creating Dataset') dataset = datagen.DataGenerator(Global.joint_list, Global.IMG_ROOT, Global.training_txt_file, remove_joints=None, in_size=Global.INPUT_SIZE) dataset._create_train_table() dataset._randomize() dataset._create_sets() model = CPM(base_lr=Global.base_lr, in_size=Global.INPUT_SIZE, batch_size=Global.batch_size, epoch=Global.epoch, dataset=dataset, log_dir=Global.LOGDIR) model.BuildModel() model.train()