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
