示例#1
0
def main(args):
    if not path.exists(args.save_dir):
        makedirs(args.save_dir)
        print("Create {}".format(args.save_dir))

    if args.mode == "train":
        train_loader = DataLoader("train", args.batch_size, args.pad_size, args.crop_size)
        valid_loader = DataLoader("valid", args.batch_size*2)

        solver = Solver(args, train_loader, valid_loader)
        solver.train()
示例#2
0
def test(config, model_dir, test_dir):
    data_loader = DataLoader(test_dir,
                             mode='test',
                             tokenize_func=lmmrl_tokenizer,
                             encode_func=lmmrl_encoder)
    batch_loader = BatchLoader(data_loader,
                               batch_size=config.batch_size,
                               timesteps=config.timesteps,
                               mode='test')

    cfg_proto = tf.ConfigProto(intra_op_parallelism_threads=0,
                               inter_op_parallelism_threads=0)
    cfg_proto.gpu_options.allow_growth = True

    # Load word frequency information
    with open(os.path.join(test_dir, 'word_freq.txt'), encoding='utf-8') as f:
        freq = f.read().split()
        config['freq'] = freq
    config.save_dir = model_dir

    model = Model(config)

    with tf.Session(config=cfg_proto, graph=model.graph) as sess:
        # Restore model/Initialize weights
        initializer = tf.random_uniform_initializer(-0.05, 0.05)
        with tf.variable_scope("model", reuse=None, initializer=initializer):
            _ = restore_model(sess, model, model_dir)

        print("Model restored from %s" % model_dir)
        # Finalize graph to prevent memory leakage
        sess.graph.finalize()

        # Prepare loader
        batch_loader.reset_pointers()
        # Start from an empty RNN state
        init_states = sess.run(model.initial_states)
        states = init_states

        acc_loss = np.zeros(batch_loader.batch_size)

        end_epoch = False
        b = 1
        while not end_epoch:
            x, y, end_epoch = batch_loader.next_batch()
            if end_epoch:
                break
            loss = model.forward(sess, x, y, states, mode='val')
            # accumulate evaluation metric here
            acc_loss += loss
            print("Batch = %d, Average loss = %.4f" % (b, np.mean(loss)))
            b += 1

        final_metric = np.exp(np.mean(acc_loss) / (b - 1))
        print("(Averaged) Evaluation metric = %.4f" % final_metric)
示例#3
0
def main():

    batch_size = 10

    # generating our data
    train_inputs, train_targets = generate_data(1000, 2)
    test_inputs, test_targets = generate_data(1000, 2)

    # creating our loaders for training and test sets
    train_loader = DataLoader(train_inputs, train_targets, batch_size)
    test_loader = DataLoader(test_inputs, test_targets, batch_size)

    # defining our layers
    layers = [
        Linear(input_dim=train_inputs[0].shape[0], output_dim=25),
        Relu(),
        Linear(input_dim=25, output_dim=25),
        Relu(),
        Linear(input_dim=25, output_dim=2),
        Tanh()
    ]

    # creating our model
    model = Sequential(layers)

    # init our optimizer
    optimizer = SGD(model.get_params(), lr=0.01)

    # init our trainer
    trainer = Trainer(model=model,
                      optimizer=optimizer,
                      epochs=500,
                      loss=LossMSE(),
                      train_loader=train_loader,
                      test_loader=test_loader)

    # starting the training session
    trainer.train()

    return 0
示例#4
0
user_feature = torch.tensor(user_feature, dtype=torch.float32)
item_feature = torch.tensor(item_feature, dtype=torch.float32)


if opt["cuda"]:
    user_feature = user_feature.cuda()
    item_feature = item_feature.cuda()
    UV = UV.cuda()
    VU = VU.cuda()
    adj = adj.cuda()
    fake_adj = fake_adj.cuda()
    corruption_UV = corruption_UV.cuda()
    corruption_VU = corruption_VU.cuda()

print("Loading data from {} with batch size {}...".format(opt['data_dir'], opt['batch_size']))
train_batch = DataLoader(opt['data_dir'] + 'train.txt', opt['batch_size'], opt,
                         user_real_dict, user_fake_dict, item_real_dict, item_fake_dict, evaluation=False)
