def run():
num_classes = 2
image_h, image_w = (160, 576)
with tf.Session() as sess:
# Path to vgg model
vgg_path = join(data_dir, 'vgg')
# Create function to get batches
batch_generator = gen_batch_function(join(data_dir, 'data_road/training'), (image_h, image_w))
# Load VGG pretrained
image_input, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(sess, vgg_path)
# Add skip connections
output = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes)
# Define placeholders
labels = tf.placeholder(tf.float32, shape=[None, image_h, image_w, num_classes])
learning_rate = tf.placeholder(tf.float32, shape=[])
logits, train_op, cross_entropy_loss = optimize(output, labels, learning_rate, num_classes)
# Training parameters
train_nn(sess, args.training_epochs, args.batch_size, batch_generator, train_op, cross_entropy_loss,
image_input, labels, keep_prob, learning_rate)
save_inference_samples(runs_dir, data_dir, sess, (image_h, image_w), logits, keep_prob, image_input)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
epochs = 50
batch_size = 5
# TF placeholders
correct_label = tf.placeholder(tf.int32, [None, None, None, num_classes], name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
input_image, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(sess, vgg_path)
nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(nn_last_layer, correct_label, learning_rate, num_classes)
train_nn(sess, epochs, batch_size, get_batches_fn, train_op, cross_entropy_loss, input_image,
correct_label, keep_prob, learning_rate)
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
def run():
print("Run")
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
# Note: Not done
kBatchSize = 5
kEpochs = 10
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Note: Not implemented.
correct_label = tf.placeholder(tf.int32, [None, None, None, num_classes], name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
# Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(layer_output, correct_label, learning_rate, num_classes)
# Train NN using the train_nn function
train_nn(sess, kEpochs, kBatchSize, get_batches_fn, train_op, cross_entropy_loss, input_image, correct_label, keep_prob, learning_rate)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
# Save the variables to disk.
print("Saving model...")
saver = tf.train.Saver()
save_path = saver.save(sess, "./model/semantic_segmentation_model.ckpt")
print("Model saved in path: %s" % save_path)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Build NN using load_vgg, layers, and optimize function
epochs = 50
batch_size = 8
correct_label = tf.placeholder(tf.int32, (None, None, None, num_classes))
learning_rate = tf.placeholder(tf.float32)
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(layer_output, correct_label, learning_rate, num_classes)
# Train NN using the train_nn function
train_nn(sess,
epochs,
batch_size,
get_batches_fn,
train_op,
cross_entropy_loss,
input_image,
correct_label,
keep_prob,
learning_rate)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
epochs = 200
batch_size = 16
#do_inference_only = True
# CAREFUL: this removes ALL models and log results of the last run
if tf.gfile.Exists(LOGDIR):
tf.gfile.DeleteRecursively(LOGDIR)
tf.gfile.MakeDirs(LOGDIR)
# hyperparameter search
for l2_const in [0.002, 0.005]:
for lrate in [0.0001, 0.00005]:
for kprob in [0.8, 0.9]:
hparam = make_hparam_string(kprob=kprob,
lrate=lrate,
l2_const=l2_const)
print('Starting run for %s' % hparam)
model_path = LOGDIR + hparam + "/model"
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
tf.reset_default_graph()
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'),
image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out,
vgg_layer7_out, num_classes)
learning_rate = tf.placeholder(dtype=tf.float32)
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None,
num_classes))
logits, train_op, cross_entropy_loss = optimize(
nn_last_layer, correct_label, learning_rate,
num_classes, l2_const)
# 'Saver' op to save and restore all the variables
saver = tf.train.Saver()
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn,
train_op, cross_entropy_loss, input_image,
correct_label, keep_prob, learning_rate, kprob,
lrate, hparam)
save_path = saver.save(sess, model_path)
print("Model saved in file: %s" % save_path)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits,
keep_prob, input_image)
def run():
parser = argparse.ArgumentParser(description="Train and Infer FCN")
parser.add_argument('--epochs',
default=1,
type=int,
help='number of epochs')
parser.add_argument('--batch_size', default=4, type=int, help='batch size')
parser.add_argument(
'--num-batches-train',
default=None,
type=int,
help='number of train batches, only adjusted for testing')
parser.add_argument(
'--num-batches-dev',
default=None,
type=int,
help='number of dev batches, only adjusted for testing')
parser.add_argument('--fast',
action='store_true',
help='runs for 1 batch with 1 epoch')
parser.add_argument('--data-source',
default='cityscapes',
help='kitti or cityscapes')
parser.add_argument(
'--use-classes',
default=False,
help='If true, predict cityscape classes instead of categories')
parser.add_argument('--scale-factor',
default=4,
type=int,
help="Scales image down on each dimension")
parser.add_argument('--save-train',
action='store_true',
help="If ON, saves output train images with labels")
parser.add_argument('--save-test',
action='store_true',
help="If ON, saves output test images with labels")
parser.add_argument('--save-val',
action='store_true',
help="If ON, saves output val images with labels")
parser.add_argument(
'--save-all-images',
action='store_true',
help="If ON, saves all train test val images with labels")
parser.add_argument('--quiet',
'-q',
action='store_true',
help='If ON, does not print batch updates')
parser.add_argument('--no-early-stop',
action='store_true',
help='If ON, will not early stop')
parser.add_argument('--should-crop', action='store_true')
parser.add_argument('--print-confusion', action='store_true')
parser.add_argument(
'--use-extra',
action='store_true',
help=
'If ON, will use extras provided there is data inside /data/leftImg8bits/train_extra'
)
args = parser.parse_args()
print("Running with arguments:")
print(args)
image_shape = (1024 // args.scale_factor, 2048 // args.scale_factor)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
epochs = args.epochs
batch_size = args.batch_size
fast_run = args.fast
verbose = not args.quiet
data_set = args.data_source
num_batches_train = args.num_batches_train
num_batches_dev = args.num_batches_dev
use_classes = args.use_classes
should_crop = args.should_crop
print_confusion = args.print_confusion
num_classes = 0
class_to_ignore = 0
early_stop = not args.no_early_stop
use_extra = args.use_extra
if data_set == "cityscapes":
if use_classes:
num_classes = NUM_CLASSES_CITYSCAPES
class_to_ignore = 19
else:
num_classes = NUM_CATEGORIES_CITYSCAPES
elif data_set == "kitti":
class_to_ignore = -1
num_classes = NUM_CLASSES_KITTI
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
label_util.init(use_classes)
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape,
should_crop)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Build NN using load_vgg, layers, and optimize function
image_input, _, _, _, _ = load_vgg(sess, vgg_path)
# Fully Convolutional Network
last_layer = layers(image_input, num_classes)
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None))
learning_rate = tf.placeholder(dtype=tf.float32)
logits, train_op, cross_entropy_loss = optimize(
last_layer, correct_label, learning_rate, num_classes)
# Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, use_extra, get_batches_fn, logits,
train_op, cross_entropy_loss, image_input, correct_label, 1.,
learning_rate, num_classes, num_batches_train,
num_batches_dev, early_stop, class_to_ignore, print_confusion,
verbose)
if args.save_test or args.save_all_images:
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits, 1., image_input,
"test")
if args.save_train or args.save_all_images:
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits, 1., image_input,
"train")
if args.save_val or args.save_all_images:
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits, 1., image_input,
"val")
def run(keep_prob_val, batch_size, num_classes):
learning_rate_val = 1e-3
num_validation_images = 2
epochs = 10
image_shape = (160, 576)
image_dtype = np.uint8
data_dir = '../../../Users/matth/Desktop/semantic/'
if not os.path.exists(data_dir):
data_dir = '../../../Desktop/semantic'
runs_dir = './runs'
if testing:
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get training and validation batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape,
generateColors(num_classes), image_dtype)
valid_batches = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/testing'), image_shape,
generateColors(num_classes), image_dtype)
validation_images, validation_labels = next(
valid_batches(num_validation_images))
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Load VGG
input_image, keep_prob, *vgg_layers = load_vgg(sess, vgg_path)
# Now create an FCN on top of VGG
output = layers(*vgg_layers, num_classes)
# Training functions
learning_rate = tf.placeholder(tf.float64,
shape=(),
name="learning_rate")
correct_label = tf.placeholder(image_dtype,
shape=(None, *image_shape, num_classes),
name="correct_label")
logits, train_op, cross_entropy_loss = optimize(
output, correct_label, learning_rate, num_classes)
# Prediction function
predictions = tf.argmax(output, axis=3)
# Finally, initial the
sess.run(tf.global_variables_initializer())
# Create a saver for training
# saver = tf.train.Saver(max_to_keep=1)
saver = None
# TRAIN!!!
post_fix = str(batch_size) + str(keep_prob_val)[1:4] + "_" + str(
epochs) + "_" + str(num_classes)
model_name = "models/model" + post_fix + "/model.ckpt"
frame_generator = train_nn(sess,
epochs,
batch_size,
get_batches_fn,
predictions,
train_op,
cross_entropy_loss,
input_image,
model_name=model_name,
correct_label=correct_label,
keep_prob=keep_prob,
learning_rate=learning_rate,
keep_prob_val=keep_prob_val,
learning_rate_val=learning_rate_val,
validation_images=validation_images,
saver=saver)
moviename = "videos/movie" + post_fix + ".mp4"
movify.process(frame_generator, output_path=moviename, fps=20)
# Process all of the test images
output_dir = 'images/' + post_fix
try:
os.makedirs(output_dir)
except Exception as e:
print(e)
image_dir = os.path.join(data_dir, 'data_road/testing/image_2')
overlay_prediction(sess, input_image, keep_prob, predictions,
image_dir, image_shape, output_dir)
# Now save those images into a movie
def frame_generator():
for file in os.listdir(output_dir):
yield scipy.misc.imresize(
scipy.misc.imread(os.path.join(output_dir, file)),
image_shape)
movify.process(frame_generator(),
output_path=output_dir + ".mp4",
fps=5)
def run():
runs_dir = './runs'
print("\n\nTesting for datatset presence......")
train_dat_count = tests.test_looking_for_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(vgg_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
glob_trainig_images_path, glob_labels_trainig_image_path,
image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Build NN using load_vgg, layers, and optimize function KK-DONE
# TF placeholders
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_dir)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
# tfImShape = tf.get_variable("image_shape")
# tfLogits = tf.get_variable("logits")
# tfKeepProb = tf.get_variable("keep_prob") TEM NO TF
print(100 * '*')
print(image_shape)
#(160, 576)
print(100 * '*')
print(logits)
#Tensor("Reshape:0", shape=(?, 2), dtype=float32)
print(100 * '*')
print(keep_prob)
#Tensor("keep_prob:0", dtype=float32)
print(100 * '*')
print(input_image)
#Tensor("image_input:0", shape=(?, ?, ?, 3), dtype=float32)
print(100 * '*')
init_op = tf.global_variables_initializer()
sess.run(init_op)
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate, train_dat_count)
folderToSaveModel = "model"
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
for i, var in enumerate(saver._var_list):
print('Var {}: {}'.format(i, var))
if not os.path.exists(folderToSaveModel):
os.makedirs(folderToSaveModel)
pathSaveModel = os.path.join(folderToSaveModel, "model.ckpt")
pathSaveModel = saver.save(sess, pathSaveModel)
print(colored("Model saved in path: {}".format(pathSaveModel),
'green'))
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
print('Loading VGG...')
layer_input_image, layer_keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
print('Building FCN graph...')
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
batch_size = 16
epochs = 25
channels = 3
learning_rate = tf.placeholder(tf.float32)
#keep_prob = tf.placeholder(tf.float32)
correct_label = tf.Variable(
tf.zeros(shape=(batch_size, image_shape[0], image_shape[1],
num_classes)))
input_image = tf.Variable(tf.zeros(shape=(batch_size, image_shape[0],
image_shape[1], channels)),
dtype=tf.float32)
print('Building optimize operation...')
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
sess.run(tf.global_variables_initializer())
# TODO: Train NN using the train_nn function
print('Train...')
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, layer_input_image, correct_label,
layer_keep_prob, learning_rate)
#saver = tf.train.Saver()
#saver.save(sess, 'trained_model', global_step=epochs)
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
print('Saving inference samples...')
helper.save_inference_samples(os.path.join(data_dir, 'test_results'),
data_dir, sess, image_shape, logits,
layer_keep_prob, layer_input_image)
if __name__=='__main__':
images_folder = './Train/CameraRGB/'
labels_folder = './Train/CameraSeg/'
image_shape = (352, 800)
num_classes = 3 # Vehicle, road, other
epochs = 50
batch_size = 8
train_model = 'vgg16'
#with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
with tf.Session() as sess:
nr_train_images = len(glob(os.path.join(images_folder, '*.png')))
get_batches_fn = gen_batch_function(images_folder, labels_folder, image_shape)
correct_label = tf.placeholder(tf.int32, shape=(None, image_shape[0], image_shape[1], num_classes))
learning_rate = tf.placeholder(tf.float32)
if train_model == 'vgg16':
keep_prob = tf.placeholder(tf.float32, name="keep_prob")
nn_input, nn_output = vgg16(keep_prob, num_classes, image_shape)
elif train_model == 'vgg16_pretrained':
vgg_path = './vgg'
nn_input, keep_prob, l3, l4, l7 = load_vgg(sess, vgg_path)
nn_output = layers(l3, l4, l7, num_classes)
elif train_model == 'resnet50':
def run():
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
# TODO: tests.test_for_kitti_dataset(data_dir) chyba niepotrzebne??
# TODO: test bach function - chyba działa
# get_batches_fn = helper.gen_batch_function('../data', image_shape)
# for X_batch, gt_batch in get_batches_fn(BATCH_SIZE):
# print(gt_batch[0].shape)
# plt.figure()
# plt.subplot(121)
# plt.imshow(X_batch[0])
# plt.subplot(122)
# plt.imshow(X_batch[0])
# plt.show()
# input('Pres enter to continue')
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
print('Pretrained model downloaded')
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function('../data', image_shape)
print('Prepared function to get batches')
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
with tf.Session() as session:
# Returns the three layers, keep probability and input layer from the vgg architecture
image_input, keep_prob, layer3, layer4, layer7 = load_vgg(session, vgg_path)
print('Get layers form vgg - Done')
# The resulting network architecture from adding a decoder on top of the given vgg model
model_output = layers(layer3, layer4, layer7, num_classes)
print('Added Decoder - Full network architecture On-Line')
# Returns the output logits, training operation and cost operation to be used
# - logits: each row represents a pixel, each column a class
# - train_op: function used to get the right parameters to the model to correctly label the pixels
# - cross_entropy_loss: function outputting the cost which we are minimizing,
# lower cost should yield higher accuracy
logits, train_op, cross_entropy_loss = optimize(model_output, correct_label, learning_rate, num_classes)
print('Model_optimised')
print('Initialize all variables - this might slow your computer, just do not worry and wait about 10 min')
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
# # Initialize all variables
session.run(tf.global_variables_initializer())
session.run(tf.local_variables_initializer())
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
print("Model build successful, starting training")
# Train the neural network
train_nn(session, EPOCHS, BATCH_SIZE, get_batches_fn,
train_op, cross_entropy_loss, image_input,
correct_label, keep_prob, learning_rate)
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
print('Training Done! :)')
# Run the model with the test images and save each painted output image (roads painted green)
helper.save_inference_samples(runs_dir, test_data_dir, session, image_shape, logits, keep_prob, image_input)
print('Saving model')
saver = tf.train.Saver()
output_dir = '../Trained_Model/' + str(time.time())
if os.path.exists(output_dir):
shutil.rmtree(output_dir)
os.makedirs(output_dir)
saver.save(session, output_dir + '/model.ckpt')
print("All done!")
def run():
tests.test_for_kitti_dataset(DATA_DIR)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(DATA_DIR)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
vgg_tensors = [
vgg_input_tensor, vgg_keep_prob_tensor, vgg_layer3_out_tensor,
vgg_layer4_out_tensor, vgg_layer7_out_tensor
] = load_vgg(sess, VGG_PATH)
output = layers(vgg_layer3_out_tensor,
vgg_layer4_out_tensor,
vgg_layer7_out_tensor,
num_classes=NUM_CLASSES)
#########################################################################################################
# THIS SECTION IS FOR DEBUGGING ONLY.
#
# # Print the shapes of the tensors (need to evaluate them, since not all dimensions are known statically).
# print('Tensor shapes:')
# sess.run(tf.local_variables_initializer())
# sess.run(tf.global_variables_initializer())
# tensors_to_print = [vgg_input_tensor,
# vgg_layer3_out_tensor,
# vgg_layer4_out_tensor,
# vgg_layer7_out_tensor,
# output]
# shapes = sess.run([tf.shape(t) for t in tensors_to_print],
# # Feed dummy data.
# {vgg_input_tensor: np.zeros([1, IMAGE_SHAPE[0], IMAGE_SHAPE[1], 3]),
# vgg_keep_prob_tensor: 1.0})
# name_to_shape = {t.name : shape for t, shape in zip(tensors_to_print, shapes)}
# print(name_to_shape)
# # Make sure the shape of the output matches the one of the input.
# in_shape = name_to_shape[vgg_input_tensor.name]
# out_shape = name_to_shape[output.name]
# np.testing.assert_array_equal(np.array(in_shape[:3]), np.array(out_shape[:3]))
#########################################################################################################
correct_label = tf.placeholder(
dtype=tf.int32,
shape=[None, IMAGE_SHAPE[0], IMAGE_SHAPE[1], NUM_CLASSES])
learning_rate = tf.placeholder(dtype=tf.float32, shape=[])
logits, train_op, loss = optimize(output, correct_label, learning_rate,
NUM_CLASSES)
get_batches_fn = helper.gen_batch_function(
os.path.join(DATA_DIR, 'data_road/training'), IMAGE_SHAPE)
train_nn(sess, NUM_EPOCHS, BATCH_SIZE, get_batches_fn, train_op, loss,
vgg_input_tensor, correct_label, vgg_keep_prob_tensor,
learning_rate)
helper.save_inference_samples(RUNS_DIR, DATA_DIR, sess, IMAGE_SHAPE,
logits, vgg_keep_prob_tensor,
vgg_input_tensor)
def run():
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
correct_label = tf.placeholder(tf.float32, [None, None, None, NUM_CLASSES],
name='correct_label')
#input_image = tf.placeholder(tf.float32, name='input_image')
#keep_prob = tf.placeholder(tf.float32, name='keep_prob')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
# final layer of the graph
layer_output = layers(layer3_out, layer4_out, layer7_out, NUM_CLASSES)
# optimizer
logits, train_op, cross_entropy_loss, iou_obj = optimize(
layer_output,
correct_label,
learning_rate,
NUM_CLASSES,
with_accuracy=True)
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
saver = tf.train.Saver(max_to_keep=5)
START_TIME = time.time()
# TODO: Train NN using the train_nn function
train_nn(sess, EPOCHS, BATCH_SIZE, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate, iou_obj, saver)
EPOCH_TIME = time.time()
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
END_TIME = time.time()
print("save time :", END_TIME - EPOCH_TIME, " TOTAL TIME:",
END_TIME - START_TIME)
def run():
print('start run()')
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
##tests.test_for_kitti_dataset(data_dir)
epochs = 7 # 10
batch_size = 7
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
## build inference graph
input_image, keep_prob, layer3, layer4, layer7 = load_vgg(sess, vgg_path)
##debug
'''
print('start debug 1 section')
for batch_image, batch_label in get_batches_fn(batch_size):
#print(type(layer7))
print(batch_image.shape)
temp = sess.run(input_image, feed_dict={input_image: batch_image})
print(temp.shape)
print(type(layer3))
temp = sess.run(layer7, feed_dict={input_image: batch_image, keep_prob: 0.5})
print(temp.shape)
break
print('debug 1 section over')
'''
##print('type of keep_prob: ' )
##print(type(keep_prob))
nn_last_layer = layers(layer3, layer4, layer7, num_classes)
## build training graph
correct_label = tf.placeholder(tf.float32, (None, None, None, num_classes))
learning_rate = tf.placeholder(tf.float32)
logits, train_op, cross_entropy_loss = optimize(nn_last_layer, correct_label, learning_rate, num_classes)
## run this initializer after your graph has been defined!!!
sess.run(tf.global_variables_initializer())
# TODO: Train NN using the train_nn function
train_nn(sess, epochs, batch_size, get_batches_fn, train_op, cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate)
writer = tf.summary.FileWriter("./tmp/log1", sess.graph)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
def run():
num_classes = 3
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
print("Loading data...")
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
print("Data loaded...")
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
"Building network..."
input_image, keep_prob, vgg_l3, vgg_l4, vgg_l7 = load_vgg(
sess, vgg_path)
output_layer = layers(vgg_l3, vgg_l4, vgg_l7, num_classes)
correct_label = tf.placeholder(tf.float32,
(None, None, None, num_classes),
name="correct_label")
learning_rate = tf.Variable(0.001,
name="learning_rate",
dtype=tf.float32)
logits, train_op, loss = optimize(output_layer, correct_label,
learning_rate, num_classes)
"Network built..."
# TODO:? Train NN using the train_nn function
print("Initializing network...")
epochs = 12
batch_size = 8
init_op = tf.global_variables_initializer()
saver = tf.train.Saver()
sess.run(init_op)
print("Network initialized...")
print("Training network...")
train_nn(sess, epochs, batch_size, get_batches_fn, train_op, loss,
input_image, correct_label, keep_prob, learning_rate)
print("Network trained...")
## Save the network here.
save_path = saver.save(sess, "data/models/final_model")
# TODO:? Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
print("Saved")
def run():
num_classes = 2
image_shape = (160, 576) # KITTI dataset uses 160x576 images
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
#PROB = 0.5
#RATE = 0.01
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
learning_rate = tf.placeholder(dtype=tf.float32, name='learning_rate')
correct_label = tf.placeholder(dtype=tf.float32,
shape=[None, None, None, num_classes],
name='correct_label')
epochs = 20
#batch_size = 256
#batch_size = 128
#batch_size = 64
batch_size = 32
#config = tf.ConfigProto()
#config.gpu_options.allow_growth = True
#with tf.Session(config=config) as sess:
with tf.Session() as sess:
# Need to define learning rate, # epochs, templates for learning rate and correct lables
# learning rate is just a float val, correct labels is a 4D value
# batch, height, width, # classes (tf placeholder)
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_probability, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
# Final layer of DNN (result)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
# gives logits, cross entropy
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label,
keep_probability, learning_rate)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_probability, input_image)
def run():
num_classes = 2
epochs = 30
batch_size = 5
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
action = 'eval'
#action='eval'
#action='train_evail'
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
try:
#try to load graph from previously saved model
#print("***************************************1***************************************")
imported_meta = tf.train.import_meta_graph("fcn.meta")
imported_meta.restore(sess, tf.train.latest_checkpoint('./'))
#print("***************************************2***************************************")
graph = tf.get_default_graph()
image_input = graph.get_tensor_by_name("image_input:0")
keep_prob = graph.get_tensor_by_name("keep_prob:0")
correct_label = graph.get_tensor_by_name("correct_label:0")
learning_rate = graph.get_tensor_by_name("learning_rate:0")
layer_output = graph.get_tensor_by_name("fcn_final:0")
print("loaded model form file")
except:
#print("***************************************3***************************************")
print("create model from scratch")
#Build NN using load_vgg, layers, and optimize function
image_input, keep_prob, layer3, layer4, layer7 = load_vgg(
sess, vgg_path)
layer_output = layers(layer3, layer4, layer7, num_classes)
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
logits, train_op, loss_op = optimize(layer_output, correct_label,
learning_rate, num_classes)
#Train NN using the train_nn function
if action == 'train' or action == 'train_eval':
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
loss_op, image_input, correct_label, keep_prob,
learning_rate)
if action == 'train' or action == 'train_eval':
saver = tf.train.Saver()
saver.save(sess, './fcn')
#Save inference data using helper.save_inference_samples
if action == 'eval' or action == 'train_eval':
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits, keep_prob,
image_input)
batch_size = 1
save_model_path = '3_datasets_batchsize1_lr00001_epoch' + str(epochs)
export_dir = './pb_dir_' + save_model_path + '_' + str(int(time.time()))
builder = tf.saved_model.builder.SavedModelBuilder(export_dir)
with tf.Session() as sess:
correct_label = tf.placeholder(tf.int32, [None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, ''),
image_shape)
# Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out,
num_classes)
logits, train_op, cross_entropy_loss = optimize(nn_last_layer,
correct_label,
learning_rate, num_classes)
sess.run(tf.global_variables_initializer())
# Train NN using the train_nn function
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
def run():
num_classes = 2
epochs = 45
batch_size = 4
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
log_dir = runs_dir + '/tf_logs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
tf.reset_default_graph()
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Augmentations implemented in gen_batch_function()
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
saver = tf.train.Saver()
tf_file_writer = tf.summary.FileWriter(log_dir, tf.get_default_graph())
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, tf_file_writer, epochs, batch_size, get_batches_fn,
train_op, cross_entropy_loss, input_image, correct_label,
keep_prob, learning_rate)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
# save trained model
saver.save(sess, './runs/semseg_model.ckpt')
# close tensorboard writer
tf_file_writer.close()
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
epochs = 32
batch_size = 1
# with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
with tf.Session() as sess:
#with tf.device("/gpu:0"):
# get layers from stored VGG
image_input, keep_prob, layer3, layer4, layer7 = load_vgg(
sess, vgg_path)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# create graph with skip connections, return last layer, inference part
final_layer = layers(layer3, layer4, layer7, num_classes)
correct_label = tf.placeholder(
tf.float32, [None, image_shape[0], image_shape[1], num_classes])
learning_rate = tf.constant(0.0001)
# continue with graph, add loss and training part
logits, train_op, cross_entropy_loss = optimize(
final_layer, correct_label, learning_rate, num_classes)
sess.run(tf.global_variables_initializer())
print('start training')
time_start = time.time()
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, image_input, correct_label, keep_prob,
learning_rate)
time_training = time.time() - time_start
print('training time: ', datetime.timedelta(seconds=time_training))
print('saving inference data')
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, image_input)
# OPTIONAL: Apply the trained model to a video
print('... finished')
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset
# instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
epochs = 20
batch_size = 8
# Allocate fixed memory
#https://stackoverflow.com/questions/34199233/
#how-to-prevent-tensorflow-from-allocating-the-totality-of-a-gpu-memory
config = tf.ConfigProto()
# only allocate 90% of the total memory of each GPU
config.gpu_options.allocator_type = 'BFC'
config.gpu_options.per_process_gpu_memory_fraction = 0.90
print("\nIn run...")
with tf.Session(config=config) as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
augment_image = helper.image_augmentation()
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
correct_label = tf.placeholder(tf.float32,
shape=[None, None, None, num_classes])
learning_rate = tf.placeholder(tf.float32)
# TODO: Train NN using the train_nn function
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate, augment_image)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Set parameters
epochs = 20
batch_size = 4
# TODO: set learning rate through params here
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
image_input, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
# Build Fully Convolutional Network
last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out,
num_classes)
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None, num_classes))
learning_rate = tf.placeholder(dtype=tf.float32)
# TODO: where does logits get used?`
logits, train_op, cross_entropy_loss = optimize(
last_layer, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, image_input, correct_label, keep_prob,
learning_rate)
# TODO: Save inference data using helper.save_inference_samples
# code snippet from ncondo
saver = tf.train.Saver()
saver.save(sess, 'checkpoints/model1.ckpt')
saver.export_meta_graph('checkpoints/model1.meta')
tf.train.write_graph(sess.graph_def, './checkpoints/', 'model1.pb',
False)
# Save image outputs
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, image_input)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = '/data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
# input_image and keep_prob are placeholders
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
# Placeholder for variable resolution images
# (the placeholders are filled with values during the training and loading of the images)
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None, num_classes))
learning_rate = tf.placeholder(dtype=tf.float32)
logits, training_operation, cross_entropy_loss = optimize(
nn_last_layer=layer_output,
correct_label=correct_label,
learning_rate=learning_rate,
num_classes=num_classes)
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
get_batches_fn=get_batches_fn,
train_op=training_operation,
cross_entropy_loss=cross_entropy_loss,
input_image=input_image,
correct_label=correct_label,
keep_prob=keep_prob,
learning_rate=learning_rate)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
# OPTIONAL: Apply the trained model to a video
print('All finished.')
def run():
num_classes = 2
#image_shape = (260, 576)
image_shape = (256, 512)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.per_process_gpu_memory_fraction = 0.5
correct_label = tf.placeholder(tf.float32,
shape=(None, image_shape[0], image_shape[1],
2))
learning_rate = tf.placeholder(tf.float32)
with tf.Session(config=config) as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
image_input, keep_prob, layer3, layer4, layer7 = load_vgg(
sess, vgg_path)
#debug shapes onebyone, trans1, trans2, nn_last_out = layers(layer3, layer4, layer7, num_classes)
nn_last_out = layers(layer3, layer4, layer7, num_classes)
### TODO
logits, train_op, cross_entropy_loss = \
optimize(nn_last_out, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
#batch_size = 1;
batch_size = 20
epochs = 1000
init = tf.global_variables_initializer()
sess.run(init)
""" ### debug the dynamic shapes
sess_out = sess.run([tf.shape(layer3),
tf.shape(layer4),
tf.shape(layer7),
tf.shape(onebyone),
tf.shape(trans1),
tf.shape(trans2),
tf.shape(nn_last_out),
tf.shape(logits),
], feed_dict={image_input: np.zeros(
(1, image_shape[0], image_shape[1], 3)),
'keep_prob:0': 0.5})
print ("*** dyn shapes ")
names = ["layer3", "layer4", "layer7", "onebyone",
"trans1", "trans2", "nn_last_out", "logtis" ]
for n, s in zip(names, sess_out):
print(n, s)
"""
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, image_input, correct_label, keep_prob,
learning_rate)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, image_input)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
epochs = 40 # tested on 10, 30, 40, 60 epochs
# 40 epochs: loss ~0.025
# slows down significantly after 40 epochs, starts to overfit
# after 30 epochs: loss ~0.05, with artifacts on cars, not ideal lighting
batch_size = 20
# large batch sizes lead to out of memory error
#keep_prob = 0.5
#learning_rate = 0.001
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
vgg_input_tensor, vgg_keep_prob_tensor, vgg_layer3_out_tensor, vgg_layer4_out_tensor, vgg_layer7_out_tensor = load_vgg(
sess, vgg_path)
deconv3 = layers(vgg_layer3_out_tensor, vgg_layer4_out_tensor,
vgg_layer7_out_tensor, num_classes)
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None, num_classes))
learning_rate = tf.placeholder(
dtype=tf.float32) # can not convert float to tensor error
logits, train_op, cross_entropy_loss = optimize(
deconv3, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, vgg_input_tensor, correct_label,
vgg_keep_prob_tensor, learning_rate)
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, vgg_keep_prob_tensor,
vgg_input_tensor)
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
epochs = 50
batch_size = 5
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
# TF Placeholders
correct_label = tf.placeholder(dtype=tf.float32,
shape=(None, None, None, num_classes),
name='correct_label')
learning_rate = tf.placeholder(dtype=tf.float32, name='learning_rate')
vgg_input, vgg_keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out,
num_classes)
logits, train_op, cross_entropy_loss = optimize(
nn_last_layer, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
sess.run(tf.global_variables_initializer())
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, vgg_input, correct_label, vgg_keep_prob,
learning_rate)
# 'Saver' op to save and restore all the variables
saver = tf.train.Saver()
save_path = saver.save(sess, 'checkpoints/model1.ckpt')
saver.export_meta_graph('checkpoints/model1.meta')
tf.train.write_graph(sess.graph_def, './checkpoints/', 'model1.pb',
False)
print("Model saved in file: %s" % save_path)
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, vgg_keep_prob, vgg_input)
def run():
num_classes = 2
image_shape = (160, 576)
# data_dir = './data'
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
correct_label = tf.placeholder(tf.int32, [None, None, None, num_classes], name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(layer_output,
correct_label, learning_rate, num_classes)
# set up a saver object
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state('./model_ckpt/')
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
# Train NN using the train_nn function
train_nn(sess, 50, 10, get_batches_fn, train_op, cross_entropy_loss, input_image,
correct_label, keep_prob, learning_rate, saver)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
# OPTIONAL: Apply the trained model to a video
# Import everything needed to edit/save/watch video clips
imp=helper.ImageProcess(sess,keep_prob,input_image,logits,image_shape)
videogen = skvideo.io.vreader('./driving.mp4')
writer = skvideo.io.FFmpegWriter("./runs/results.mp4")
for i,frame in enumerate(videogen):
if i<5:
print("frame:",i)
new_frame=imp.pipeline(frame)
writer.writeFrame(new_frame)
writer.close()
def run():
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
#helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
path = os.path.join(data_dir, 'data_road/training')
print(path)
get_batches_fn = helper.gen_batch_function(path, image_shape)
#
epochs = 50
batch_size = 32
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
#
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer_3, layer_4, layer_7 = load_vgg(
sess, vgg_path)
layer_output = layers(layer_3, layer_4, layer_7, num_classes)
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter('/tmp/log/train', sess.graph)
tf.global_variables_initializer().run()
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
# OPTIONAL: Apply the trained model to a video
writer.close()
def run():
num_classes = NUM_CLASSES
image_shape = IMAGE_SHAPE
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg16/vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
# TODO: Train NN using the train_nn function
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
# OPTIONAL: Apply the trained model to a video
epochs = EPOCHS
batch_size = BATCH_SIZE
# TF placeholders
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
input_image, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
#sess.run(tf.Print(vgg_layer7_out, [tf.shape(vgg_layer7_out)]))
#nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes)
nn_last_layer = layers(vgg_layer3_out,
vgg_layer4_out,
vgg_layer7_out,
num_classes,
sess=sess,
vgg_input=input_image,
keep_prob=keep_prob)
logits, train_op, cross_entropy_loss = optimize(
nn_last_layer, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate)
# TODO: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
print("running on images - done")
def run():
num_classes = CLASSES
image_shape = IMAGE_SHAPE
data_dir = DATA_DIR
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Build NN using load_vgg, layers, and optimize function
correct_label = tf.placeholder(tf.int32,
[None, None, None, num_classes],
name='correct_label')
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
input_image, keep_prob, vgg_layer3_out, vgg_layer4_out, vgg_layer7_out = load_vgg(
sess, vgg_path)
nn_last_layer = layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out,
num_classes)
logits, train_op, cross_entropy_loss, decaying_learning_rate = optimize(
nn_last_layer, correct_label, learning_rate, num_classes)
start_time = time.time()
epoch_loss = train_nn(sess, EPOCHS, BATCH_SIZE, get_batches_fn,
train_op, cross_entropy_loss, input_image,
correct_label, keep_prob, learning_rate,
decaying_learning_rate)
end_time = time.time()
elapsed = end_time - start_time
hours = elapsed // 3600
minutes = (elapsed % 3600) // 60
seconds = (elapsed % 3600) % 60
print(
"Training time: {:.0f} hours {:.0f} minutes {:.0f} seconds".format(
hours, minutes, seconds))
log_file_path = './' + str(EPOCHS) + '_log.txt'
log_file = open(log_file_path, 'w')
log_file.write('Epoch,Loss\n')
for key in epoch_loss.keys():
log_file.write('{},{}\n'.format(key, epoch_loss[key]))
log_file.close()
start_time = time.time()
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
end_time = time.time()
elapsed = end_time - start_time
hours = elapsed // 3600
minutes = (elapsed % 3600) // 60
seconds = (elapsed % 3600) % 60
print("Inference time: {:.0f} hours {:.0f} minutes {:.0f} seconds".
format(hours, minutes, seconds))
# Save model for later use
#saver = tf.train.Saver()
#saver.save(sess, MODEL_DIR + '/model_meta')
#print("Model saved to {} directory".format(MODEL_DIR))
# OPTIONAL: Apply the trained model to a video
start_time = time.time()
processed_frames = []
# Load video
#video_clip = VideoFileClip(VIDEO_DIR + '/project_video.mp4')
video_clip = VideoFileClip(VIDEO_DIR + '/solidWhiteRight.mp4')
frame_counter = 1
for frame in video_clip.iter_frames():
processed_frame = helper.segment_single_image(
sess, logits, keep_prob, input_image, frame, image_shape)
# Collect processed frame
processed_frames.append(processed_frame)
print("Frame {} processed".format(frame_counter))
frame_counter += 1
# Stitcha all frames to get the video
processed_video = ImageSequenceClip(processed_frames,
fps=video_clip.fps)
processed_video.write_videofile(VIDEO_DIR +
'/solidWhiteRight_processed.mp4',
audio=False)
print("Processed video written to {} directory".format(VIDEO_DIR))
end_time = time.time()
elapsed = end_time - start_time
hours = elapsed // 3600
minutes = (elapsed % 3600) // 60
seconds = (elapsed % 3600) % 60
print(
"Video processing time: {:.0f} hours {:.0f} minutes {:.0f} seconds"
.format(hours, minutes, seconds))
def run():
#tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
# Memory parameters https://medium.com/@lisulimowicz/tensorflow-cpus-and-gpus-configuration-9c223436d4ef
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
tf.global_variables_initializer()
tf.local_variables_initializer()
# Placeholders
labels = tf.placeholder(tf.float32,
shape=[None, None, None, num_classes])
learning_rate = tf.placeholder(tf.float32)
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Build NN using load_vgg, layers, and optimize function
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
logits, train_op, cross_entropy_loss = optimize(
layer_output, labels, learning_rate, num_classes)
# Train NN using the train_nn function
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, labels, keep_prob,
learning_rate)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
# Apply the trained model to a video
def complete_pipeline(img):
"""
Sample code taken from gen_test_output helper method
"""
image = scipy.misc.imresize(img, image_shape)
im_softmax = sess.run([tf.nn.softmax(logits)], {
keep_prob: 1.0,
input_image: [image]
})
im_softmax = im_softmax[0][:, 1].reshape(image_shape[0],
image_shape[1])
segmentation = (im_softmax > 0.5).reshape(image_shape[0],
image_shape[1], 1)
mask = np.dot(segmentation, np.array([[0, 255, 0, 127]]))
mask = scipy.misc.toimage(mask, mode="RGBA")
street_im = scipy.misc.toimage(image)
street_im.paste(mask, box=None, mask=mask)
return np.array(street_im)
def video_pipeline(current_image):
''' Complete video pipeline '''
return complete_pipeline(current_image)
def generate_video(output, process_image):
''' Generate a video '''
print('Generating video to: {}'.format(output))
clip1 = VideoFileClip(
input_file) #.subclip(1,10) # 0,5 TODO remove this
video_clip = clip1.fl_image(process_image)
video_clip.write_videofile(output, audio=False)
clip1.reader.close()
return output
video_output = generate_video(output_file, video_pipeline)
def run():
#global variables
global tensorboard, trainning
#Arguments
parser = argparse.ArgumentParser(
description='Semantic Segmentation Trainning')
parser.add_argument('-tb',
'--tensorboard',
action='store_true',
help='Save data for TensorBoard')
parser.add_argument('-to',
'--trainning_off',
action='store_false',
help='Set Trainning OFF for the network')
parser.add_argument('-v',
'--video',
default=None,
type=str,
help='Apply Segmentation FCN network over the video')
args = parser.parse_args()
tensorboard = args.tensorboard
trainning = args.trainning_off
video = args.video
#Tranning values
epochs = 8
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
batch_size = 4
num_classes = 2
image_shape = (160, 576)
data_dir = './data'
runs_dir = './runs'
tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(
os.path.join(data_dir, 'data_road/training'), image_shape)
# Build NN using load_vgg, layers, and optimize function
# Load VGG
input_tensor, keep_prob_tensor, layer3_tensor, layer4_tensor, layer7_tensor = load_vgg(
sess, vgg_path)
# Transfor into a FCN
output = layers(layer3_tensor, layer4_tensor, layer7_tensor,
num_classes)
# Load Optmizer
correct_label = tf.placeholder(tf.float32,
[None, None, None, num_classes],
name='correct_label')
logits, train_op, cross_entropy_loss = optimize(
output, correct_label, learning_rate, num_classes)
# Train NN using the train_nn function
if trainning:
print("Trainning Model")
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_tensor, correct_label,
keep_prob_tensor, learning_rate)
# Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, data_dir, sess,
image_shape, logits,
keep_prob_tensor, input_tensor)
else:
print("Loading pre-trained model")
#load model
saver = tf.train.Saver()
saver.restore(sess, "./data/model/model.ckpt")
#Apply the trained model to a video
if video is not None:
print("Loading video " + video)
print("Creating Video, saved at result.mp4")
#clip = VideoFileClip('driving_10.mp4')
clip = VideoFileClip(video)
create_video(clip, sess, logits, keep_prob_tensor, input_tensor,
image_shape)
def run():
num_classes = 4 # CW: red, yellow, green, unknown
proportion_train = 0.75 # rest validation. Don't have big enough set for separate test set really!
# CW: both real Carla images and simulator exports are 800x600.
# We might find shrinking them helps with performance in terms of
# speed or memory, though classification quality will suffer if
# we go too far. Semantic segregation project chose a size with
# reasonably high power-of-two factors to allow for the repeated halving
# of resolution going up the CNN funnel (160x576, or 2^5*5 x 2^6*9)
# without any awkward padding issues. 800 already divides nicely,
# but 600 is 2^3*3*5^2 so it can only be halved cleanly 3 times.
# But there is not too much happening at the bottom of any of our
# images, so clipping a little to 800x576 should be quite nice,
# maybe with a 1/2 or 1/4 shrink to speed things up.
# TODO clipping logic -- for now just shrinking to avoid code changes
image_shape = (
288, 384
) # Initial experiment size (heightxwidth) -- out of GPU memory trying 576*800. Multiples of 32.
data_dir = './data'
runs_dir = './runs'
# Walkthrough: maybe ~6 epochs to start with. Batches not too big because large amount of information.
epochs = 20 # To get started
batch_size = 1 # Already getting memory warnings!
# Other hyperparameters in train_nn(); would have put them here but went with template calling structure
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(data_dir)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
with tf.Session() as sess:
# Path to vgg model
vgg_path = os.path.join(data_dir, 'vgg')
# Split images into training and validation sets
training_image_paths, validation_image_paths = \
helper.get_split_image_paths(proportion_train, '../data/training_images')
# Create function to get batches
get_batches_fn = helper.gen_batch_function(training_image_paths,
image_shape, num_classes)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# Walkthrough: correct labels will be 4D (batch, height, width, num classes)
# CW: see my comments in get_batches_fn() to remind self of why... final (num classes) axis is one-hot
# with [0]=1 for background and [1]=1 for (any) road
# DONE: Build NN using load_vgg, layers, and optimize function
# CW: load VGG16 (actually already modified version for FCN) and pick out tensors corresponding
# to layers we want to attach to
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, vgg_path)
# CW: add our own layers to do transpose convolution skip connections from encoder
layer_output = layers(layer3_out, layer4_out, layer7_out,
num_classes) # get final layer out
# CW: for debug, want to visualise model structure in Tensorboard; initially did this
# before adding my layers to understand how to connect to unmodified VGG layers. Now
# doing afterwards to include picture in write-up that includes my layers.
if True: # Turned off for most runs when not debugging
print(tf.trainable_variables()
) # also trying to understand what we've got
log_path = os.path.join(vgg_path, 'logs')
writer = tf.summary.FileWriter(log_path, graph=sess.graph)
# Then visualise as follows:
# >tensorboard --logdir=C:\Users\UK000044\git\CarND-Semantic-Segmentation\data\vgg\logs --host localhost
# Open http://localhost:6006 in browser (if don't specify --host, in Windows 10 uses PC name, and
# localhost or 127.0.0.1 find no server, whereas http://pc_name:6006 does work)
# CW: add operations to classify each pixel by class and assess performance
# Input label size dynamic because have odd number of images as last batch; can get away without specifying
# shape in complete detail up front but specifying those we know to hopefully make bugs more apparent
correct_label = tf.placeholder(tf.float32,
shape=[None, num_classes],
name='correct_label')
# Reshape labels as one-hot matrix spanning all of the pixels from all of the images concatenated together
flattened_label = tf.reshape(correct_label, (-1, num_classes),
name='flattened_label')
learning_rate = tf.placeholder(tf.float32,
shape=(),
name='learning_rate')
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
# CW: have to initialise variables at some point
init_op = tf.global_variables_initializer()
sess.run(init_op)
# DONE: Train NN using the train_nn function
train_nn(sess, epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, flattened_label, keep_prob,
learning_rate)
# DONE: Save inference data using helper.save_inference_samples
helper.save_inference_samples(runs_dir, validation_image_paths, sess,
image_shape, logits, keep_prob,
input_image)
def run(data_arg, vgg_arg, output_arg, run_arg):
num_classes = 2
image_shape = (
256, 256
) # KITTI dataset uses 160x576 images, puzzle dataset uses 256x256
data_dir = data_arg
vgg_path = vgg_arg
runs_dir = run_arg
# tests.test_for_kitti_dataset(data_dir)
# Download pretrained vgg model
helper.maybe_download_pretrained_vgg(vgg_path)
# OPTIONAL: Train and Inference on the cityscapes dataset instead of the Kitti dataset.
# You'll need a GPU with at least 10 teraFLOPS to train on.
# https://www.cityscapes-dataset.com/
# own parameters
n_epochs = 1
batch_size = 4
print("==========\nSession start.\n==========")
with tf.Session() as sess:
# Path to vgg model
# Create function to get batches
get_batches_fn = helper.gen_batch_function(os.path.join(
data_dir, 'training'),
image_shape,
puzzle=True)
# OPTIONAL: Augment Images for better results
# https://datascience.stackexchange.com/questions/5224/how-to-prepare-augment-images-for-neural-network
# TODO: Build NN using load_vgg, layers, and optimize function
print("Building NN...")
input_image, keep_prob, layer3_out, layer4_out, layer7_out = load_vgg(
sess, os.path.join(vgg_path, "vgg"))
layer_output = layers(layer3_out, layer4_out, layer7_out, num_classes)
# create placeholders
correct_label = tf.placeholder(tf.int32, (None, None, None, None),
name="correct_label")
learning_rate = tf.placeholder(tf.float32, name='learning_rate')
logits, train_op, cross_entropy_loss = optimize(
layer_output, correct_label, learning_rate, num_classes)
# TODO: Train NN using the train_nn function
print("Training NN...")
train_nn(sess, n_epochs, batch_size, get_batches_fn, train_op,
cross_entropy_loss, input_image, correct_label, keep_prob,
learning_rate)
# TODO: Save inference data using helper.save_inference_samples
# helper.save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image)
print("Saving examples")
helper.save_inference_samples(runs_dir, data_dir, sess, image_shape,
logits, keep_prob, input_image)
print("saving model...")
# Save the variables to disk.
saver = tf.train.Saver()
save_path = saver.save(sess, output_arg)
print("Model saved in path: %s" % save_path)
# OPTIONAL: Apply the trained model to a video
print("==========\nSession end.\n==========")
