def initialize(self): self.model = ModelBuilder(self.config).get_model() self.model.config_name = self.config_name try: self.model.set_training(True) except AttributeError: pass self.model.initialize() self.saver_sparse = tf.train.Saver( tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, self.model.get_variable_scope()))
def train_chord_to_melody_model(self, tt_split=0.9, epochs=100, model_name='basic_rnn'): ''' Train model step - model takes in chord piano roll and outputs melody piano roll. :param tt_split: train test split :param epochs: number of epochs to train :param model_name: specify which model we are training :return: None. Model is assigned as self.model for this generator ''' # Train test split self.__prepare_data_tt_splited(tt_split=tt_split, model_name=model_name, src="nottingham-embed") # print('Chords shape: {} Melodies shape: {}'.format(chords.shape, melodies.shape)) # Load / train model if model_name == 'basic_rnn': if os.path.exists("basic_rnn.h5"): mb = ModelBuilder(self.X_train, self.Y_train, self.X_test, self.Y_test) model = mb.build_basic_rnn_model( input_dim=self.X_train.shape[1:]) model.load_weights("basic_rnn.h5") else: mb = ModelBuilder(self.X_train, self.Y_train, self.X_test, self.Y_test) model = mb.build_attention_bidirectional_rnn_model( input_dim=self.X_train.shape[1:]) model = mb.train_model(model, epochs, loss="categorical_crossentropy") model.save_weights("basic_rnn.h5") self.model = model
def initialize_profile(self): self.config['batch_size'] = str(bb) self.model = ModelBuilder(self.config).get_model() self.config['batch_size'] = str(self.num_batch) self.model.config_name = self.config_name try: self.model.set_training(False) except AttributeError: pass self.model.initialize() self.saver_sparse = tf.train.Saver( tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, self.model.get_variable_scope()))
def main(): print('Using GPU: ', torch.cuda.get_device_name(0)) start_time = time.time() # Prepare configuration config = Configuration() cf = config.load() # Enable log file logger_debug = Logger(cf.log_file_debug) logger_debug.write('\n ---------- Init experiment: ' + cf.exp_name + ' ---------- \n') # Model building logger_debug.write('- Building model: ' + cf.model_name + ' <--- ') model = ModelBuilder(cf) model.build() print(model.net) # Problem type if cf.problem_type == 'segmentation': problem_manager = SemanticSegmentationManager(cf, model) elif cf.problem_type == 'classification': problem_manager = ClassificationManager(cf, model) elif cf.problem_type == 'detection': problem_manager = DetectionManager(cf, model) else: raise ValueError('Unknown problem type') # Create dataloader builder dataloader = DataLoaderBuilder(cf, model) if cf.train: model.net.train() # enable dropout modules and others train_time = time.time() logger_debug.write('\n- Reading Train dataset: ') dataloader.build_train() if (cf.valid_dataset_path is not None or (cf.valid_images_txt is not None and cf.valid_gt_txt is not None)) and cf.valid_samples_epoch != 0: logger_debug.write('\n- Reading Validation dataset: ') dataloader.build_valid(cf.valid_samples_epoch, cf.valid_images_txt, cf.valid_gt_txt, cf.resize_image_valid, cf.valid_batch_size) problem_manager.trainer.start(dataloader.train_loader, dataloader.train_set, dataloader.valid_set, dataloader.valid_loader) else: # Train without validation inside epoch problem_manager.trainer.start(dataloader.train_loader, dataloader.train_set) train_time = time.time() - train_time logger_debug.write('\t Train step finished: %ds ' % train_time) if cf.validation: model.net.eval() valid_time = time.time() if not cf.train: logger_debug.write('- Reading Validation dataset: ') dataloader.build_valid(cf.valid_samples, cf.valid_images_txt, cf.valid_gt_txt, cf.resize_image_valid, cf.valid_batch_size) else: # If the Dataloader for validation was used on train, only update the total number of images to take dataloader.valid_set.update_indexes( cf.valid_samples, valid=True) # valid=True avoids shuffle for validation logger_debug.write('\n- Starting validation <---') problem_manager.validator.start(dataloader.valid_set, dataloader.valid_loader, 'Validation') valid_time = time.time() - valid_time logger_debug.write('\t Validation step finished: %ds ' % valid_time) if cf.test: model.net.eval() test_time = time.time() logger_debug.write('\n- Reading Test dataset: ') dataloader.build_valid(cf.test_samples, cf.test_images_txt, cf.test_gt_txt, cf.resize_image_test, cf.test_batch_size) logger_debug.write('\n - Starting test <---') problem_manager.validator.start(dataloader.valid_set, dataloader.valid_loader, 'Test') test_time = time.time() - test_time logger_debug.write('\t Test step finished: %ds ' % test_time) if cf.predict_test: model.net.eval() pred_time = time.time() logger_debug.write('\n- Reading Prediction dataset: ') dataloader.build_predict() logger_debug.write('\n - Generating predictions <---') problem_manager.predictor.start(dataloader.predict_loader) pred_time = time.time() - pred_time logger_debug.write('\t Prediction step finished: %ds ' % pred_time) total_time = time.time() - start_time logger_debug.write('\n- Experiment finished: %ds ' % total_time) logger_debug.write('\n')
def load_model(self, model_name, tt_split=0.9, is_fast_load=True): # clear session to avoid any errors K.clear_session() print("Chosen model: {}".format(model_name)) if not is_fast_load: # Train test split if model_name == 'bidem' or model_name == 'attention' or model_name == "bidem_preload": self.__prepare_data_tt_splited(tt_split=tt_split, model_name=model_name, src='nottingham-embed') print('Chords shape: {} Melodies shape: {}'.format( self.X_train.shape, self.Y_train.shape)) else: self.__prepare_data_tt_splited(tt_split=tt_split, model_name=model_name, src='nottingham') print('Chords shape: {} Melodies shape: {}'.format( self.X_train.shape, self.Y_train.shape)) if is_fast_load: mb = ModelBuilder(None, None, None, None) else: mb = ModelBuilder(self.X_train, self.Y_train, self.X_test, self.Y_test) if model_name == 'basic_rnn_normalized': self.model = mb.build_basic_rnn_model(input_dim=(1200, 128)) weights_path = '../note/active_models/basic_rnn_weights_500.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) elif model_name == 'basic_rnn_unnormalized': self.model = mb.build_basic_rnn_model(input_dim=(1200, 128)) weights_path = '../note/active_models/basic_rnn_weights_500_unnormalized.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) elif model_name == 'bidem': self.model = mb.build_bidirectional_rnn_model(input_dim=(1200, )) weights_path = '../note/active_models/bidem_weights_500.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) elif model_name == 'bidem_regularized': self.model = mb.build_bidirectional_rnn_model_no_embeddings( input_dim=(1200, 1)) weights_path = '../note/active_models/bidirectional_regularized_500.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) elif model_name == 'attention': self.model = mb.build_attention_bidirectional_rnn_model( input_dim=(1200, )) weights_path = '../note/active_models/attention_weights_1000.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) elif model_name == 'bidem_preload': self.model = mb.build_bidirectional_rnn_model_no_embeddings( input_dim=(None, 32)) weights_path = '../note/active_models/bidirectional_embedding_preload_100.h5' print('Loading ' + weights_path + '...') self.model.load_weights(weights_path) else: print('No model name: {}'.format(model_name)) return self.model_name = model_name
currentdir = os.path.dirname( os.path.abspath(inspect.getfile(inspect.currentframe()))) parentdir = os.path.dirname(currentdir) sys.path.insert(0, parentdir) from agents.actions.sc2_wrapper import SC2Wrapper, TerranWrapper, ProtossWrapper from agents.states.sc2 import Simple64State from models.model_builder import ModelBuilder from utils.logger import Logger state_builder = Simple64State() action_wrapper = TerranWrapper() helper = ModelBuilder() helper.add_input_layer(int(state_builder.get_state_dim())) helper.add_fullyconn_layer(512) helper.add_fullyconn_layer(256) helper.add_output_layer(action_wrapper.get_action_space_dim()) b = Logger(10000) print("Saving b") b.save(".") print(b.ep_total) b.ep_total = 900 print(b.ep_total) print("Loading b") b.load(".")