def setUp(self): import json testcase_config_filename = '/tmp/testcase_config.json' testcase_config = { "data_path": "utils/testing.txt", "data_path_samples": "/tmp/in_dir/images", "data_path_gt": "/tmp/in_dir/maps", "data_path_pred": "/tmp/in_dir/pred_maps", "is_training": "False", "validation_percentage": "10", "testing_percentage": "10", "weights_file": "/tmp/vgg16_weights.npz", "dataset_name": "crowd_maps", "work_dir": "/tmp/work_dir/", "exp_name": "crowdnetreg_debug", "checkpoint_to_restore": "no_restore", "num_epochs": 20, "learning_rate": 0.001, "batch_size": 10, "max_to_keep": 5 } with open(testcase_config_filename, 'w') as f: json.dump(testcase_config, f) testcase_config_reloaded = config.process_config( testcase_config_filename) self.dsetsloader = datahandler.FileListDatasetLoader( testcase_config_reloaded)
def evaluate(): args = get_args() config = process_config(args.config) # load dataset file dataset = load_pair_paths(config) metric_names = [] results = [] model_names = [] config.unpool_type = "simple" config.exp_name = "nyu-resnet-berhu-aug-30-simple-upproject" config.prediction_model_name = "model-150-0.19.km" config.model_dir = os.path.join("../experiments", config.exp_name, "model/") config.tensorboard_dir = os.path.join("../experiments", config.exp_name, "log/") metric_names, result = extract(dataset, config) results.append(result) model_names.append(config.unpool_type + "_"+ config.model_type+ "_" + config.loss_type) config.unpool_type = "deconv" config.exp_name = "nyu-resnet-berhu-aug-30-deconv-upproject" config.prediction_model_name = "model-150-0.21.km" config.model_dir = os.path.join("../experiments", config.exp_name, "model/") config.tensorboard_dir = os.path.join("../experiments", config.exp_name, "log/") metric_names, result = extract(dataset, config) results.append(result) model_names.append(config.unpool_type + "_"+ config.model_type+ "_" + config.loss_type) config.unpool_type = "checkerboard" config.exp_name = "nyu-resnet-berhu-aug-30-checkerboard-upproject" config.prediction_model_name = "model-150-0.20.km" config.model_dir = os.path.join("../experiments", config.exp_name, "model/") config.tensorboard_dir = os.path.join("../experiments", config.exp_name, "log/") metric_names, result = extract(dataset, config) results.append(result) model_names.append(config.unpool_type + "_"+ config.model_type+ "_" + config.loss_type) config.unpool_type = "resize" config.exp_name = "nyu-resnet-berhu-aug-30-resize-upproject" config.prediction_model_name = "model-150-0.20.km" config.model_dir = os.path.join("../experiments", config.exp_name, "model/") config.tensorboard_dir = os.path.join("../experiments", config.exp_name, "log/") metric_names, result = extract(dataset, config) results.append(result) model_names.append(config.unpool_type + "_"+ config.model_type+ "_" + config.loss_type) print(metric_names) print(results) print(model_names)
def __init__(self, configuration_file_path, gloves_name=None): """ :param model_path: path to the static gestures model :param configuration_file_path: path to the configuration file to load :param glove_path: path to a glove if a pretrained glove is selected """ self.configuration_file = process_config( configuration_file_path) # load the configuration file #static_model path #model_path = self.configuration_file["static_model_path"] model_path = eval(self.configuration_file["static_model_path"]) #print("static model path:",model_path) self.static_model = load_model(model_path) self.mouse_controller = controllers.MouseController( self.configuration_file) self.keyboard_controller = controllers.KeyboardController( self.configuration_file) self.dynamic_controller = controllers.DynamicController( self.configuration_file) self.intermediate_controller = controllers.IntermediateController( self.configuration_file) #add a new glove if gloves_name is None: file_name = time.strftime("%Y%m%d-%H%M%S") self.gloves = Gloves() save_path = os.path.join(os.getcwd(), 'Gloves', file_name + '.txt') gloves_image = self.gloves.train() #pickle.dump(self.gloves, save_path) with open(save_path, 'wb') as handle: pickle.dump(self.gloves, handle, protocol=pickle.HIGHEST_PROTOCOL) image_path = os.path.join(os.getcwd(), 'Gloves', file_name + '.jpg') cv2.imwrite(image_path, gloves_image) #load a saved glove else: #self.gloves = pickle.load(os.path.join(os.getcwd(), 'Gloves', gloves_name)) glove_path = os.path.join(os.getcwd(), "Gloves", gloves_name + ".txt") with open(glove_path, 'rb') as handle: self.gloves = pickle.load(handle) self.current_mode = MODE.KEYBOARD self.start()
def train(): # load config file and prepare experiment args = get_args() config = process_config(args.config) create_dirs([config.model_dir, config.tensorboard_dir]) # load dataset file dataset = load_pair_paths(config) # split dataset train and test train_pairs, test_pairs = split_dataset(config, dataset) if config.debug: print("WARNING!!! DEBUG MODE ON! 100 training.") train_pairs = train_pairs[:100] print(train_pairs) test_pairs = test_pairs[:100] print(test_pairs) # Calculate steps for each epoch train_num_steps = calculate_num_iter(config, train_pairs) test_num_steps = calculate_num_iter(config, test_pairs) # Create the model model = depth_model(config) #set dynamic output shape config.output_size = list(model.output_shape[1:]) # Create train and test data generators train_gen = tf_data_generator(config, train_pairs, is_training=True) test_gen = tf_data_generator(config,test_pairs, is_training=False) # Prepare for training model.compile(optimizer=select_optimizer(config), loss=select_loss(config)) model.fit( train_gen, steps_per_epoch=train_num_steps, epochs=config.num_epochs, callbacks=create_callbacks(config), validation_data=test_gen, validation_steps=test_num_steps, verbose=1) print("Training Done.")
def predict(): args = get_args() config = process_config(args.config) model = load_depth_model_from_weights(config) for i in range(8): img = image.load_img('../images/' + str(i + 1) + '.jpg', target_size=(config.input_size[0], config.input_size[1])) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) prediction = model.predict(x) print("prediction shape", prediction.shape) prediction = np.reshape(prediction, [prediction.shape[1], prediction.shape[2]]) plt.imsave('../images/depth_' + str(i + 1) + '.jpg', prediction)
curr_it, len(test_loader), l2h_loss_D.item(), l2h_loss_D_real.item(), l2h_loss_D_fake.item(), l2h_loss_G.item(), l2h_loss_G_GAN.item(), l2h_loss_pixel.item(), )) def validate(self): pass def finalize(self): """ Finalize all the operations of the 2 Main classes of the process the operator and the data loader :return: """ self.logger.info( "Please wait while finalizing the operation.. Thank you") self.save_checkpoint() self.summary_writer.export_scalars_to_json("{}all_scalars.json".format( self.config.summary_dir)) self.summary_writer.close() self.dataloader.finalize() if __name__ == "__main__": config_dir = config.process_config('configurations/train_config.json') gan = Combined_GAN(config_dir)
import face_model import argparse import cv2 import sys import numpy as np import os from tqdm import * import imgaug as ia from imgaug import augmenters as iaa from bunch import Bunch from config import process_config config = process_config("./config.json") args = Bunch(config.pretrained_model) model = face_model.FaceModel(args) sometimes = lambda aug: iaa.Sometimes(0.8, aug) seq = iaa.Sequential([ iaa.Fliplr(0.5), sometimes( iaa.OneOf([ iaa.Grayscale(alpha=(0.0, 1.0)), iaa.AddToHueAndSaturation((-20, 20)), iaa.Add((-20, 20), per_channel=0.5), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.GaussianBlur((0, 2.0)), iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), iaa.Sharpen(alpha=(0, 0.5), lightness=(0.7, 1.3)), iaa.Emboss(alpha=(0, 0.5), strength=(0, 1.5)) ])) ])
default='1e5', help= 'How often to print the step to the terminal (may be in scientific notation)' ) parser.add_argument('--delay', type=int, default=0, help='Number of milliseconds between steps') parser.add_argument('--pause', action='store_true', default=False, help='Start the game in a paused state') args = parser.parse_args() # Process config (if there is one) and update args process_config(args) # Set width and height set_width(args.width) set_height(args.height) # Get flea class args.flea_class = get_flea(args.flea_name) # Convert to float then int to allow for scientific notation args.display_frequency = int(float(args.display_frequency)) args.print_frequency = int(float(args.print_frequency)) run_simulation(args.num_rows, args.num_cols, args.flea_class, args.num_fleas, args.flea_rows, args.flea_cols, args.init_directions, args.square_colors, args.image,
noise = torch.randn(data_high.size(0), 1) noise, _ = self.to_var(noise) # We figured out a mistake at very last moment in our high-to-low generator's pixel loss. # For pixel loss we should provide generated_lr image and donwssampled lr image of original # image. We passed generated lr image and actual lr image. So we dont have weights for # high-to-low model. Just for the sake of outputs we are doing some twik which is not # correct but though we are doing this. #gen_int_lr = self.h2l_G(data_input_high, noise) gen_hr = self.l2h_G(data_input_low) path_int = os.path.join(self.test_file, img_name.split('.')[0] + '_int_lr.jpg') path_final = os.path.join(self.test_file, img_name.split('.')[0] + '_final_hr.jpg') vutils.save_image(data_input_low.data, path_int, normalize=True) #vutils.save_image(gen_hr.data, path_final, normalize=True) if __name__ == '__main__': try: mode = sys.argv[1] except: print( 'Missing param value for mode. \nUsage: Possible values for mode are h2l, l2h, combined.' ) sys.exit(1) config_dir = config.process_config( 'F:/Study/2nd_Semester/CV/Project/temp/configurations/test_config.json' ) gan = TestCode(config_dir, mode) gan.test()
for tag, meter in state['model'].meters.items(): file_id = 'pre_finetune_{}'.format(tag) logger.log(file_id, state['epoch'], meter.value()[0]) engine.hooks['on_start'] = on_start engine.hooks['on_sample'] = on_sample engine.hooks['on_forward'] = on_forward engine.hooks['on_start_epoch'] = on_start_epoch engine.hooks['on_end_epoch'] = partial(on_end_epoch, { 'best_val': best_val, 'wait': 0 }) engine.train(model, loaders['train'], maxepoch=config['optim']['epochs'], optimizer=optimizer) model.reset_meters() if os.path.exists(best_model_path): model.load_state_dict(torch.load(best_model_path)) if loaders['test'] is not None: log_meters('test', logger, engine.test(model, loaders['test'])) return model if __name__ == '__main__': config = process_config() model_init = get_model(config) loaders = load_data(config) model = train(model_init, loaders, config)
def __init__(self, config_path): self.initialled = False with open(config_path, 'r', encoding='utf-8') as config_file: self.config = process_config(config_path)
import actions import utils __location__ = os.path.realpath( os.path.join(os.getcwd(), os.path.dirname(__file__))) defaults = { 'list_location': 'todo.txt', 'default_command': 'h', 'default_view': 'hide o p_id c_id a', 'archive_location': 'archive.txt', 'archive_automatically': 'false', 'archive_delay': '2' } settings = config.process_config(__location__, defaults) def open_list(): """open and read the task list file""" list_location = os.path.dirname(__file__) + "/" + settings['list_location'] try: with open(list_location, 'r') as f: file = f.readlines() except FileNotFoundError: with open(list_location, 'w+') as f: file = f.readlines() return file def print_projects():