connect dataset api to train-psy

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
+*.npy
 
 # C extensions
 *.so

agent.py

@@ -42,6 +42,7 @@ def __init__(self, args):
     def build_model(self):
 
         if self.mode == 'train' or self.mode == 'overfit':  # validation phase
+            print('Building Train Network')
             with tf.variable_scope('network') as scope:
                 self.model = self.model(self.args)
                 self.model.build()

config/experiments_config/fcn8s_depthnet_train.yaml

@@ -0,0 +1,28 @@
+# Directories arguments
+data_dir: "synthetic_seq"
+exp_dir:  "fcn8s_depthnet"
+out_dir:  "fcn8s_depthnet"
+
+# Data arguments
+img_height:   720
+img_width:    1280
+num_channels: 1
+num_classes:  26
+
+# Train arguments
+num_epochs: 200
+batch_size: 5
+shuffle: True
+data_mode: "experiment"
+save_every: 5
+test_every: 5
+max_to_keep: 1
+
+# Models arguments
+learning_rate:   0.0001
+weight_decay: 0.0005
+pretrained_path: "pretrained_weights/depthnet.npy"
+
+# Misc arguments
+verbose: False
+

config/experiments_config/unet_depthnet_train.yaml

@@ -0,0 +1,36 @@
+# Directories arguments
+data_dir: "synthetic_seq"
+exp_dir:  "unet_depthnet"
+out_dir:  "unet_depthnet"
+
+# Data arguments
+# image dimensions are reduced to enable run on my pc
+img_height:   740
+img_width:    1280
+num_channels: 1
+num_classes:  28
+
+# Train arguments
+num_epochs: 200
+batch_size: 20
+train_data_len: 2000
+shuffle: True
+dropout_keep_prob: 0.95
+data_mode: "experiment"
+save_every: 10
+test_every: 10
+max_to_keep: 2
+weighted_loss: False
+random_cropping: False
+freeze_encoder: False
+
+# Models arguments
+learning_rate:   0.0001
+weight_decay: 0.0005
+bias : 0.0
+batchnorm_enabled: True
+#pretrained_path: "pretrained_weights/mobilenet_v1.pkl"
+
+# Misc arguments
+verbose: False
+

config/experiments_config/unet_depthnet_train_small.yaml

@@ -0,0 +1,36 @@
+# Directories arguments
+data_dir: "synthetic_seq"
+exp_dir:  "unet_depthnet_small"
+out_dir:  "unet_depthnet_small"
+
+# Data arguments
+# image dimensions are reduced to enable run on my pc
+img_height:   125
+img_width:    125
+num_channels: 1
+num_classes:  28
+
+# Train arguments
+num_epochs: 200
+batch_size: 20
+train_data_len: 2000
+shuffle: True
+dropout_keep_prob: 0.95
+data_mode: "experiment"
+save_every: 10
+test_every: 10
+max_to_keep: 2
+weighted_loss: False
+random_cropping: False
+freeze_encoder: False
+
+# Models arguments
+learning_rate:   0.0001
+weight_decay: 0.0005
+bias : 0.0
+batchnorm_enabled: True
+#pretrained_path: "pretrained_weights/mobilenet_v1.pkl"
+
+# Misc arguments
+verbose: False
+

data/data_load_psy.py

@@ -0,0 +1,98 @@
+
+# coding: utf-8
+
+'''
+#usage example
+train_seq_folder = 'c:\\TFSegmentation\\data\\synthetic_seq\\train_seq'
+dataset = load_datase(train_seq_folder, 5)
+iterator = dataset.make_one_shot_iterator()
+next_example = iterator.get_next()
+sess = tf.Session()
+sess.run(next_example)
+'''
+
+import os
+import h5py
+import warnings
+import tensorflow as tf
+import numpy as np
+import skimage.transform as st
+from train.basic_train import BasicTrain
+from metrics.metrics import Metrics
+from utils.reporter import Reporter
+from utils.misc import timeit
+from utils.average_meter import FPSMeter
+
+MIN_DEPTH = 300
+MAX_DEPTH = 1500
+
+def _read_hdf5_func(filename, label, h, w):
+    out_size = (h, w);
+    #print('file: ' + str(filename))
+    filename_decoded = filename.decode("utf-8")
+    #print(filename_decoded)
+    h5_file_name, group_name = filename_decoded.split('__')
+    h5_file = h5py.File(h5_file_name, "r")
+    #print(group_name)
+
+    # Read depth image
+    depth_image_path = group_name + 'Z'
+    depth_image = h5_file[depth_image_path].value
+    depth_image_scaled = np.array(depth_image, copy=False)
+    depth_image_scaled.clip(MIN_DEPTH, MAX_DEPTH, out=depth_image_scaled)
+    depth_image_scaled -= MIN_DEPTH
+    np.floor_divide(depth_image_scaled, (MAX_DEPTH - MIN_DEPTH + 1) / 256,
+                    out=depth_image_scaled, casting='unsafe')
+    # Read labels
+    label_image_path = group_name + 'LABEL'
+    label_image = h5_file[label_image_path].value
+    h5_file.close()
+    #resize output
+    depth_resize = depth_image_scaled
+    if(depth_image_scaled.shape != out_size):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            depth_resize = st.resize(depth_resize, out_size,
+                                     order = 0, preserve_range = True)
+            label_image = st.resize(label_image, out_size,
+                                     order = 0, preserve_range = True)
+            label_image = label_image.astype('uint8')
+    depth_image = depth_resize.astype(np.uint8)
+    depth_image = np.expand_dims(depth_image,2)
+    return depth_image, label_image
+
+
+def load_dataset(train_seq_folder, batch_size, h, w):
+    train_seq_files = []
+    for (dirpath, dirnames, filenames) in os.walk(train_seq_folder):
+        train_seq_files.extend(os.path.join(dirpath, x) for x in filenames)
+    filenames = []
+    for train_seq_name in train_seq_files:
+        train_seq = h5py.File(train_seq_name, "r")
+        num_cameras = train_seq['INFO']['NUM_CAMERAS'].value[0]
+        num_frames = train_seq['INFO']['COUNT'].value[0] * 5
+        train_seq.close()
+        for frame_idx in range(0, num_frames, 5):
+            for cam_idx in range(num_cameras):
+                filename_str = train_seq_name + '__' + 'FRAME{:04d}/RAW/CAM{:d}/'.format(frame_idx, cam_idx)
+                filenames.append(filename_str)
+
+    num_images = len(filenames)
+    int_num_images = int(np.floor(num_images / batch_size) * batch_size)
+    if num_images != int_num_images :
+        del filenames[int_num_images:]
+
+    labels = [0]*len(filenames)
+    dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
+    dataset = dataset.shuffle(buffer_size=10000)
+    dataset = dataset.map(
+        lambda filename, label: tuple(tf.py_func(
+            _read_hdf5_func, [filename, labels, h, w], [tf.uint8, tf.uint8])), num_parallel_calls=1)
+
+
+    dataset = dataset.batch(batch_size)
+    dataset = dataset.repeat()
+    dataset = dataset.prefetch(1)
+
+    return dataset
+

