import re import os import numpy as np import tensorflow as tf import json from keras import backend as K from keras.preprocessing.image import Iterator from keras.preprocessing.image import ImageDataGenerator from keras.utils.generic_utils import Progbar from keras.models import model_from_json import utils import img_utils from common_flags import FLAGS test_datagen = utils.DroneDataGenerator(rescale=1. / 255) y = img_utils.load_img("data/testing/HMB_3/images/1479425597710017397.jpg", grayscale=True, crop_size=(200, 200), target_size=(320, 240)) x = test_datagen.random_transform(y, seed=None) x = test_datagen.standardize(x) batch_x = np.zeros((1, ) + (200, 200, 1), dtype=K.floatx()) batch_x[0] = x json_model_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.json_model_fname) model = utils.jsonToModel(json_model_path) # Load weights weights_load_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.weights_fname)
def _main(): output_dim = 2 batch_size = 16 experiment_rootdir = '/home/jing/PycharmProjects/dcnn/new_model' train_dir = '/home/jing/PycharmProjects/dcnn/training' val_dir = '/home/jing/PycharmProjects/dcnn/val' epochs = 100 img_mode = 'rgb' img_channels = 3 img_width = 320 img_height = 240 crop_img_height = 200 crop_img_width = 200 initial_epoch = 0 # Generate training data with real-time augmentation train_datagen = utils.DroneDataGenerator(rotation_range=0.2, rescale=1. / 255, width_shift_range=0.2, height_shift_range=0.2) train_data_generator = train_datagen.flow_from_directory( train_dir, shuffle=True, color_mode=img_mode, target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size=batch_size) # Generate validation data with real-time augmentation val_datagen = utils.DroneDataGenerator(rescale=1. / 255) val_data_generator = val_datagen.flow_from_directory( val_dir, shuffle=True, color_mode=img_mode, target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size=FLAGS.batch_size) model = resnet8(img_width, img_height, img_channels, output_dim) # Initialize loss weights model.gama = tf.Variable(1, trainable=False, name='alpha', dtype=tf.float32) # Initialize number of samples for hard-mining model.k_mse_v = tf.Variable(batch_size, trainable=False, name='k_mse_v', dtype=tf.int32) model.k_mse_x = tf.Variable(batch_size, trainable=False, name='k_mse_x', dtype=tf.int32) optimizer = optimizers.Adam(decay=1e-5) # Configure training process model.compile( loss=[hard_mining_mse(model.k_mse_v), hard_mining_mse(model.k_mse_x)], optimizer=optimizer, loss_weights=[model.gama, 1]) # Save model with the lowest validation loss weights_path = os.path.join(experiment_rootdir, 'weights_{epoch:03d}.h5') writeBestModel = ModelCheckpoint(filepath=weights_path, monitor='val_loss', save_best_only=True, save_weights_only=True) # Train model steps_per_epoch = int(np.ceil(train_data_generator.samples / batch_size)) validation_steps = int(np.ceil(val_data_generator.samples / batch_size)) print('Training ------------') model.fit_generator(train_data_generator, epochs=epochs, steps_per_epoch=steps_per_epoch, callbacks=writeBestModel, validation_data=val_data_generator, validation_steps=validation_steps, initial_epoch=initial_epoch)
def _main(): # Create the experiment rootdir if not already there if not os.path.exists(FLAGS.experiment_rootdir): os.makedirs(FLAGS.experiment_rootdir) # Input image dimensions img_width, img_height = FLAGS.img_width, FLAGS.img_height # Cropped image dimensions crop_img_width, crop_img_height = FLAGS.crop_img_width, FLAGS.crop_img_height # Image mode if FLAGS.img_mode=='rgb': img_channels = 3 elif FLAGS.img_mode == 'grayscale': img_channels = 1 else: raise IOError("Unidentified image mode: use 'grayscale' or 'rgb'") # Output dimension (one for steering and one for collision) output_dim = 1 # Generate training data with real-time augmentation train_datagen = utils.DroneDataGenerator(rotation_range = 0.2, rescale = 1./255, width_shift_range = 0.2, height_shift_range=0.2) train_generator = train_datagen.flow_from_directory(FLAGS.train_dir, shuffle = True, color_mode=FLAGS.img_mode, target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size = FLAGS.batch_size) # Generate validation data with real-time augmentation val_datagen = utils.DroneDataGenerator(rescale = 1./255) val_generator = val_datagen.flow_from_directory(FLAGS.val_dir, shuffle = True, color_mode=FLAGS.img_mode, target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size = FLAGS.batch_size) # Weights to restore weights_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.weights_fname) initial_epoch = 0 if not FLAGS.restore_model: # In this case weights will start from random weights_path = None else: # In this case weigths will start from the specified model initial_epoch = FLAGS.initial_epoch # Define model model = getModel(crop_img_width, crop_img_height, img_channels, output_dim, weights_path) # Save the architecture of the model as png plot_arch_path = os.path.join(FLAGS.experiment_rootdir, 'architecture.png') plot_model(model, to_file=plot_arch_path) # Serialize model into json json_model_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.json_model_fname) utils.modelToJson(model, json_model_path) # Train model trainModel(train_generator, val_generator, model, initial_epoch)
def _main(): if not os.path.exists(FLAGS.experiment_rootdir): os.makedirs(FLAGS.experiment_rootdir) base_model=MobileNet(weights='imagenet',include_top=False) #imports the mobilenet model and discards the last 1000 neuron layer. # Print mobilenet summary x=base_model.output x=GlobalAveragePooling2D()(x) x=Dense(1024,activation='relu')(x) #we add dense layers so that the model can learn more complex functions and classify for better results. x=Dense(1024,activation='relu')(x) #dense layer 2 x=Dense(512,activation='relu')(x) #dense layer 3 steering=Dense(1,activation='softmax')(x) #final layer with softmax activation collision=Dense(1,activation='softmax')(x) #final layer with softmax activation model=Model(inputs=base_model.input,outputs=[steering,collision]) # Print mobilenet summary for i,layer in enumerate(model.layers[:(len(model.layers)-4)]): print('Setting as non-trainable',i,layer.name) layer.trainable=False for i,layer in enumerate(model.layers[(len(model.layers)-4):]): print('Setting as trainable',i,layer.name) layer.trainable=True crop_img_width, crop_img_height = FLAGS.crop_img_width, FLAGS.crop_img_height img_width, img_height = FLAGS.img_width, FLAGS.img_height # Generate training data with real-time augmentation train_datagen = utils.DroneDataGenerator(rotation_range = 0.2, rescale = 1./255, width_shift_range = 0.2, height_shift_range=0.2) train_generator = train_datagen.flow_from_directory(FLAGS.train_dir, shuffle = True, color_mode='rgb', target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size = FLAGS.batch_size) val_datagen = utils.DroneDataGenerator(rescale = 1./255) val_generator = val_datagen.flow_from_directory(FLAGS.val_dir, shuffle = True, color_mode='rgb', target_size=(img_width, img_height), crop_size=(crop_img_height, crop_img_width), batch_size = FLAGS.batch_size) # Serialize model into json json_model_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.json_model_fname) utils.modelToJson(model, json_model_path) initial_epoch = FLAGS.initial_epoch model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy']) #step_size_train=train_generator.samples//FLAGS.batch_size step_size_train = int(np.ceil(train_generator.samples / FLAGS.batch_size)) validation_steps = int(np.ceil(val_generator.samples / FLAGS.batch_size)) model.fit_generator(train_generator, steps_per_epoch=step_size_train, epochs=FLAGS.epochs, validation_data=val_generator, validation_steps = validation_steps, initial_epoch=initial_epoch)
def _main(): # Set testing mode (dropout/batchnormalization) K.set_learning_phase(TEST_PHASE) # Generate testing data test_datagen = utils.DroneDataGenerator(rescale=1. / 255) test_generator = test_datagen.flow_from_directory( FLAGS.test_dir, shuffle=False, color_mode=FLAGS.img_mode, target_size=(FLAGS.img_width, FLAGS.img_height), crop_size=(FLAGS.crop_img_height, FLAGS.crop_img_width), batch_size=FLAGS.batch_size) # Load json and create model json_model_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.json_model_fname) model = utils.jsonToModel(json_model_path) # Load weights weights_load_path = os.path.join(FLAGS.experiment_rootdir, FLAGS.weights_fname) try: model.load_weights(weights_load_path) print("Loaded model from {}".format(weights_load_path)) except: print("Impossible to find weight path. Returning untrained model") # Compile model model.compile(loss='mse', optimizer='adam') # Get predictions and ground truth n_samples = test_generator.samples nb_batches = int(np.ceil(n_samples / FLAGS.batch_size)) predictions, ground_truth, t = utils.compute_predictions_and_gt( model, test_generator, nb_batches, verbose=1) # Param t. t=1 steering, t=0 collision t_mask = t == 1 # ************************* Steering evaluation *************************** # Predicted and real steerings pred_steerings = predictions[t_mask, 0] real_steerings = ground_truth[t_mask, 0] # Compute random and constant baselines for steerings random_steerings = random_regression_baseline(real_steerings) constant_steerings = constant_baseline(real_steerings) # Create dictionary with filenames dict_fname = { 'test_regression.json': pred_steerings, 'random_regression.json': random_steerings, 'constant_regression.json': constant_steerings } # Evaluate predictions: EVA, residuals, and highest errors print('direction:') for fname, pred in dict_fname.items(): abs_fname = os.path.join(FLAGS.experiment_rootdir, fname) evaluate_regression(pred, real_steerings, abs_fname) # Write predicted and real steerings dict_test = { 'pred_steerings': pred_steerings.tolist(), 'real_steerings': real_steerings.tolist() } utils.write_to_file( dict_test, os.path.join(FLAGS.experiment_rootdir, 'predicted_and_real_steerings.json')) # ************************* collision(translation) evaluation *************************** # Predicted and real labels pred_prob = predictions[~t_mask, 1] real_labels = ground_truth[~t_mask, 1] # Compute random and constant baselines for steerings random_labels = random_regression_baseline(real_labels) constant_labels = constant_baseline(real_labels) # Create dictionary with filenames dict_fname = { 'translation-test_regression.json': pred_prob, 'translation-random_regression.json': random_labels, 'translation-constant_regression.json': constant_labels } # Evaluate predictions: EVA, residuals, and highest errors print('translation:') for fname, pred in dict_fname.items(): abs_fname = os.path.join(FLAGS.experiment_rootdir, fname) evaluate_regression(pred, real_labels, abs_fname) # Write predicted and real steerings dict_test = { 'pred_labels': pred_prob.tolist(), 'real_probs': real_labels.tolist() } utils.write_to_file( dict_test, os.path.join(FLAGS.experiment_rootdir, 'predicted_and_real_labels.json'))
import utils import os import tensorflow as tf import cnn_models from keras import optimizers import logz from common_flags import FLAGS import log_utils from keras.callbacks import ModelCheckpoint OUTPUT_PATH = '/home/stmoon/Project/AE590/dronet/output/' TRAIN_DATA_PATH = '/home/stmoon/Project/AE590/deeplab/out' TEST_DATA_PATH = '/home/stmoon/Project/AE590/deeplab/test_data' train_datagen = utils.DroneDataGenerator(rotation_range=0.2, rescale=1. / 255, width_shift_range=0.2, height_shift_range=0.2) train_data_generator = train_datagen.flow_from_directory(TRAIN_DATA_PATH) test_data_generator = train_datagen.flow_from_directory(TEST_DATA_PATH) model = cnn_models.resnet8(700, 500, 1, 1) # Serialize model into json json_model_path = os.path.join(OUTPUT_PATH, "model.json") utils.modelToJson(model, json_model_path) optimizer = optimizers.Adam(decay=1e-5) model.alpha = tf.Variable(1, trainable=False, name='alpha', dtype=tf.float32) #model.beta = tf.Variable(0, trainable=False, name='beta', dtype=tf.float32)