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(".")