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