def slave(comm): mus, logvars = load_init_z() vae = VAE() vae.load_state_dict(torch.load(cfg.vae_save_ckpt, map_location=lambda storage, loc: storage)['model']) model = RNNModel() model.load_state_dict(torch.load(cfg.rnn_save_ckpt, map_location=lambda storage, loc: storage)['model']) count = 1 status = MPI.Status() gpuid = comm.rank % 4 # device = torch.device('cuda:{}'.format(gpuid)) # vae.to(device) # model.to(device) print('Worker {} Started, model on GPU {}'.format(comm.rank, gpuid)) while True: solution = comm.recv(source=0, tag=MPI.ANY_TAG, status=status) tag = status.Get_tag() if tag == 1: print('Worker {} received solution {}'.format(comm.rank, count)) zs = [sample_init_z(mus, logvars) for _ in range(cfg.trials_per_pop)] controller = deflatten_controller(solution) reward = rollout(model, controller, zs) print('Worker {} finished solution {}, reward: mean {} | max {} | min {} | std {}'.format( comm.rank, count, reward.mean(), reward.max(), reward.min(), reward.std())) comm.send(reward.mean(), dest=0, tag=2) count += 1 elif tag == 3: print('Worker {} evaluate current solution'.format(comm.rank)) controller = deflatten_controller(solution) reward = evaluate(model, vae, controller) comm.send(reward, dest=0, tag=2)
def predicting(self): vocab_to_id = get_vocab_to_id(self.train_data_path, self.vocab_file, False) data_helper = DataHelper(vocab_to_id) reader = open("data/predict_data", 'r') writer = open("data/res", 'w') dishs = [] file_data = [] for line in reader.readlines(): line = line.strip().decode("utf-8") line_split = line.split("\t") if len(line_split) != 2: continue type, dish_name = line_split dishs.append(dish_name) file_data.append(line_split) batch = data_helper.create_prediction_batch(dishs) with tf.Session() as sess: cnn_model = RNNModel(self.rnn_size, self.embedding_size, self.class_num, len(vocab_to_id), self.learning_rate, self.model_path) ckpt = tf.train.get_checkpoint_state(self.model_dir) cnn_model.saver.restore(sess, ckpt.model_checkpoint_path) prediction, pre_label = cnn_model.predict(sess, batch) pre_pre = sess.run(tf.nn.softmax(prediction)) print pre_label, pre_pre, prediction for idx, sub_review_lable in enumerate(pre_label): writer.write("{}\t{}\t{}\n".format(file_data[idx][0], file_data[idx][1], sub_review_lable))
def dummy(): config = train_config data_train = load_data(config, 'train') config['input_dim'] = data_train.input_[0].shape[-1] config['output_dim'] = data_train.target[0].shape[-1] data_train.reshuffle() rnn_model_class, placeholders = get_model_and_placeholders(config) rnn_model = RNNModel(config, placeholders, mode='training') # loop through all training batches for i, batch in enumerate(data_train.all_batches()): # get the feed dict for the current batch feed_dict = rnn_model.get_feed_dict(batch) for sequence_mask in batch.mask: if np.sum(sequence_mask) < 35: print('found it {0}'.format(np.sum(sequence_mask))) input_padded, target_padded = batch.get_padded_data() mse = mean_squared_error(input_padded[0], target_padded[0]) mse2 = mean_squared_error(input_padded[1], target_padded[1])
def main(self): print("SmartGator Intelligent chatbot") self.root_dir = os.getcwd() self.load_config() self.load_model_params() self.load_args() self.update_settings() self.text_data = dataset(self.args) # RNN Model Initialized # self.model = RNNModel(self.text_data, self.args) # Handlers to write and save learned models # self.writer = tf.summary.FileWriter(self._get_summary_name()) self.saver = tf.train.Saver(max_to_keep=200, write_version=tf.train.SaverDef.V1) self.session = tf.Session(config=tf.ConfigProto( allow_soft_placement=True, log_device_placement=False)) print("Initializing tf variables") self.session.run(tf.global_variables_initializer()) # If a previous model exists load it and procedd from last run step # self.manage_previous_model(self.session) # If using word2vec model we need to laod word vectors # if self.init_embeddings: self.load_embedding(self.session) # Twitter Interface up or not # if self.twitter: return # Batch Testing # elif self.file_: try: with open(self.TEST_IN_NAME, "r") as f: try: with open(self.TEST_OUT_SUFFIX, 'w') as output: for line in f: output.write( self.predict_daemon(line[:-1]) + "\n") except: print("Writing in file is a problem") except: print("Open file error") # Else if in CLI testing mode # elif self.test: self.interactive_main(self.session) # Else in training mode # else: self.train_model(self.session) self.session.close() print("Say Bye Bye to SmartGator! ;)")
def decomopsitionNet(data, lookBack, batchSize): scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(data) # 分割序列为样本,并整理成RNN的输入形式 trainData, testData = divideTrainTest(dataset) trainX, trainY = createSamples(trainData, lookBack, RNN=False) testX, testY = createSamples(testData, lookBack, RNN=False) print("testX shape:", testX.shape) print("testy shape:", testY.shape) print("trainX shape:", trainX.shape) print("trainy shape:", trainY.shape) net1 = DecompositionNetModel(inputDim=24, hiddenNum=100, outputDim=24) net2 = RNNModel(inputDim=1, hiddenNum=100, outputDim=1, layerNum=1, cell="RNN") optimizer1 = optim.RMSprop(net1.parameters(), lr=1e-4) optimizer2 = optim.SGD(net2.parameters(), lr=1e-3) prime = net1.forward()
def train_model(self): args = self.args # Load data corpus = Corpus(args.file) train_data = train.batchify(corpus.train, args.batch_size, self.device) # Build the model ntokens = len(corpus.dictionary) model = RNNModel(args.model, ntokens, args.emsize, args.nhid, args.nlayers, args.dropout, args.tied).to(self.device) # criterion = nn.NLLLoss() # criterion = nn.MSELoss() criterion = self.args.criterion optimizer = optim.Adam(model.parameters(), lr=args.lr) # Training code # Loop over epochs. lr = args.lr # At any point you can hit Ctrl + C to break out of training early. try: for epoch in range(1, args.epochs + 1): epoch_start_time = time.time() train.train(train_data, args, model, optimizer, criterion, corpus, epoch, lr, self.device) print('-' * 89) with open(args.save, 'wb') as f: torch.save(model, f) lr /= 4.0 except KeyboardInterrupt: print('-' * 89) print('Exiting from training early') return model
def test(data, batch_size=64, filename='roc.png', **kwargs): global args assert args.checkpoint is not None model = RNNModel(feature_dims=data[0].feature_dim, model_dir=args.output_dir, **kwargs) model.restore(args.checkpoint) data = list(filter(lambda d: d.seq is not None, data)) for i in tqdm(range(0, len(data), batch_size)): x, y, length = get_feature_label(data[i:i + batch_size], length_limit=10000) predictions = model.predict(x, length) for l, p in zip(data[i:i + batch_size], predictions): l.prediction = p # if SimpleLengthModel.data_filter(data[i]): # x, y, length = get_feature_label(data[i:i+batch_size], length_limit=1000) # predictions = model.predict(x, length) # for l,p in zip(data[i:i+batch_size], predictions): # l.prediction = p # else: # for l in data[i:i+batch_size]: # l.prediction = 1 + l.length / 100000.0 predictions = list(map(attrgetter('prediction'), data)) labels = list(map(attrgetter('label'), data)) plot_roc(predictions, labels, filename=filename)
def export_onnx(path, batch_size, seq_len): print('The model is also exported in ONNX format at {}'.format( os.path.realpath(args.onnx_export))) model.eval() dummy_input = torch.LongTensor(seq_len * batch_size).zero_().view( -1, batch_size).to(device) hidden = model.init_hidden(batch_size) torch.onnx.export(model, (dummy_input, hidden), path)
def build_model(num_layers=1, num_units=128, num_feature=None, keep_prob=1.0): if not num_feature: print("Please determine number of feature") model = RNNModel(num_layers=num_layers, num_units=num_units, num_feature=num_feature, keep_prob=keep_prob, is_training=True) model.build_graph() return model
def __init__(self, context: PyTorchTrialContext): self.context = context data_config = self.context.get_data_config() hparams = self.context.get_hparams() using_bind_mount = data_config["use_bind_mount"] use_cache = data_config["use_cache"] self.eval_batch_size = hparams["eval_batch_size"] download_directory = ( Path(data_config["bind_mount_path"]) if using_bind_mount else Path("/data")) / f"data-rank{self.context.distributed.get_rank()}" self.corpus = data.load_and_cache_dataset(download_directory, use_cache) self.model_cls = hparams["model_cls"] emsize = hparams["word_embeddings_size"] num_hidden = hparams["num_hidden"] num_layers = hparams["num_layers"] dropout = hparams["dropout"] self.bptt = hparams["bptt"] if self.model_cls.lower() == "transformer": num_heads = hparams["num_heads"] self.model = TransformerModel(self.corpus.ntokens, emsize, num_heads, num_hidden, num_layers, dropout) else: tied = hparams["tied"] self.model = RNNModel( self.model_cls, self.corpus.ntokens, emsize, num_hidden, num_layers, dropout, tied, ) self.model = self.context.wrap_model(self.model) self.criterion = nn.NLLLoss() lr = hparams["lr"] optimizer = torch.optim.SGD(self.model.parameters(), lr=lr) self.optimizer = self.context.wrap_optimizer(optimizer) self.lr_scheduler = self.context.wrap_lr_scheduler( torch.optim.lr_scheduler.ReduceLROnPlateau( self.optimizer, factor=0.25, patience=0, threshold=0.001, threshold_mode="abs", verbose=True, ), LRScheduler.StepMode.MANUAL_STEP, )
def __init__(self): super().__init__() self.mfcc_rnn = RNNModel() self.pitch_clf01 = PitchModel([0, 1]) self.pitch_clf67 = PitchModel([6, 7]) self.mfcc_rnn.load() self.pitch_clf01.load() self.pitch_clf67.load() self.mfcc_rnn.clf.eval()
def build_model(): """Build the model according to CLI arguments Global Dependencies: - corpus - args """ # noise for soise sampling in NCE noise = build_unigram_noise(torch.FloatTensor(corpus.vocab.idx2count)) # setting up NCELoss modules if args.index_module == 'linear': criterion = IndexLinear( args.nhid, ntoken, noise=noise, noise_ratio=args.noise_ratio, norm_term=args.norm_term, loss_type=args.loss, reduction='none', ) model = RNNModel( ntoken, args.emsize, args.nhid, args.nlayers, criterion=criterion, dropout=args.dropout, ) elif args.index_module == 'gru': if args.nlayers != 1: logger.warning( 'Falling into one layer GRU due to Index_GRU supporting') nce_criterion = IndexGRU( ntoken, args.nhid, args.nhid, args.dropout, noise=noise, noise_ratio=args.noise_ratio, norm_term=args.norm_term, ) model = GenModel(criterion=nce_criterion, ) else: logger.error('The index module [%s] is not supported yet' % args.index_module) raise (NotImplementedError('index module not supported')) if args.cuda: model.cuda() logger.info('model definition:\n %s', model) return model
def model_load(fn): model_opt = json.load(open(fn + '.opt')) model = RNNModel(model_opt['rnn_type'], model_opt['ntoken'], model_opt['ninp'], model_opt['nhid'], model_opt['nlayers'], model_opt['dropout'], model_opt['dropouth'], model_opt['dropouti'], model_opt['dropoute'], model_opt['wdrop'], model_opt['tie_weights']) with open(fn + '.model', 'rb') as f: model_dict, criterion, optimizer = torch.load(f) model.load_state_dict(model_dict) return model, criterion, optimizer
class EnsembleModel(_ModelBase): def __init__(self): super().__init__() self.mfcc_rnn = RNNModel() self.pitch_clf01 = PitchModel([0, 1]) self.pitch_clf67 = PitchModel([6, 7]) self.mfcc_rnn.load() self.pitch_clf01.load() self.pitch_clf67.load() self.mfcc_rnn.clf.eval() def test(self): dev_data = self.reader.mini_batch_iterator(self.reader.val_person) y, pred = [], [] for itr, total_iter, feat, label, files in dev_data: pred_, prob_ = self.mfcc_rnn.test_iter(itr, total_iter, feat, label, files) for i, p in enumerate(pred_): if p in [0, 1] and prob_[i][p] < 0.8: pred_[i] = self.pitch_clf01.test_iter(*feat[i]) if p in [6, 7] and prob_[i][p] < 0.7: pred_[i] = self.pitch_clf67.test_iter(*feat[i]) y.extend(label) pred.extend(pred_) printer.info('%d/%d' % (itr, total_iter)) # for i,_ in enumerate(pred_): # if pred_[i] != label[i]: # logger.info(files[i]) # if itr > 1000: break acc = accuracy_score(y, pred) printer.info(acc) cm = confusion_matrix(y, pred) pickle.dump(cm, open('models/cm.pkl', 'wb')) print(cm) return acc def interactive(self): test_data = self.reader.new_file_detect_iterator() y, pred = [], [] for itr, total_iter, feat, label, files in test_data: pred_, prob_ = self.mfcc_rnn.test_iter(itr, total_iter, feat, label, files) for i, p in enumerate(pred_): if p in [0, 1] and prob_[i][p] < 0.8: pred_[i] = self.pitch_clf01.test_iter(*feat[i]) if p in [6, 7] and prob_[i][p] < 0.7: pred_[i] = self.pitch_clf67.test_iter(*feat[i]) print('***Prediction***\n%s\n' % output_dict[pred_[0]]) print('***Confidence***\n%s\n' % str(prob_[0][pred_[0]]))
def generate_flow(epoch=3): """读取存储的模型,生成新词""" corpus = Corpus(train_dir) config = Config() config.vocab_size = len(corpus.dictionary) model = RNNModel(config) model_file = os.path.join(save_dir, model_name.format(epoch)) assert os.path.exists(model_file), 'File %s does not exist.' % model_file model.load_state_dict( torch.load(model_file, map_location=lambda storage, loc: storage)) word_list = generate(model, corpus.dictionary.idx2word, word_len=50) print(''.join(word_list))
def evaluate(data_source): # Turn on evaluation mode which disables dropout. model.eval() total_loss = 0. ntokens = len(corpus.dictionary) hidden = model.init_hidden(eval_batch_size) with torch.no_grad(): for i in range(0, data_source.size(0) - 1, args.bptt): data, targets = get_batch(data_source, i) output, hidden = model(data, hidden) output_flat = output.view(-1, ntokens) total_loss += len(data) * criterion(output_flat, targets).item() hidden = repackage_hidden(hidden) return total_loss / (len(data_source) - 1)
def test_real(epi): vae = VAE() vae.load_state_dict(torch.load(cfg.vae_save_ckpt)['model']) model = RNNModel() model.load_state_dict(torch.load(cfg.rnn_save_ckpt)['model']) controller = Controller() controller.load_state_dict(torch.load(cfg.ctrl_save_ckpt)['model']) env = DoomTakeCover(True) obs = env.reset() model.reset() frames = [] for step in range(cfg.max_steps): frames.append(cv2.resize(obs, (256, 256))) obs = torch.from_numpy(obs.transpose(2, 0, 1)).unsqueeze(0).float() / 255.0 mu, logvar, _, z = vae(obs) inp = torch.cat((model.hx.detach(), model.cx.detach(), z), dim=1) y = controller(inp) y = y.item() action = encode_action(y) model.step(z.unsqueeze(0), action.unsqueeze(0)) obs_next, reward, done, _ = env.step(action.item()) obs = obs_next if done: break print('Episode {}: Real Reward {}'.format(epi, step)) write_video(frames, 'real_{}.avi'.format(epi), (256, 256)) os.system('mv real_{}.avi /home/bzhou/Dropbox/share'.format(epi))
def main(): args = parse_arguments() use_cuda = torch.cuda.is_available() print("[!] preparing dataset...") TEXT = data.Field() train_data, val_data, test_data = datasets.WikiText2.splits(TEXT) TEXT.build_vocab(train_data, min_freq=10) train_iter, val_iter, test_iter = data.BPTTIterator.splits( (train_data, val_data, test_data), batch_size=args.batch_size, bptt_len=30, repeat=False) vocab_size = len(TEXT.vocab) print("[TRAIN]:%d\t[VALID]:%d\t[TEST]:%d\t[VOCAB]%d" % (len(train_iter), len(val_iter), len(test_iter), vocab_size)) print("[!] Instantiating models...") model = RNNModel('LSTM', ntoken=vocab_size, ninp=600, nhid=600, nlayers=2, dropout=0.5) optimizer = optim.Adam(model.parameters(), lr=args.lr) if use_cuda: model.cuda() print(model) best_val_loss = None for e in range(1, args.epochs + 1): train(model, optimizer, train_iter, vocab_size, args.grad_clip, args.log_interval, use_cuda) val_loss = evaluate(model, val_iter, vocab_size, use_cuda) print("[Epoch: %d] val-loss:%5.2f | val-pp:%5.2f" % (e, val_loss, math.exp(val_loss))) # Save the model if the validation loss is the best we've seen so far. if not best_val_loss or val_loss < best_val_loss: print("[!] saving model") if not os.path.isdir(args.save): os.makedirs(args.save) torch.save(model, './%s/lm_%d.pt' % (args.save, e)) best_val_loss = val_loss test_loss = evaluate(model, test_iter, vocab_size, use_cuda) print("[Epoch: %d] test-loss:%5.2f | test-pp:%5.2f" % (e, test_loss, math.exp(test_loss)))
def training(self): vocab_to_id = get_vocab_to_id(self.train_data_path, self.vocab_file, False) logdir = os.path.join( self.summary_path, datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + "/") self.vocab_size = len(vocab_to_id) create_path(self.log_path) logger = get_logger(self.logfile_path) with tf.Session() as sess: summary_writer = tf.summary.FileWriter(logdir, graph=sess.graph) summary_writer.flush() rnn_model = RNNModel(self.rnn_size, self.embedding_size, self.class_num, self.vocab_size, self.learning_rate, self.model_path) test_data_generator = SentenceGenerator(self.test_data_path) testBatchManage = BatchManager(test_data_generator, 0, vocab_to_id) test_data = testBatchManage.get_all_data_to_batch() sess.run(tf.global_variables_initializer()) current_step = 0 for e in range(self.epoch_num): logger.info("Epoch num: " + str(e + 1) + "\n") print("Epoch num: " + str(e + 1) + "\n") train_data_generator = SentenceGenerator(self.train_data_path) trainBatchManage = BatchManager(train_data_generator, self.batch_size, vocab_to_id) for batchs in trainBatchManage.getBatches(): current_step += 1 loss, accuracy, summary_op = rnn_model.train( sess, batchs, self.dropout) if current_step % self.epoch_step == 0: loss_test, accuracy_test, _ = rnn_model.train_test( sess, test_data, 1.0) logger.info("loss:" + str(loss_test) + " accuracy:" + str(accuracy_test) + "\n") print("loss:" + str(loss_test) + " accuracy:" + str(accuracy_test) + "\n") summary_writer.add_summary(summary_op, current_step) rnn_model.saver.save(sess, self.model_path, global_step=current_step)
def train(): # training file on disk train_file = args.train_data # training data class print("starting") trainData = textData(train_file, args.vocab_size) # model model = RNNModel(embedding_size=args.embedding_size, bidir=args.bidir, hidden_units=args.hidden_units, vocab_size=args.vocab_size, batch_size=args.batch_size, num_layers=args.num_layers, num_entities=args.num_entities) # create the genereator for the training set and validation set params = { 'batch_size': args.batch_size, 'shuffle': True, 'num_workers': 1, 'collate_fn': collate_fn } train_gen = data.DataLoader(trainData, **params) max_epochs = args.epochs # loss function and optimizer loss_func = nn.NLLLoss() optimizer = torch.optim.SGD(model.parameters(), lr=args.learning_rate) for epoch in range(max_epochs): for batch_x, batch_y in train_gen: if batch_y.size()[0] < args.batch_size: continue print(batch_x) # make zero grad optimizer.zero_grad() output = model(batch_x) loss = loss_func(output, batch_y) loss.backward() optimizer.step() print(loss)
def test_rnn(): np.random.seed(0) num_layers = 50 seq_length = num_layers * 2 batchsize = 2 vocab_size = 4 data = np.random.randint(0, vocab_size, size=(batchsize, seq_length), dtype=np.int32) source, target = make_source_target_pair(data) model = RNNModel(vocab_size, ndim_embedding=100, num_layers=num_layers, ndim_h=3, kernel_size=3, pooling="fo", zoneout=False, wgain=1) np.random.seed(0) model.reset_state() Y = model(source, test=True).data model.reset_state() np.random.seed(0) for t in xrange(source.shape[1]): y = model.forward_one_step(source[:, :t + 1], test=True).data target = np.swapaxes(np.reshape(Y, (batchsize, -1, vocab_size)), 1, 2) target = np.reshape(np.swapaxes(target[:, :, t, None], 1, 2), (batchsize, -1)) assert np.sum((y - target)**2) == 0 print("t = {} OK".format(t))
def build_model(args, corpus): criterion = None ntokens = len(corpus.dictionary) model = RNNModel(args.model, ntokens, args.emsize, args.nhid, args.nlayers, args.dropout, args.dropouth, args.dropouti, args.dropoute, args.wdrop, args.tied) ### if args.resume: logging.info('Resuming model ...') model, criterion, optimizer = model_load(args.resume_path) optimizer.param_groups[0]['lr'] = args.lr model.dropouti, model.dropouth, model.dropout, args.dropoute = args.dropouti, args.dropouth, args.dropout, args.dropoute if args.wdrop: from weight_drop import WeightDrop for rnn in model.rnns: if type(rnn) == WeightDrop: rnn.dropout = args.wdrop elif rnn.zoneout > 0: rnn.zoneout = args.wdrop ### if not criterion: splits = [] if ntokens > 500000: # One Billion # This produces fairly even matrix mults for the buckets: # 0: 11723136, 1: 10854630, 2: 11270961, 3: 11219422 splits = [4200, 35000, 180000] elif ntokens > 75000: # WikiText-103 splits = [2800, 20000, 76000] logging.info(f'Using {splits}') criterion = SplitCrossEntropyLoss(args.emsize, splits=splits, verbose=False) ### params = list(model.parameters()) + list(criterion.parameters()) total_params = sum(x.size()[0] * x.size()[1] if len(x.size()) > 1 else x.size()[0] for x in params if x.size()) logging.info(f'Args: {args}') logging.info(f'Model total parameters: {total_params}') if args.cuda: model = model.cuda() criterion = criterion.cuda() return model, criterion
def build_worker_graph(training_filename): with tf.variable_scope('training_input_pipeline'): it, next_ele = get_input_iterator(training_filename, config['batch_size'], len(args.worker_hosts.split(",")), args.task_index) with tf.variable_scope("model"): model = RNNModel(next_ele, config) return model, next_ele, it
def build_model(args, ntokens: int): """ Returns model and loss function. """ print('INFO: Building model') model = RNNModel(args.model, ntokens, args.emsize, args.nhid, args.nlayers, args.dropout, args.dropouth, args.dropouti, args.dropoute, args.wdrop, args.tied) if args.cuda: print('INFO: Moving model to GPU') model.cuda() total_params = sum(x.size()[0] * x.size()[1] if len(x.size()) > 1 else x.size()[0] for x in model.parameters()) print('INFO: Model total parameters:', total_params) criterion = nn.CrossEntropyLoss() return model, criterion
def train(args): checkpoint_path = args.checkpoint_path dajare_sentence = args.query nlp = spacy.load('ja_ginza_nopn') words = nlp(dajare_sentence) words = [w.orth_ for w in words] batch_size = 32 T = 32 emb_size = 128 hidden_size = 128 dropout = 0.0 lr = 1e-3 data_gen = DataForGenerator(batch_size=batch_size, T=T) data_gen.load_vocab('./vocab.csv', vocab_size=50000) words_id, _ = data_gen.preprocess([words], None) vocab_size = len(data_gen.vocab.word2id) print("Vocab size: ", vocab_size) model = RNNModel( batch_size=batch_size, vocab_size=vocab_size, emb_size=emb_size, hidden_size=hidden_size, T=T, dropout=dropout, lr=lr, model_path=None) model.load_weights(checkpoint_path) print(words) print(words_id) pred = model.predict(words_id[0]) print(pred) print(pred.shape)
def predicting_1(self): vocab_to_id = get_vocab_to_id(self.train_data_path, self.vocab_file, False) data_helper = DataHelper(vocab_to_id) dishs = [u"网上的口碑什么的蛮好的一家店 专门打了个电话让这边的师傅上门帮我们家的小宝宝理了一个头发"] batch = data_helper.create_prediction_batch(dishs) with tf.Session() as sess: cnn_model = RNNModel(self.rnn_size, self.embedding_size, self.class_num, len(vocab_to_id), self.learning_rate, self.model_path) ckpt = tf.train.get_checkpoint_state(self.model_dir) cnn_model.saver.restore(sess, ckpt.model_checkpoint_path) prediction, pre_label = cnn_model.predict(sess, batch) pre_pre = sess.run(tf.nn.softmax(prediction)) print pre_label, pre_pre, prediction for idx, sub_review_lable in enumerate(pre_label): print "{}\t{}".format( dishs[idx], data_helper.get_cats_name(sub_review_lable))
def predicting_2(self): vocab_to_id = get_vocab_to_id(self.train_data_path, self.vocab_file, False) data_helper = DataHelper(vocab_to_id) data_generator = SentenceGenerator("data/other_data") batchManage = BatchManager(data_generator, self.batch_size, vocab_to_id) writer = open("data/res_other", "w") with tf.Session() as sess: models = RNNModel(self.rnn_size, self.embedding_size, self.class_num, len(vocab_to_id), self.learning_rate, self.model_path) ckpt = tf.train.get_checkpoint_state(self.model_dir) models.saver.restore(sess, ckpt.model_checkpoint_path) for batchs in batchManage.getBatches(): prediction, pre_label = models.predict(sess, batchs) for sub_review_lable in pre_label: writer.write(str(sub_review_lable) + "\n")
def exporting_model(self): vocab_to_id = get_vocab_to_id(self.train_data_path, self.vocab_file, False) with tf.Session() as sess: rnn_model = RNNModel(self.rnn_size, self.embedding_size, self.class_num, len(vocab_to_id), self.learning_rate, self.model_path) ckpt = tf.train.get_checkpoint_state(self.model_dir) rnn_model.saver.restore(sess, ckpt.model_checkpoint_path) export_model(sess, rnn_model, "export/", "1", vocab_to_id)
def run(isGen, topic=u"静夜思:"): file_name = "poem.txt" args = ControlParm() data = DataHandle(file_name, args) interface = Interface() model = RNNModel(args, data, isGen=isGen) if isGen == 0: print("[INFO] start trainning") interface.train(data, model, args) else: interface.generate(data, model, args, topic)
def load_model_corpora(checkpoint): """ Load the model the checkpoint pointed at by `checkpoint' is for and the corpora indicated in the arguments within the checkpoint. """ try: checkpoint = load_checkpoint(checkpoint) args = checkpoint['args'] params = checkpoint['params'] except Exception as e: print('The following exception ocurred:') print(e) raise RuntimeError('The first object in checkpoint must be a ' 'dictionary containing at least [args,params].') # Use the arguments to create a model that is the same as the one we have # the parameters for. if args.load: with open(args.load, 'rb') as f: stored_dict = pickle.load(f) corpora = Corpus(args.corpus, load=True, vocab=stored_dict['vocabulary'], vectors=stored_dict['vectors']) else: # I never do load = False. corpora = None if not hasattr(args, 'old_model'): args.old_model = False if args.old_model: model = old_model('LSTM', len(corpora.vocab), args.encoder_size, args.hidden_size, args.layers, args.dropout) else: encoder = Encoder(50, len(corpora.vocab), corpora.vectors) model = RNNModel(encoder.encoding_size, args.hidden_size, len(corpora.vocab), args.layers, encoder, dropout=args.dropout) # load the parameters from checkpoint model.load_state_dict(params) return model, corpora