dev_batch = DataLoader(opt['data_dir'] + 'test.txt', opt["batch_size"], opt, user_real_dict, user_fake_dict, item_real_dict, item_fake_dict, evaluation=True)


# model
if not opt['load']:
    trainer = DGITrainer(opt)
else:
    # load pretrained model
    model_file = opt['model_file']
    print("Loading model from {}".format(model_file))
    model_opt = torch_utils.load_config(model_file)
    model_opt['optim'] = opt['optim']
    trainer = DGITrainer(opt)
    trainer.load(model_file)
示例#5
0
文件: train.py 项目: microw/ccks_kg
# opt['word_vocab_size'] = len(char2id)+2
# opt['pos_size'] = len(id2pos)+2

vocab_file = opt['vocab_dir'] + '/vocab.pkl'
vocab = Vocab(vocab_file, load=True)
opt['word_vocab_size'] = vocab.size
emb_file = opt['vocab_dir'] + '/embedding.npy'
emb_matrix = np.load(emb_file)
assert emb_matrix.shape[0] == vocab.size
# assert emb_matrix.shape[1] == opt['word_emb_dim']
word2id = vocab.word2id

# load data 加载数据
print("Loading data from {} with batch size {}...".format(
    opt['data_dir'], opt['batch_size']))
train_batch = DataLoader(bert_tokenizer, train_data, predicate2id,
                         subj_type2id, obj_type2id, opt['batch_size'])

model_id = opt['id'] if len(opt['id']) > 1 else '0' + opt['id']
model_save_dir = opt['save_dir'] + '/' + model_id
opt['model_save_dir'] = model_save_dir
helper.ensure_dir(model_save_dir, verbose=True)

# save config
helper.save_config(opt, model_save_dir + '/config.json', verbose=True)
file_logger = helper.FileLogger(
    model_save_dir + '/' + opt['log'],
    header="# epoch\ttrain_loss\dev_p\tdev_r\tdev_f1")
# print model info
helper.print_config(opt)
print(opt['num_class'])
# model 初始化模型
示例#6
0
opt['word_vocab_size'] = len(char2id) + 2
opt['pos_size'] = len(id2pos) + 2

vocab_file = opt['vocab_dir'] + '/vocab.pkl'
vocab = Vocab(vocab_file, load=True)
opt['word_vocab_size'] = vocab.size
emb_file = opt['vocab_dir'] + '/embedding.npy'
emb_matrix = np.load(emb_file)
assert emb_matrix.shape[0] == vocab.size
assert emb_matrix.shape[1] == opt['word_emb_dim']
word2id = vocab.word2id

# load data
print("Loading data from {} with batch size {}...".format(
    opt['data_dir'], opt['batch_size']))
train_batch = DataLoader(train_data, predicate2id, char2id, word2id, pos2id,
                         subj_type2id, obj_type2id, opt['batch_size'])

model_id = opt['id'] if len(opt['id']) > 1 else '0' + opt['id']
model_save_dir = opt['save_dir'] + '/' + model_id
opt['model_save_dir'] = model_save_dir
helper.ensure_dir(model_save_dir, verbose=True)

# save config
helper.save_config(opt, model_save_dir + '/config.json', verbose=True)
file_logger = helper.FileLogger(
    model_save_dir + '/' + opt['log'],
    header="# epoch\ttrain_loss\dev_p\tdev_r\tdev_f1")
# print model info
helper.print_config(opt)
print(opt['num_class'])
# model
示例#7
0
# set CPU/GPU device for execution
if args.gpu_ids is not None:
    if args.gpu_ids[0] >= 0:
        device = torch.device("cuda", args.gpu_ids[0])
    else:
        device = torch.device("cpu")
else:
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# ----------------------------------------------------------------------------
# Importing Dataset Loader
# ----------------------------------------------------------------------------
if args.overfit is True:
    train_loader = DataLoader(os.path.join(args.data_dir, "train"),
                              num_workers=args.cpu_workers,
                              batch_size=args.batch_size,
                              limit=256,
                              shuffle=True)
    test_loader = DataLoader(os.path.join(args.data_dir, "val"),
                             num_workers=args.cpu_workers,
                             batch_size=args.batch_size,
                             limit=256,
                             shuffle=False)
