Example #1
0
def predict(model_name, participator, load_weight_from):
    logger_name = model_name + str(participator) + str(load_weight_from)
    logger = logging.getLogger(logger_name) # so that no multiple loggers input the same data
    f_time = datetime.datetime.today()
    output_dir = os.path.join('output', 'predict_'+str(f_time))
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    hdlr = logging.FileHandler(os.path.join(output_dir, 'rnn.log'))
    logger.addHandler(hdlr)
    console_handler = logging.StreamHandler()
    logger.addHandler(console_handler)
    logger.setLevel(logging.INFO)
    gal = GAL_data()
    gal.set_logger(logger)
    gal.load_data(load_list=['eeg', 'kin'])
    data_description = gal.get_data_description()
    participator = participator
    logger.info('participator : {0}'.format(participator))

    rnn = EEG_model(None)
    rnn.set_logger(logger)
    rnn.select_model(model_name)
    rnn.load_model_weight(model_name, load_weight_from)

    logger.info( 'running model data from a generator')
    data_len=gal.part_data_count[participator]
    data_split_ratio = [0.8, 0.2]
    train_list = np.arange(int(data_len * data_split_ratio[0]))
    test_list = np.arange(data_len - int(data_len * data_split_ratio[0]))

    rnn.set_data_description(data_description)
    generator = gal.data_generator_kin(part=participator, timesteps=10, stride=10)
    rnn.save_kin_generator(generator=generator,train_list=train_list, test_list=test_list, output_dir=output_dir)
Example #2
0
def run_model_kin_generator(model_name, participator, timesteps, stride, nb_epoch, patience_limit, loss_delta_limit, load_weight_from = None):
    logger_name = model_name + str(participator) + str(timesteps) + str(stride) + str(nb_epoch) + str(load_weight_from)
    logger = logging.getLogger(logger_name) # so that no multiple loggers input the same data
    f_time = datetime.datetime.today()
    output_dir = os.path.join('output', 'kin_'+str(f_time))
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    hdlr = logging.FileHandler(os.path.join(output_dir, 'rnn.log'))
    logger.addHandler(hdlr)
    console_handler = logging.StreamHandler()
    logger.addHandler(console_handler)
    logger.setLevel(logging.INFO)
    gal = GAL_data()
    gal.set_logger(logger)
    gal.load_data(load_list=['eeg', 'kin'])
    gal.preprocess_kin()
    data_description = gal.get_data_description()
    participator = participator
    logger.info('participator : {0}'.format(participator))

    rnn = EEG_model(None)
    rnn.set_logger(logger)
    rnn.select_model(model_name)
    if load_weight_from != None:
        rnn.load_model_weight(model_name, load_weight_from)

    logger.info( 'running model data from a generator')
    data_len=gal.part_data_count[participator]
    data_split_ratio = [0.8,0.2]
    train_list = np.arange(int(data_len * data_split_ratio[0]))
    test_list = np.arange(data_len - int(data_len * data_split_ratio[0]))

    loss_train_df = pd.DataFrame(columns = ['epoch', 'loss'])
    loss_test_df = pd.DataFrame(columns = ['epoch', 'loss'])
    patience = 0
    for epoch in range(nb_epoch):
        generator = gal.data_generator_kin(part=participator, timesteps=timesteps, stride=stride)
        logger.info( 'epoch : {0}'.format(epoch))
        start = time.clock()
        train_loss, test_loss = rnn.run_model_with_generator_kin(generator=generator, train_list=train_list, test_list=test_list)
        loss_train_df.loc[epoch, ['epoch', 'loss']] = [epoch+1, train_loss]
        loss_test_df.loc[epoch, ['epoch', 'loss']] = [epoch+1, test_loss]
        if epoch == 0:
            prev_train_loss = train_loss
        logger.info( 'epoch {0} ran for {1} minutes'.format(epoch, (time.clock() - start)/60))
        loss_delta = abs(prev_train_loss - train_loss) / prev_train_loss * 100
        if loss_delta < loss_delta_limit:
            patience = patience + 1
            if patience > patience_limit:
                logger.info('training stopped at epoch {0} due to patience threshold'.format(epoch))
                break
        else:
            patience = patience - 1

    loss_train_df.to_csv(os.path.join(output_dir, 'train_loss.csv'), index=False)
    loss_test_df.to_csv(os.path.join(output_dir, 'test_loss.csv'), index=False)

    rnn.set_data_description(data_description)
    rnn.set_model_config('epoch', nb_epoch)
    generator = gal.data_generator_kin(part=participator, timesteps=timesteps, stride = stride)

    rnn.save_kin_generator(generator=generator,train_list=train_list, test_list=test_list, output_dir=output_dir)