def main(_):
parser = argparse.ArgumentParser()
parser.add_argument('--output_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
normalize = True
lidar_grss2013_scale = 5
lidar_grss2018_scale = lidar_grss2013_scale / 2.5
loader_name = "GRSS2013DataLoader"
loader = get_class(loader_name + '.' + loader_name)(flags.path)
grss_2013_data_set = loader.load_data(0, normalize)
loader_name = "GRSS2018DataLoader"
loader = get_class(loader_name + '.' + loader_name)(flags.path)
grss_2018_data_set = loader.load_data(0, normalize)
grss_2013_band = 8
grss_2018_band = 2
match_data(grss_2013_band, grss_2018_band, grss_2013_data_set,
grss_2018_data_set, lidar_grss2013_scale, lidar_grss2018_scale)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
loader_name = flags.loader_name
loader = get_class(loader_name + '.' + loader_name)(flags.path)
sample_set = loader.load_samples(0.1, 0.1)
data_set = loader.load_data(0, True)
shadow_map, _ = loader.load_shadow_map(0, data_set)
plt.imshow(shadow_map * 255)
plt.title("figure_name"), plt.xticks([]), plt.yticks([])
plt.show()
non_shadow_test_sample = 0
for point in sample_set.validation_targets:
if shadow_map[point[1], point[0]] == 1:
shadow_map[point[1], point[0]] = 0
else:
non_shadow_test_sample = non_shadow_test_sample + 1
plt.imshow(shadow_map * 255)
plt.title("figure_name"), plt.xticks([]), plt.yticks([])
plt.show()
imwrite("shadow_map.tif", shadow_map, planarconfig='contig')
def read_data_set(self, loader_name, path, test_data_ratio, neighborhood,
normalize):
loader = get_class(loader_name + '.' + loader_name)(path)
model_base_dir = loader.get_model_base_dir()
for record in tf.python_io.tf_record_iterator(model_base_dir +
'metadata.tfrecord'):
example = tf.train.Example()
example.ParseFromString(record) # calling protocol buffer API
training_data_shape = np.array(
example.features.feature['training_data_shape'].int64_list.
value)
testing_data_shape = np.array(
example.features.feature['testing_data_shape'].int64_list.value
)
validation_data_shape = np.array(
example.features.feature['validation_data_shape'].int64_list.
value)
return TFRecordDataInfo(data=TFRecordSpecialData(training_data_shape),
path=model_base_dir + 'training.tfrecord'), \
TFRecordDataInfo(data=TFRecordSpecialData(testing_data_shape),
path=model_base_dir + 'test.tfrecord'), \
TFRecordDataInfo(data=TFRecordSpecialData(validation_data_shape),
path=model_base_dir + 'validation.tfrecord'), None, \
loader.get_class_count(), None, loader.get_target_color_list()
def read_data_set(self, loader_name, path, test_data_ratio, neighborhood, normalize):
start_time = time.time()
loader = get_class(loader_name + '.' + loader_name)(path)
data_set = loader.load_data(neighborhood, normalize)
sample_set = loader.load_samples(test_data_ratio)
training_data_shape = numpy.concatenate(
([sample_set.training_targets.shape[0]], loader.get_data_shape(data_set)))
testing_data_shape = numpy.concatenate(
([sample_set.test_targets.shape[0]], loader.get_data_shape(data_set)))
validation_data_shape = numpy.concatenate(
([sample_set.validation_targets.shape[0]], loader.get_data_shape(data_set)))
print('Loaded dataset(%.3f sec)' % (time.time() - start_time))
return \
GeneratorDataInfo(
data=GeneratorSpecialData(shape=training_data_shape, size=numpy.prod(training_data_shape)),
targets=sample_set.training_targets,
loader=loader,
dataset=data_set), \
GeneratorDataInfo(
data=GeneratorSpecialData(shape=testing_data_shape, size=numpy.prod(testing_data_shape)),
targets=sample_set.test_targets,
loader=loader,
dataset=data_set), \
GeneratorDataInfo(
data=GeneratorSpecialData(shape=validation_data_shape, size=numpy.prod(validation_data_shape)),
targets=sample_set.validation_targets,
loader=loader,
dataset=data_set), \
data_set.shadow_creator_dict, \
loader.get_class_count(), loader.get_scene_shape(data_set), loader.get_target_color_list()
def main(_):
parser = argparse.ArgumentParser()
parser.add_argument(
'--path',
nargs='?',
const=True,
type=str,
default='C:/Users/AliGökalp/Documents/phd/data/2013_DFTC/2013_DFTC',
help='Input data path')
parser.add_argument(
'--loader_name',
nargs='?',
const=True,
type=str,
default='GRSS2013DataLoader',
help='Data set loader name, Values : GRSS2013DataLoader')
parser.add_argument('--neighborhood',
nargs='?',
type=int,
default=5,
help='Neighborhood for data extraction')
parser.add_argument('--test_ratio',
nargs='?',
type=float,
default=0.05,
help='Ratio of training data to use in testing')
parser.add_argument('--compressed',
nargs='?',
const=True,
type=bool,
default=False,
help='If true, performs compression')
parser.add_argument('--target_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Target path to write the files to')
flags, unparsed = parser.parse_known_args()
inmemoryimporter = get_class('InMemoryImporter.InMemoryImporter')()
training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_ratio, class_count, scene_shape, color_list = \
inmemoryimporter.read_data_set(flags.loader_name, flags.path, flags.test_ratio, flags.neighborhood, True)
write_metadata_record(os.path.join(flags.target_path, 'metadata.tfrecord'),
training_data_with_labels.data,
test_data_with_labels.data,
validation_data_with_labels.data)
write_to_tfrecord(os.path.join(flags.target_path, 'training.tfrecord'),
training_data_with_labels.data,
training_data_with_labels.labels, flags.compressed)
write_to_tfrecord(os.path.join(flags.target_path, 'test.tfrecord'),
test_data_with_labels.data, test_data_with_labels.labels,
flags.compressed)
write_to_tfrecord(os.path.join(flags.target_path, 'validation.tfrecord'),
validation_data_with_labels.data,
validation_data_with_labels.labels, flags.compressed)
pass
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output_path', nargs='?', const=True, type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
loader_name = flags.loader_name
loader = get_class(loader_name + '.' + loader_name)(flags.path)
sample_set = loader.load_samples(0.1, 0.1)
data_set = loader.load_data(0, True)
scene_shape = loader.get_scene_shape(data_set)
target_classes_as_image = create_target_image_via_samples(sample_set, scene_shape)
shadow_map = get_shadow_map(target_classes_as_image)
imwrite("muulf_shadow_map.tif", shadow_map, planarconfig='contig')
create_shadow_corrected_image(data_set.casi, loader.load_data(0, False).casi, shadow_map)
draw_targets(loader.get_target_color_list(), target_classes_as_image, "Targets")
# retval, labels, stats, centroids = cv2.connectedComponentsWithStats(shadow_map)
contours, hierarchy = cv2.findContours(shadow_map, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
# draw_im = numpy.zeros(shadow_map.shape, dtype=numpy.uint8)
# cv2.drawContours(draw_im, contours, -1, 255, 3)
for contour in contours:
target_map = {}
fill_targets_for_contour(contour, target_classes_as_image, target_map)
if BUILDING_SHADOW_CLASS in target_map:
del target_map[BUILDING_SHADOW_CLASS]
if INVALID_TARGET_VALUE in target_map:
del target_map[INVALID_TARGET_VALUE]
if BUILDING_CLASS in target_map:
del target_map[BUILDING_CLASS]
final_neigh_target = None
final_neigh_count = 0
for neigh_target, neigh_count in target_map.items():
if final_neigh_target is not None:
if neigh_count > final_neigh_count:
final_neigh_target = neigh_target
final_neigh_count = neigh_count
else:
final_neigh_target = neigh_target
final_neigh_count = neigh_count
# print(final_neigh_target)
# print(final_neigh_count)
if final_neigh_target is None:
print("found contour with no proper neighbors")
else:
image = get_contour_image(shadow_map.shape, contour)
target_classes_as_image[image] = final_neigh_target
print("shadow converted to neighboring target %d" % final_neigh_target)
draw_targets(loader.get_target_color_list(), target_classes_as_image, "Targets after shadow correction")
# increase target level as one
target_classes_as_image[target_classes_as_image != INVALID_TARGET_VALUE] = target_classes_as_image[
target_classes_as_image != INVALID_TARGET_VALUE] + 1
imwrite("muulf_gt_shadow_corrected.tif", target_classes_as_image, planarconfig='contig')
def main(_):
flags = parse_cmd(argparse.ArgumentParser())
print('Input information:', flags)
nn_model = get_class(flags.model_name + '.' + flags.model_name)()
if flags.max_evals == 1:
print('Running in single execution training mode')
algorithm_params = nn_model.get_default_params(flags.batch_size)
if flags.algorithm_param_path is not None:
algorithm_params = json.load(open(flags.algorithm_param_path, 'r'))
# algorithm_params = namedtuple('GenericDict', algorithm_params_dict.keys())(**algorithm_params_dict)
perform_an_episode(flags, algorithm_params, nn_model,
flags.base_log_path)
# code for dumping the parameters as json
# json.dump(algorithm_params, open('algorithm_param_output_cnnv4.json', 'w'), indent=3)
else:
print('Running in hyper parameter optimization mode')
model_space_fun = nn_model.get_hyper_param_space
global episode_run_index
trial_fileaddress = os.path.join(flags.base_log_path, "trial.p")
while True:
try:
with open(trial_fileaddress, "rb") as read_file:
trials = pickle.load(read_file)
episode_run_index = len(trials.trials)
best = convert_trial_to_dictvalues(
trials.best_trial['misc']['vals'])
except IOError:
print("No trials file found. Starting trials from scratch")
episode_run_index = 0
trials = Trials()
if episode_run_index == flags.max_evals:
break
best = fmin(
fn=lambda params: 1 -
(perform_an_episode(flags, params, nn_model, flags.
base_log_path).validation_accuracy),
space=model_space_fun(),
algo=tpe.suggest,
trials=trials,
max_evals=episode_run_index + 1)
pickle.dump(trials, open(trial_fileaddress, "wb"))
json.dump(trials.results, open('trial_results.json', 'w'), indent=3)
print(space_eval(model_space_fun(), best))
def read_data_set(self, loader_name, path, train_data_ratio, test_data_ratio, neighborhood, normalize):
start_time = time.time()
loader = get_class(loader_name + '.' + loader_name)(path)
data_set = loader.load_data(neighborhood, normalize)
sample_set = loader.load_samples(train_data_ratio, test_data_ratio)
training_data_with_labels = self._get_data_with_labels(sample_set.training_targets, loader, data_set)
validation_data_with_labels = self._get_data_with_labels(sample_set.validation_targets, loader, data_set)
test_data_with_labels = self._get_data_with_labels(sample_set.test_targets, loader, data_set)
print('Loaded dataset(%.3f sec)' % (time.time() - start_time))
return training_data_with_labels, test_data_with_labels, validation_data_with_labels, data_set.shadow_creator_dict, \
loader.get_class_count(), loader.get_scene_shape(data_set), loader.get_target_color_list()
def load_op(batch_size, iteration_count, loader_name, path):
neighborhood = 0
loader = get_class(loader_name + '.' + loader_name)(path)
data_set = loader.load_data(neighborhood, True)
shadow_map, shadow_ratio = loader.load_shadow_map(neighborhood, data_set)
# normal_data_as_matrix, shadow_data_as_matrix = GRSS2013DataLoader.get_targetbased_shadowed_normal_data(data_set,
# loader,
# shadow_map,
# loader.load_samples(0.1))
if FLAGS.use_target_map:
normal_data_as_matrix, shadow_data_as_matrix = get_data_from_scene(
data_set, loader, shadow_map)
else:
normal_data_as_matrix, shadow_data_as_matrix = get_all_shadowed_normal_data(
data_set, loader, shadow_map, multiply_shadowed_data=False)
# normal_data_as_matrix, shadow_data_as_matrix = create_dummy_shadowed_normal_data(data_set, loader)
hsi_channel_len = normal_data_as_matrix.shape[3] - 1
normal_data_as_matrix = normal_data_as_matrix[:, :, :, 0:hsi_channel_len]
shadow_data_as_matrix = shadow_data_as_matrix[:, :, :, 0:hsi_channel_len]
normal = tf.placeholder(dtype=normal_data_as_matrix.dtype,
shape=normal_data_as_matrix.shape,
name='x')
shadow = tf.placeholder(dtype=shadow_data_as_matrix.dtype,
shape=shadow_data_as_matrix.shape,
name='y')
epoch = int(
(iteration_count * batch_size) / normal_data_as_matrix.shape[0])
data_set = tf.data.Dataset.from_tensor_slices(
(normal,
shadow)).apply(shuffle_and_repeat(buffer_size=10000, count=epoch))
data_set = data_set.map(
lambda param_x, param_y_: perform_shadow_augmentation_random(
param_x, param_y_, shadow_ratio[0:hsi_channel_len]),
num_parallel_calls=4)
data_set = data_set.batch(batch_size)
data_set_itr = data_set.make_initializable_iterator()
return InitializerHook(data_set_itr, normal, shadow, normal_data_as_matrix,
shadow_data_as_matrix)
def read_data_set(self, loader_name, path, train_data_ratio,
test_data_ratio, neighborhood, normalize):
training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_dict, class_range, \
scene_shape, color_list = \
self.generator_importer.read_data_set(loader_name=loader_name, path=path, train_data_ratio=train_data_ratio,
test_data_ratio=test_data_ratio,
neighborhood=neighborhood, normalize=normalize)
loader = get_class(loader_name + '.' + loader_name)(path)
shape = loader.get_data_shape(training_data_with_labels.dataset)
for index in range(0, 5000):
self.target_class.append(0)
element_data = numpy.zeros(shape=shape, dtype=numpy.float)
element_data[:, :, -1] = numpy.ones(element_data[:, :, -1].shape)
self.target_data.append(element_data)
return training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_dict, class_range, \
scene_shape, color_list
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
loader_name = flags.loader_name
loader = get_class(loader_name + '.' + loader_name)(flags.path)
sample_set = loader.load_samples(0.1, 0.1)
data_set = loader.load_data(0, False)
scene_shape = loader.get_scene_shape(data_set)
imsave(
os.path.join(flags.output_path, "result_colorized.tif"),
create_colored_image(
create_target_image_via_samples(sample_set, scene_shape),
loader.get_target_color_list()))
def perform_full_scene_classification(data_path, loader_name, neighborhood,
estimator, batch_size):
loader = get_class(loader_name + '.' + loader_name)(data_path)
data_set = loader.load_data(neighborhood, False)
scene_shape = loader.get_scene_shape(data_set)
all_scene_target_array = GeneratorImporter.GeneratorImporter.create_all_scene_target_array(
scene_shape)
predict_pixel_count = scene_shape[0] * scene_shape[1]
progress_bar = tqdm(total=predict_pixel_count)
prediction = numpy.empty([predict_pixel_count], dtype=numpy.uint8)
batch_cache = numpy.empty([
batch_size,
loader.get_data_shape(data_set)[0],
loader.get_data_shape(data_set)[1],
loader.get_data_shape(data_set)[2]
],
dtype=numpy.float32)
current_pixel_index = 0
batch_pixel_index = 0
for point in all_scene_target_array:
batch_cache[batch_pixel_index] = loader.get_point_value(
data_set, point)
current_pixel_index = current_pixel_index + 1
batch_pixel_index = batch_pixel_index + 1
if current_pixel_index == predict_pixel_count or batch_pixel_index == batch_size:
point_val = flatten_data(batch_cache[0:batch_pixel_index])
prediction[(current_pixel_index - batch_pixel_index):current_pixel_index] = \
estimator.predict(point_val)
progress_bar.update(batch_pixel_index)
batch_pixel_index = 0
progress_bar.close()
scene_as_image = numpy.reshape(prediction, scene_shape)
output_path = "."
imsave(os.path.join(output_path, "result_raw.tif"), scene_as_image)
imsave(
os.path.join(output_path, "result_colorized.tif"),
create_colored_image(scene_as_image, loader.get_target_color_list()))
def main(_):
numpy.set_printoptions(precision=5, suppress=True)
neighborhood = FLAGS.neighborhood
_validate_flags()
loader_name = FLAGS.loader_name
loader = get_class(loader_name + '.' + loader_name)(FLAGS.path)
data_set = loader.load_data(neighborhood, True)
log_dir = "./"
# test_x_data = numpy.full([1, 1, band_size], fill_value=1.0, dtype=float)
# print_tensors_in_checkpoint_file(FLAGS.checkpoint_path, tensor_name='ModelX2Y', all_tensors=True)
shadow_map, shadow_ratio = loader.load_shadow_map(neighborhood, data_set)
gan_inference_wrapper_dict = {
"cycle_gan": CycleGANInferenceWrapper(),
"gan_x2y": GANInferenceWrapper(fetch_shadows=False),
"gan_y2x": GANInferenceWrapper(fetch_shadows=True)
}
hook = gan_inference_wrapper_dict[FLAGS.gan_type].create_inference_hook(
data_set=data_set,
loader=loader,
log_dir=log_dir,
neighborhood=neighborhood,
shadow_map=shadow_map,
shadow_ratio=shadow_ratio,
validation_sample_count=FLAGS.number_of_samples)
gpu = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(gpu[0], True)
with tf.Session() as sess:
gan_inference_wrapper_dict[
FLAGS.gan_type].create_generator_restorer().restore(
sess, FLAGS.checkpoint_path)
hook.after_create_session(sess, None)
run_context = SessionRunContext(original_args=None, session=sess)
hook.after_run(run_context=run_context, run_values=None)
def main(_):
parser = argparse.ArgumentParser()
parser.add_argument('--output_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
model = get_class(flags.model_name + '.' + flags.model_name)()
algorithm_params = model.get_default_params(flags.batch_size)
if flags.algorithm_param_path is not None:
algorithm_params = json.load(open(flags.algorithm_param_path, 'r'))
importer_name = flags.importer_name
# data_importer = get_class(importer_name + '.' + importer_name)()
data_importer = ControlledDataImporter()
training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_dict, class_range, \
scene_shape, color_list = \
data_importer.read_data_set(flags.loader_name, flags.path, flags.test_ratio, flags.neighborhood, True)
validation_data_with_labels = data_importer.create_all_scene_data(
scene_shape, validation_data_with_labels)
testing_tensor, training_tensor, validation_tensor = data_importer.convert_data_to_tensor(
test_data_with_labels, training_data_with_labels,
validation_data_with_labels, class_range)
deep_nn_template = tf.make_template('nn_core',
model.create_tensor_graph,
class_count=class_range.stop)
start_time = time.time()
validation_data_set = validation_tensor.dataset
validation_input_iter = simple_nn_iterator(validation_data_set,
flags.batch_size)
validation_images, validation_labels = validation_input_iter.get_next()
model_input_params = ModelInputParams(x=validation_images,
y=None,
device_id='/gpu:0',
is_training=False)
validation_tensor_outputs = deep_nn_template(
model_input_params, algorithm_params=algorithm_params)
validation_nn_params = NNParams(
input_iterator=validation_input_iter,
data_with_labels=None,
metrics=None,
predict_tensor=validation_tensor_outputs.y_conv)
validation_nn_params.data_with_labels = validation_data_with_labels
saver = tf.train.Saver(var_list=slim.get_variables_to_restore(
include=["nn_core"], exclude=["image_gen_net_"]))
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
config.gpu_options.allow_growth = False
config.gpu_options.per_process_gpu_memory_fraction = 1.0
with tf.Session(config=config) as session:
# Restore variables from disk.
saver.restore(session, flags.base_log_path)
# Init for imaging the results
validation_tensor.importer.perform_tensor_initialize(
session, validation_tensor, validation_nn_params)
histogram_tensors = []
histogram_tensor_names = []
result_map = {}
bin_map = {}
base_bin = 480 / calculate_tensor_size(
validation_tensor_outputs.histogram_tensors[0].tensor)
for histogram_tensor_instance in validation_tensor_outputs.histogram_tensors:
histogram_tensors.append(histogram_tensor_instance.tensor)
histogram_tensor_names.append(histogram_tensor_instance.name)
result_map[histogram_tensor_instance.name] = []
bin_map[histogram_tensor_instance.name] = int(
base_bin *
calculate_tensor_size(histogram_tensor_instance.tensor))
sample_idx = 0
while True:
try:
# prediction, current_prediction = session.run([
# tf.argmax(validation_nn_params.predict_tensor, 1), histogram_tensors])
current_prediction = session.run(histogram_tensors)
if sample_idx > 2000:
for tensor_result, tensor_name in zip(
current_prediction, histogram_tensor_names):
result_map[tensor_name].append(tensor_result)
if sample_idx == 5000:
break
sample_idx = sample_idx + 1
except tf.errors.OutOfRangeError:
break
for tensor_name in histogram_tensor_names:
range_min = sys.float_info.max
range_max = sys.float_info.min
for result in result_map[tensor_name]:
range_min = min(range_min, result.min())
range_max = max(range_max, result.max())
all_hists = numpy.zeros(
[len(result_map[tensor_name]), bin_map[tensor_name]],
dtype=numpy.int)
bin_edges = None
for idx, result in enumerate(result_map[tensor_name]):
hist, bin_edges = numpy.histogram(result,
range=(range_min, range_max),
bins=bin_map[tensor_name])
all_hists[idx] = hist
mean = numpy.mean(all_hists, axis=0)
plt.plot(bin_edges[:-1], mean, label=tensor_name)
plt.xlim(min(bin_edges), max(bin_edges))
plt.xlabel("Value")
plt.ylabel("Counts")
plt.fill_between(bin_edges[:-1], mean)
plt.title(tensor_name)
plt.savefig(
os.path.join(flags.output_path, tensor_name + "_fig.jpg"))
plt.clf()
print('Done evaluation(%.3f sec)' % (time.time() - start_time))
def perform_an_episode(flags, algorithm_params, model, base_log_path):
importer_name = flags.importer_name
data_importer = get_class(importer_name + '.' + importer_name)()
training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_dict, class_range, \
scene_shape, color_list = \
data_importer.read_data_set(flags.loader_name, flags.path, flags.test_ratio, flags.neighborhood, True)
shadow_struct = None
if flags.augment_data_with_shadow is not None:
shadow_struct = shadow_dict[flags.augment_data_with_shadow]
augmentation_info = AugmentationInfo(
shadow_struct=shadow_struct,
perform_shadow_augmentation=flags.augment_data_with_shadow is not None,
perform_rotation_augmentation=flags.augment_data_with_rotation,
perform_reflection_augmentation=flags.augment_data_with_reflection,
offline_or_online=flags.offline_augmentation,
augmentation_random_threshold=flags.augmentation_random_threshold)
batch_size = algorithm_params["batch_size"]
epoch = flags.epoch
if epoch is None:
required_steps = flags.step
else:
required_steps = int(
((training_data_with_labels.data.shape[0] * epoch) / batch_size))
global episode_run_index
print('Starting episode#%d with steps#%d : %s' %
(episode_run_index, required_steps, algorithm_params))
validation_accuracy_list = []
testing_accuracy_list = []
loss_list = []
device_id = '/gpu:0'
if flags.device == "gpu":
device_id = '/gpu:0'
elif flags.device == "cpu":
device_id = '/cpu:0'
elif flags.device == "tpu":
device_id = None
for run_index in range(0, flags.split_count):
with tf.Graph().as_default():
# Set random seed as the same value to get consistent results
tf.set_random_seed(1234)
print('Starting Run #%d' % run_index)
testing_tensor, training_tensor, validation_tensor = data_importer.convert_data_to_tensor(
test_data_with_labels, training_data_with_labels,
validation_data_with_labels, class_range)
# Collect unnecessary data
gc.collect()
cross_entropy, learning_rate, testing_nn_params, training_nn_params, validation_nn_params, train_step = create_graph(
training_tensor.dataset,
testing_tensor.dataset,
validation_tensor.dataset,
class_range,
batch_size,
device_id,
epoch,
augmentation_info=augmentation_info,
algorithm_params=algorithm_params,
model=model,
create_separate_validation_branch=data_importer.
requires_separate_validation_branch)
# Collect unnecessary data
gc.collect()
#######################################################################
training_nn_params.data_with_labels = training_data_with_labels
testing_nn_params.data_with_labels = test_data_with_labels
validation_nn_params.data_with_labels = validation_data_with_labels
############################################################################
if not flags.perform_validation:
validation_nn_params = None
tf.summary.scalar('training_cross_entropy', cross_entropy)
tf.summary.scalar('training_learning_rate', learning_rate)
tf.summary.text('test_confusion',
tf.as_string(testing_nn_params.metrics.confusion))
tf.summary.scalar('test_overall_accuracy',
testing_nn_params.metrics.accuracy)
tf.summary.text(
'validation_confusion',
tf.as_string(validation_nn_params.metrics.confusion))
tf.summary.scalar('validation_overall_accuracy',
validation_nn_params.metrics.accuracy)
tf.summary.scalar(
'validation_average_accuracy',
validation_nn_params.metrics.mean_per_class_accuracy)
tf.summary.scalar('validation_kappa',
validation_nn_params.metrics.kappa)
episode_start_time = time.time()
log_dir = os.path.join(
base_log_path, 'log/episode_' + str(episode_run_index) +
'/run_' + str(run_index))
training_result = run_monitored_session(
cross_entropy, log_dir, required_steps, class_range,
flags.save_checkpoint_steps, flags.validation_steps,
train_step, augmentation_info, flags.device,
training_nn_params, training_tensor, testing_nn_params,
testing_tensor, validation_nn_params, validation_tensor)
print('Done training for %.3f sec' %
(time.time() - episode_start_time))
testing_accuracy_list.append(training_result.test_accuracy)
loss_list.append(training_result.loss)
if flags.perform_validation:
print(
'Run #%d, Validation accuracy=%g, Testing accuracy=%g, loss=%.2f'
% (run_index, training_result.validation_accuracy,
training_result.test_accuracy, training_result.loss))
validation_accuracy_list.append(
training_result.validation_accuracy)
else:
print('Run #%d, Testing accuracy=%g, loss=%.2f' %
(run_index, training_result.test_accuracy,
training_result.loss))
mean_validation_accuracy = None
if flags.perform_validation:
mean_validation_accuracy = mean(validation_accuracy_list)
std_validation_accuracy = std(validation_accuracy_list)
print('Validation result: (%g) +- (%g)' %
(mean_validation_accuracy, std_validation_accuracy))
mean_testing_accuracy = mean(testing_accuracy_list)
std_testing_accuracy = std(testing_accuracy_list)
mean_loss = mean(loss_list)
std_loss = std(loss_list)
print(
'Mean testing accuracy result: (%g) +- (%g), Loss result: (%g) +- (%g)'
% (mean_testing_accuracy, std_testing_accuracy, mean_loss, std_loss))
episode_run_index = episode_run_index + 1
return TrainingResult(validation_accuracy=mean_validation_accuracy,
test_accuracy=mean_testing_accuracy,
loss=mean_loss)
def main(_):
log_dir = FLAGS.train_log_dir
if not tf.gfile.Exists(log_dir):
tf.gfile.MakeDirs(log_dir)
with tf.device(tf.train.replica_device_setter(FLAGS.ps_tasks)):
validation_iteration_count = FLAGS.validation_itr_count
validation_sample_count = FLAGS.validation_sample_count
loader_name = FLAGS.loader_name
neighborhood = 0
loader = get_class(loader_name + '.' + loader_name)(FLAGS.path)
data_set = loader.load_data(neighborhood, True)
shadow_map, shadow_ratio = loader.load_shadow_map(
neighborhood, data_set)
with tf.name_scope('inputs'):
initializer_hook = load_op(FLAGS.batch_size,
FLAGS.max_number_of_steps, loader,
data_set, shadow_map, shadow_ratio,
FLAGS.regularization_support_rate)
training_input_iter = initializer_hook.input_itr
images_x, images_y = training_input_iter.get_next()
# Set batch size for summaries.
# images_x.set_shape([FLAGS.batch_size, None, None, None])
# images_y.set_shape([FLAGS.batch_size, None, None, None])
# Define model.
gan_type = FLAGS.gan_type
gan_train_wrapper_dict = {
"cycle_gan":
CycleGANWrapper(cycle_consistency_loss_weight=FLAGS.
cycle_consistency_loss_weight,
identity_loss_weight=FLAGS.identity_loss_weight,
use_identity_loss=FLAGS.use_identity_loss),
"gan_x2y":
GANWrapper(identity_loss_weight=FLAGS.identity_loss_weight,
use_identity_loss=FLAGS.use_identity_loss,
swap_inputs=False),
"gan_y2x":
GANWrapper(identity_loss_weight=FLAGS.identity_loss_weight,
use_identity_loss=FLAGS.use_identity_loss,
swap_inputs=True)
}
wrapper = gan_train_wrapper_dict[gan_type]
with tf.variable_scope('Model', reuse=tf.AUTO_REUSE):
the_gan_model = wrapper.define_model(images_x, images_y)
peer_validation_hook = wrapper.create_validation_hook(
data_set, loader, log_dir, neighborhood, shadow_map,
shadow_ratio, validation_iteration_count,
validation_sample_count)
the_gan_loss = wrapper.define_loss(the_gan_model)
# Define CycleGAN train ops.
train_ops = _define_train_ops(the_gan_model, the_gan_loss)
# Training
train_steps = tfgan.GANTrainSteps(1, 1)
status_message = tf.string_join([
'Starting train step: ',
tf.as_string(tf.train.get_or_create_global_step())
],
name='status_message')
if not FLAGS.max_number_of_steps:
return
gpu = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(gpu[0], True)
training_scaffold = Scaffold(saver=tf.train.Saver(max_to_keep=20))
gan_train(
train_ops,
log_dir,
scaffold=training_scaffold,
save_checkpoint_steps=validation_iteration_count,
get_hooks_fn=tfgan.get_sequential_train_hooks(train_steps),
hooks=[
initializer_hook, peer_validation_hook,
tf.train.StopAtStepHook(num_steps=FLAGS.max_number_of_steps),
tf.train.LoggingTensorHook([status_message], every_n_iter=1000)
],
master=FLAGS.master,
is_chief=FLAGS.task == 0)
def main(_):
parser = argparse.ArgumentParser()
parser.add_argument('--output_path',
nargs='?',
const=True,
type=str,
default=os.path.dirname(__file__),
help='Path for saving output images')
flags = parse_cmd(parser)
model = get_class(flags.model_name + '.' + flags.model_name)()
algorithm_params = model.get_default_params(flags.batch_size)
if flags.algorithm_param_path is not None:
algorithm_params = json.load(open(flags.algorithm_param_path, 'r'))
importer_name = flags.importer_name
data_importer = get_class(importer_name + '.' + importer_name)()
training_data_with_labels, test_data_with_labels, validation_data_with_labels, shadow_dict, class_range, \
scene_shape, color_list = \
data_importer.read_data_set(flags.loader_name, flags.path, flags.test_ratio, flags.neighborhood, True)
validation_data_with_labels = data_importer.create_all_scene_data(
scene_shape, validation_data_with_labels)
testing_tensor, training_tensor, validation_tensor = data_importer.convert_data_to_tensor(
test_data_with_labels, training_data_with_labels,
validation_data_with_labels, class_range)
deep_nn_template = tf.make_template('nn_core',
model.create_tensor_graph,
class_count=class_range.stop)
start_time = time.time()
validation_data_set = validation_tensor.dataset
validation_input_iter = simple_nn_iterator(validation_data_set,
flags.batch_size)
validation_images, validation_labels = validation_input_iter.get_next()
model_input_params = ModelInputParams(x=validation_images,
y=None,
device_id='/gpu:0',
is_training=False)
validation_tensor_outputs = deep_nn_template(
model_input_params, algorithm_params=algorithm_params)
validation_nn_params = NNParams(
input_iterator=validation_input_iter,
data_with_labels=None,
metrics=None,
predict_tensor=validation_tensor_outputs.y_conv)
validation_nn_params.data_with_labels = validation_data_with_labels
prediction = numpy.empty([scene_shape[0] * scene_shape[1]],
dtype=numpy.uint8)
saver = tf.train.Saver(var_list=slim.get_variables_to_restore(
include=["nn_core"], exclude=["image_gen_net_"]))
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
config.gpu_options.allow_growth = False
config.gpu_options.per_process_gpu_memory_fraction = 1.0
with tf.Session(config=config) as session:
# Restore variables from disk.
saver.restore(session, flags.base_log_path)
# Init for imaging the results
validation_tensor.importer.perform_tensor_initialize(
session, validation_tensor, validation_nn_params)
perform_prediction(session, validation_nn_params, prediction)
scene_as_image = numpy.reshape(prediction, scene_shape)
imsave(os.path.join(flags.output_path, "result_raw.tif"),
scene_as_image)
imsave(os.path.join(flags.output_path, "result_colorized.tif"),
create_colored_image(scene_as_image, color_list))
# Init for accuracy
# validation_tensor.importer.perform_tensor_initialize(session, validation_tensor, validation_nn_params)
# validation_accuracy = calculate_accuracy(session, validation_nn_params)
# print('Validation accuracy=%g' % validation_accuracy)
print('Done evaluation(%.3f sec)' % (time.time() - start_time))
def main(_):
_validate_flags()
make_them_shadow = FLAGS.make_them_shadow
loader_name = FLAGS.loader_name
loader = get_class(loader_name + '.' + loader_name)(FLAGS.path)
data_set = loader.load_data(0, True)
offset = data_set.casi_min
multiplier = data_set.casi_max
if offset is None:
offset = 0
if multiplier is None:
multiplier = 1
target_data_type = loader.get_original_data_type()
shadow_map, shadow_ratio = loader.load_shadow_map(0, data_set)
scene_shape = loader.get_scene_shape(data_set)
element_size = loader.get_data_shape(data_set)
element_size = [element_size[0], element_size[1], element_size[2] - 1]
convert_only_the_convenient_pixels = not FLAGS.convert_all
if make_them_shadow == "shadow":
shadow = True
sign_to_filter_in_shadow_map = 0
elif make_them_shadow == "deshadow":
shadow = False
sign_to_filter_in_shadow_map = 1
else:
shadow = True
sign_to_filter_in_shadow_map = -1
make_them_shadow = "none"
gan_inference_wrapper_dict = {
"cycle_gan": CycleGANInferenceWrapper(),
"gan_x2y": GANInferenceWrapper(fetch_shadows=False),
"gan_y2x": GANInferenceWrapper(fetch_shadows=True)
}
input_tensor, output_tensor = gan_inference_wrapper_dict[
FLAGS.gan_type].make_inference_graph(data_set,
loader,
shadow,
clip_invalid_values=False)
gpu = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(gpu[0], True)
with tf.Session() as sess:
if make_them_shadow != "none":
gan_inference_wrapper_dict[
FLAGS.gan_type].create_generator_restorer().restore(
sess, FLAGS.checkpoint_path)
screen_size_first_dim = scene_shape[0]
screen_size_sec_dim = scene_shape[1]
progress_bar = tqdm(total=screen_size_first_dim * screen_size_sec_dim)
band_size = element_size[2]
hsi_image = numpy.zeros(
[screen_size_first_dim, screen_size_sec_dim, band_size],
dtype=target_data_type)
for first_idx in range(0, screen_size_first_dim):
for second_idx in range(0, screen_size_sec_dim):
input_data = loader.get_point_value(
data_set, [second_idx, first_idx])[:, :, 0:band_size]
input_data = numpy.expand_dims(input_data, axis=0)
if not convert_only_the_convenient_pixels or shadow_map[
first_idx, second_idx] == sign_to_filter_in_shadow_map:
generated_y_data = export(sess, input_tensor, input_data,
output_tensor)
else:
generated_y_data = input_data
hsi_image[first_idx, second_idx, :] = \
((generated_y_data * multiplier) + offset).astype(target_data_type)
progress_bar.update(1)
progress_bar.close()
if convert_only_the_convenient_pixels:
convert_region_suffix = ""
else:
convert_region_suffix = "all"
imwrite(os.path.join(
FLAGS.output_path,
f"shadow_image_{make_them_shadow}_{convert_region_suffix}.tif"),
hsi_image,
planarconfig='contig')
hsi_image = hsi_image.astype(float)
hsi_image -= offset
hsi_image /= multiplier
hsi_as_rgb = (
get_rgb_from_hsi(loader.get_band_measurements(), hsi_image) *
256).astype(numpy.uint8)
imwrite(
os.path.join(
FLAGS.output_path,
f"shadow_image_rgb_{make_them_shadow}_{convert_region_suffix}.tif"
), hsi_as_rgb)
def main(_):
numpy.set_printoptions(precision=5, suppress=True)
neighborhood = FLAGS.neighborhood
_validate_flags()
loader_name = FLAGS.loader_name
loader = get_class(loader_name + '.' + loader_name)(FLAGS.path)
data_set = loader.load_data(neighborhood, True)
element_size = loader.get_data_shape(data_set)
element_size = [element_size[0], element_size[1], element_size[2] - 1]
images_x_hwc_pl, generated_y = make_inference_graph(model_forward_generator_name, element_size,
clip_invalid_values=False)
images_y_hwc_pl, generated_x = make_inference_graph(model_backward_generator_name, element_size,
clip_invalid_values=False)
# print_tensors_in_checkpoint_file(FLAGS.checkpoint_path, tensor_name='ModelX2Y', all_tensors=True)
with tf.Session() as sess:
create_generator_restorer().restore(sess, FLAGS.checkpoint_path)
shadow_map, shadow_ratio = loader.load_shadow_map(neighborhood, data_set)
# neighborhood aware indice finder
if neighborhood > 0:
indices = numpy.where(shadow_map[neighborhood:-neighborhood, neighborhood:-neighborhood] == 0)
else:
indices = numpy.where(shadow_map == 0)
iteration_count = 3000*2
band_size = element_size[2]
total_band_ratio = numpy.zeros([1, 1, band_size], dtype=float)
for i in range(0, iteration_count):
# Pick a random point
data_indice = random.randint(0, indices[0].size - 1)
test_indice = [indices[1][data_indice], indices[0][data_indice]]
test_x_data = loader.get_point_value(data_set, test_indice)
test_x_data = test_x_data[:, :, 0:band_size]
# test_x_data = numpy.full([1, 1, band_size], fill_value=1.0, dtype=float)
generated_y_data = export(sess, images_x_hwc_pl, test_x_data, generated_y)
generated_x_data = export(sess, images_y_hwc_pl, generated_y_data, generated_x)
band_ratio = numpy.mean(generated_y_data / test_x_data, axis=(0, 1))
shadow_calc_ratio = band_ratio * shadow_ratio[0:band_size]
is_there_inf = numpy.any(numpy.isinf(band_ratio))
is_there_nan = numpy.any(numpy.isnan(band_ratio))
if is_there_inf or is_there_nan:
print("inf or nan value")
else:
total_band_ratio = total_band_ratio + band_ratio
if iteration_count == 1:
print_info(test_x_data, generated_x_data, generated_y_data, band_ratio, shadow_calc_ratio)
print("Mean total ratio")
print(total_band_ratio / iteration_count)
print("Mean Generated vs Original Ratio")
print(total_band_ratio / iteration_count * shadow_ratio[0:band_size])
def main(_):
_validate_flags()
convert_only_the_convenient_pixels = True
make_them_shadow = True
loader_name = FLAGS.loader_name
loader = get_class(loader_name + '.' + loader_name)(FLAGS.path)
data_set = loader.load_data(0, True)
offset = data_set.casi_min
multiplier = data_set.casi_max
if offset is None:
offset = 0
if multiplier is None:
multiplier = 1
target_data_type = loader.get_original_data_type()
shadow_map, shadow_ratio = loader.load_shadow_map(0, data_set)
scene_shape = loader.get_scene_shape(data_set)
element_size = loader.get_data_shape(data_set)
element_size = [element_size[0], element_size[1], element_size[2] - 1]
if make_them_shadow:
model_name = model_forward_generator_name
sign_to_filter_in_shadow_map = 0
else:
model_name = model_backward_generator_name
sign_to_filter_in_shadow_map = 1
images_hwc_pl, generated_output = make_inference_graph(
model_name, element_size, clip_invalid_values=False)
with tf.Session() as sess:
create_generator_restorer().restore(sess, FLAGS.checkpoint_path)
screen_size_first_dim = scene_shape[0]
screen_size_sec_dim = scene_shape[1]
progress_bar = tqdm(total=screen_size_first_dim * screen_size_sec_dim)
band_size = element_size[2]
hsi_image = numpy.zeros(
[screen_size_first_dim, screen_size_sec_dim, band_size],
dtype=target_data_type)
for first_idx in range(0, screen_size_first_dim):
for second_idx in range(0, screen_size_sec_dim):
input_data = loader.get_point_value(
data_set, [second_idx, first_idx])[:, :, 0:band_size]
if not convert_only_the_convenient_pixels or (
convert_only_the_convenient_pixels
and shadow_map[first_idx, second_idx]
== sign_to_filter_in_shadow_map):
generated_y_data = export(sess, images_hwc_pl, input_data,
generated_output)
else:
generated_y_data = input_data
hsi_image[first_idx, second_idx, :] = \
((generated_y_data * multiplier) + offset).astype(target_data_type)
progress_bar.update(1)
progress_bar.close()
imwrite(os.path.join(FLAGS.output_path, "shadow_image.tif"),
hsi_image,
planarconfig='contig')