else:
    train_loader = DataLoader(os.path.join(args.data_dir, "train"),
                              num_workers=args.cpu_workers,
                              batch_size=args.batch_size,
                              shuffle=True)
    test_loader = DataLoader(os.path.join(args.data_dir, "val"),
                             num_workers=args.cpu_workers,
                             batch_size=args.batch_size,
示例#8
0
    """ Read YAML file and do some additional processing.
    """
    config = {}
    with open(config_file, 'r') as file:
        config = yaml.load(file, Loader=yaml.SafeLoader)

    return config


if __name__ == "__main__":
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = "2"

    args, unknown = _parse_args()
    config = parse_config_file(args.config_file)

    loader = DataLoader(config)
    circle = ganCIRCLE(config, args.key, args.secret)
    circle.g_lr_hr.save('sr_generator_model')

    epochs = config["epochs"]

    iterations = tf.constant((loader.epoch_size // (loader.batch_size)) - 2)
    tf.print('Each epoch will have %s iterations' % (iterations.numpy()))

    pb = Progbar(tf.cast(iterations * epochs, tf.float32), width=10, verbose=1)

    for epoch in tf.range(epochs):

        g_total_loss_list = []
        d_total_loss_list = []
示例#9
0
def train(data_dir, save_dir, best_dir, config):
	"""Prepare the data and begin training."""
	# Create variables
	batch_size = config.batch_size
	timesteps = config.timesteps
	num_epochs = config.epochs
	# Load the text and vocabulary
	data_loader = DataLoader(
		data_dir, 
		mode='train', 
		tokenize_func=lmmrl_tokenizer, 
		encode_func=lmmrl_encoder, 
		word_markers=config.include_word_markers,
		max_word_length=config.max_word_length
	)
	# Prepare batches for training and validation
	train_batch_loader = BatchLoader(data_loader, batch_size=batch_size, timesteps=timesteps, mode='train')
	val_batch_loader = BatchLoader(data_loader, batch_size=batch_size, timesteps=timesteps, mode='val')

	# update vocabulary sizes
	config.word_vocab_size = len(data_loader.vocabs['words'])
	config.char_vocab_size = len(data_loader.vocabs['chars'])

	# Run on GPU by default
	cfg_proto = tf.ConfigProto(intra_op_parallelism_threads=0, inter_op_parallelism_threads=0)
	cfg_proto.gpu_options.allow_growth = True

	##########################################################################
	# Load word frequency information
	##########################################################################
	with open(os.path.join(data_dir, 'word_freq.txt'), encoding='utf-8') as f:
		freq = f.read().split()
		config['freq'] = freq
	##########################################################################

	# Create model
	config.save_dir = save_dir
	model = Model(config)

	with tf.Session(config=cfg_proto, graph=model.graph) as sess:
		# Restore model/Initialize weights
		initializer = tf.random_uniform_initializer(-0.05, 0.05)
		with tf.variable_scope("model", reuse=None, initializer=initializer):
			steps_done = restore_model(sess, model, save_dir)
		
		logger.info("Loaded %d completed steps", steps_done)

		# Find starting epoch
		start_epoch = model.epoch_cntr.eval()

		# Start epoch-based training
		lr = config.initial_learning_rate
		
		# Finalize graph to prevent memory leakage
		sess.graph.finalize()
		last_val_ppl = 10000
		
		for epoch in range(start_epoch, num_epochs):
			logger.info("Epoch %d / %d", epoch+1, num_epochs)
			# train
			run_epoch(sess, model, train_batch_loader, 'train', save_dir=save_dir, lr=lr)
			# fine-tune after every epoch
            sess.run(model.update_unknown)
			model.fine_tune(sess)
			# validate
			val_ppl = run_epoch(sess, model, val_batch_loader, 'val', best_dir=best_dir)
			# update learning rate conditionally
			if val_ppl >= last_val_ppl:
				lr *= config.lr_decay
				logger.info("Decaying learning rate to %.4f", lr)
			last_val_ppl = val_ppl
			# increment epoch
			sess.run([model.incr_epoch])