data/psy_input.py

@@ -0,0 +1,87 @@
+def _read_hdf5_func(filename, label):
+    filename_decoded = filename.decode("utf-8")
+    h5_file_name, group_name = filename_decoded.split('__')
+    h5_file = h5py.File(h5_file_name, "r")
+    #print(group_name)
+
+    # Read depth image
+    depth_image_path = group_name + 'Z'
+    depth_image = h5_file[depth_image_path].value
+
+    # Read labels
+    label_image_path = group_name + 'LABEL'
+    label_image = h5_file[label_image_path].value
+    h5_file.close()
+    return depth_image, label_image
+
+
+def generate_datasets(train_seq_folder, val_seq_folder, params):
+    print(train_seq_folder)
+    print(val_seq_folder)
+
+    train_seq_files = []
+    for (dirpath, dirnames, filenames) in os.walk(train_seq_folder):
+        train_seq_files.extend(os.path.join(dirpath, x) for x in filenames)
+    print(train_seq_files)
+
+    val_seq_files = []
+    for (dirpath, dirnames, filenames) in os.walk(val_seq_folder):
+        val_seq_files.extend(os.path.join(dirpath, x) for x in filenames)
+    print(val_seq_files)
+
+    train_filenames = []
+    for train_seq_name in train_seq_files:
+        train_seq = h5py.File(train_seq_name, "r")
+        num_cameras = train_seq['INFO']['NUM_CAMERAS'].value[0]
+        num_frames = train_seq['INFO']['COUNT'].value[0]
+        train_seq.close()
+        for frame_idx in range(num_frames):
+            for cam_idx in range(num_cameras):
+                train_filename_str = train_seq_name + '__' + 'FRAME{:04d}/RAW/CAM{:d}/'.format(frame_idx, cam_idx)
+                train_filenames.append(train_filename_str)
+
+    val_filenames = []
+    for val_seq_name in val_seq_files:
+        val_seq = h5py.File(val_seq_name, "r")
+        num_cameras = val_seq['INFO']['NUM_CAMERAS'].value[0]
+        num_frames = val_seq['INFO']['COUNT'].value[0]
+        val_seq.close()
+        for frame_idx in range(num_frames):
+            for cam_idx in range(num_cameras):
+                val_filename_str = val_seq_name + '__' + 'FRAME{:04d}/RAW/CAM{:d}/'.format(frame_idx, cam_idx)
+                val_filenames.append(val_filename_str)
+
+
+
+    parse_fn = lambda filename, label: tuple(tf.py_func(
+                        read_hdf5_func, [filename, label], [tf.int16, tf.uint8]))
+
+    val_labels = [0]*len(val_filenames) 
+    val_dataset = tf.data.Dataset.from_tensor_slices((val_filenames, val_labels))
+        .shuffle(buffer_size=10000)
+        .map(parse_fn, num_parallel_calls=params.num_parallel_calls)
+
+    train_labels = [0]*len(train_filenames)
+    train_dataset = tf.data.Dataset.from_tensor_slices((train_filenames, train_labels))
+        .shuffle(buffer_size=10000)
+        .map(parse_fn, num_parallel_calls=params.num_parallel_calls)
+        .batch(params.batch_size)
+        .repeat()
+        .prefetch(1)
+
+    iterator = tf.data.Iterator.from_structure(train_dataset.output_types,
+                                           train_dataset.output_shapes)
+
+    train_init_op = iterator.make_initializer(train_dataset)
+    val_init_op = iterator.make_initializer(val_dataset)
+
+    images, labels = iterator.get_next()
+    iterator_init_op = iterator.initializer
+
+    inputs = {'images': images, 
+              'labels': labels, 
+              'train_init_op': train_init_op, 
+              'val_init_op': val_init_op}
+
+    return inputs
+