def task2():
print("Threading for loading model")
# Uncomment the below statement if you have already saved the model or comment it if you want to train model
model_ = Seq2seq(decoder_seq_length = decoder_seq_length,
cell_enc=tf.keras.layers.LSTMCell,
cell_dec=tf.keras.layers.LSTMCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size, embedding_size=emb_dim))
return model_
def __init__(self):
# preProcessor is only utilised here to avoid duplicating string2array
self.preProcessor = DataPreProcessor("")
self.model_ = Seq2seq(
decoder_seq_length=self.decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(
vocabulary_size=self.vocabulary_size,
embedding_size=self.emb_dim),
)
load_weights = tl.files.load_npz(name="data/model.npz")
tl.files.assign_weights(load_weights, self.model_)
def get_model(vocab_size):
embedding_size = model_config['embedding_size']
hidden_unit = model_config['hidden_unit']
hidden_layer = model_config['hidden_layer']
decoder_seq_length = model_config['decoder_seq_length']
model = Seq2seq(
embedding_layer=tl.layers.Embedding(vocabulary_size=vocab_size,
embedding_size=embedding_size),
n_layer=hidden_layer,
n_units=hidden_unit,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
decoder_seq_length=decoder_seq_length,
)
return model
def init():
global model_, word2idx, start_id, unk_id, idx2word
data_corpus = "twitter"
#data preprocessing
metadata, trainX, trainY, testX, testY, validX, validY = initial_setup(
data_corpus)
# Parameters
src_len = len(trainX)
tgt_len = len(trainY)
assert src_len == tgt_len
batch_size = 32
n_step = src_len // batch_size
src_vocab_size = len(metadata['idx2w']) # 8002 (0~8001)
emb_dim = 1024
word2idx = metadata['w2idx'] # dict word 2 index
idx2word = metadata['idx2w'] # list index 2 word
unk_id = word2idx['unk'] # 1
pad_id = word2idx['_'] # 0
start_id = src_vocab_size # 8002
end_id = src_vocab_size + 1 # 8003
word2idx.update({'start_id': start_id})
word2idx.update({'end_id': end_id})
idx2word = idx2word + ['start_id', 'end_id']
src_vocab_size = tgt_vocab_size = src_vocab_size + 2
num_epochs = 3
vocabulary_size = src_vocab_size
decoder_seq_length = 20
model_ = Seq2seq(
decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size,
embedding_size=emb_dim),
)
model_.load_weights("model.hdf5")
def test_basic_simpleSeq2Seq(self):
model_ = Seq2seq(
decoder_seq_length=5,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=128,
embedding_layer=tl.layers.Embedding(vocabulary_size=self.vocab_size, embedding_size=self.embedding_size),
)
optimizer = tf.optimizers.Adam(learning_rate=0.001)
for epoch in range(self.num_epochs):
model_.train()
trainX, trainY = shuffle(self.trainX, self.trainY)
total_loss, n_iter = 0, 0
for X, Y in tqdm(tl.iterate.minibatches(inputs=trainX, targets=trainY, batch_size=self.batch_size,
shuffle=False), total=self.n_step,
desc='Epoch[{}/{}]'.format(epoch + 1, self.num_epochs), leave=False):
dec_seq = Y[:, :-1]
target_seq = Y[:, 1:]
with tf.GradientTape() as tape:
## compute outputs
output = model_(inputs=[X, dec_seq])
output = tf.reshape(output, [-1, self.vocab_size])
loss = cross_entropy_seq(logits=output, target_seqs=target_seq)
grad = tape.gradient(loss, model_.all_weights)
optimizer.apply_gradients(zip(grad, model_.all_weights))
total_loss += loss
n_iter += 1
model_.eval()
test_sample = trainX[0:2, :].tolist()
top_n = 1
for i in range(top_n):
prediction = model_([test_sample], seq_length=self.dec_seq_length, start_token=0, top_n=1)
print("Prediction: >>>>> ", prediction, "\n Target: >>>>> ", trainY[0:2, 1:], "\n\n")
# printing average loss after every epoch
print('Epoch [{}/{}]: loss {:.4f}'.format(epoch + 1, self.num_epochs, total_loss / n_iter))
def __init__(self):
#data preprocessing
metadata, trainX, trainY, testX, testY, validX, validY = self.initial_setup(
)
# Parameters
src_len = len(trainX)
tgt_len = len(trainY)
assert src_len == tgt_len
batch_size = 32
n_step = src_len // batch_size
src_vocab_size = len(metadata['idx2w']) # 8002 (0~8001)
emb_dim = 1024
self.word2idx = metadata['w2idx'] # dict word 2 index
self.idx2word = metadata['idx2w'] # list index 2 word
self.unk_id = self.word2idx['unk'] # 1
pad_id = self.word2idx['_'] # 0
self.start_id = src_vocab_size # 8002
end_id = src_vocab_size + 1 # 8003
self.word2idx.update({'start_id': self.start_id})
self.word2idx.update({'end_id': end_id})
self.idx2word = self.idx2word + ['start_id', 'end_id']
src_vocab_size = tgt_vocab_size = src_vocab_size + 2
vocabulary_size = src_vocab_size
self.model_ = Seq2seq(
decoder_seq_length=50,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=5,
n_units=256,
embedding_layer=tl.layers.Embedding(
vocabulary_size=vocabulary_size, embedding_size=emb_dim),
)
load_weights = tl.files.load_npz(name='for_adis/classes/model.npz')
tl.files.assign_weights(load_weights, self.model_)
def __init__(self):
data_corpus = "twitter"
metadata, idx_q, idx_a = data.load_data(
PATH='data/{}/'.format(data_corpus))
src_vocab_size = len(metadata['idx2w']) # 8002 (0~8001)
emb_dim = 1024
word2idx = metadata['w2idx'] # dict word 2 index
idx2word = metadata['idx2w'] # list index 2 word
unk_id = word2idx['unk'] # 1
pad_id = word2idx['_'] # 0
start_id = src_vocab_size # 8002
end_id = src_vocab_size + 1 # 8003
word2idx.update({'start_id': start_id})
word2idx.update({'end_id': end_id})
idx2word = idx2word + ['start_id', 'end_id']
src_vocab_size = tgt_vocab_size = src_vocab_size + 2
# num_epochs = 5
vocabulary_size = src_vocab_size
decoder_seq_length = 20
self.unk_id = unk_id
self.pad_id = pad_id
self.start_id = start_id
self.end_id = end_id
self.word2idx = word2idx
self.idx2word = idx2word
self.model_ = Seq2seq(
decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(
vocabulary_size=vocabulary_size, embedding_size=emb_dim),
)
load_weights = tl.files.load_npz(name='model.npz')
tl.files.assign_weights(load_weights, self.model_)
start_token=start_id,
top_n=top_n)
sentence = []
for w_id in sentence_id[0]:
w = idx2word[w_id]
if w == 'end_id':
break
sentence = sentence + [w]
return sentence
decoder_seq_length = 20
model_ = Seq2seq(
decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size,
embedding_size=emb_dim),
)
# Uncomment below statements if you have already saved the model
# load_weights = tl.files.load_npz(name='model.npz')
# tl.files.assign_weights(load_weights, model_)
optimizer = tf.optimizers.Adam(learning_rate=0.001)
model_.train()
seeds = [
"happy birthday have a nice day",
def inference(seed, top_n):
#try changiong to cornell or twitter if it doesnt work
data_corpus = "cornell_corpus"
metadata, trainX, trainY, testX, testY, validX, validY = initial_setup(
data_corpus)
src_len = len(testX)
tgt_len = len(testY)
assert src_len == tgt_len
batch_size = 32
n_step = src_len // batch_size
src_vocab_size = len(metadata['idx2w']) # 8002 (0~8001)
emb_dim = 1024
word2idx = metadata['w2idx']
idx2word = metadata['idx2w']
unk_id = word2idx['unk']
pad_id = word2idx['_']
start_id = src_vocab_size
end_id = src_vocab_size + 1
word2idx.update({'start_id': start_id})
word2idx.update({'end_id': end_id})
idx2word = idx2word + ['start_id', 'end_id']
src_vocab_size = tgt_vocab_size = src_vocab_size + 2
num_epochs = 8
vocabulary_size = src_vocab_size
decoder_seq_length = 20
model_ = Seq2seq(
decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size,
embedding_size=emb_dim),
)
load_weights = tl.files.load_npz(name='model8.npz')
tl.files.assign_weights(load_weights, model_)
seed_id = [word2idx.get(w, unk_id) for w in seed.split(" ")]
sentence_id = model_(inputs=[[seed_id]],
seq_length=20,
start_token=start_id,
top_n=1)
sentence = []
for w_id in sentence_id[0]:
w = idx2word[w_id]
if w == 'end_id':
break
sentence = sentence + [w]
sntnc = ' '.join(sentence)
return str(sntnc)
for w_id in sentence_id[0]:
w = idx2word[w_id]
if w == 'end_id':
break
sentence = sentence + [w]
return sentence
decoder_seq_length = 20
# создание модели seq2seq
# encoder и decoder основаны на GRU
model_ = Seq2seq(
decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
# это таблица соответствия для встраивания слов.
# Embedding Доступ к содержимому слова осуществляется с помощью целочисленных индексов,
# а затем вывод представляет собой встроенный вектор слова
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size,
embedding_size=emb_dim),
)
# Uncomment below statements if you have already saved the model
load_weights = tl.files.load_npz(name='model.npz')
tl.files.assign_weights(load_weights, model_)
# усовершенствованный градиентный спуск, запомиает напраление предыдущих градиентов
# которые добавляются к текущему градиенту
optimizer = tf.optimizers.Adam(learning_rate=0.001)
model_.train()
batch_size = 192
n_step = src_len // batch_size
emb_dim = 1024 # embedding dictionary size
num_epochs = 20 # epochs to train for
vocabulary_size = len(word2idx)
start_id = word2idx['start_id'] # <bos>
end_id = word2idx['end_id'] # <eos>
unk_id = word2idx['unk'] # id for an unknown word
pad_id = word2idx['_'] # id for padding
# construct the model
embedding_layer = tl.layers.Embedding(vocabulary_size=vocabulary_size, embedding_size=emb_dim)
model_ = Seq2seq(decoder_seq_length=decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3, # number of GRU layers
n_units=300,
embedding_layer=embedding_layer)
# load the model if its there
if os.path.isfile (model_file):
load_weights = tl.files.load_npz(name=model_file)
tl.files.assign_weights(load_weights, model_)
print ("loaded weights")
chat () # chat with the model
train_model () # train it also
def testdata(seed):
data_corpus = "chatapp"
#data preprocessing
metadata, trainX, trainY, testX, testY, validX, validY = initial_setup(data_corpus)
# Parameters
src_len = len(trainX)
tgt_len = len(trainY)
assert src_len == tgt_len
batch_size = 32
n_step = src_len // batch_size
src_vocab_size = len(metadata['idx2w']) # 8002 (0~8001)
emb_dim = 1024
word2idx = metadata['w2idx'] # dict word 2 index
idx2word = metadata['idx2w'] # list index 2 word
unk_id = word2idx['unk'] # 1
pad_id = word2idx['_'] # 0
start_id = src_vocab_size # 8002
end_id = src_vocab_size + 1 # 8003
word2idx.update({'start_id': start_id})
word2idx.update({'end_id': end_id})
idx2word = idx2word + ['start_id', 'end_id']
src_vocab_size = tgt_vocab_size = src_vocab_size + 2
num_epochs = 100
vocabulary_size = src_vocab_size
def inference(seed, top_n):
model_.eval()
seed_id = [word2idx.get(w, unk_id) for w in seed.split(" ")]
sentence_id = model_(inputs=[[seed_id]], seq_length=20, start_token=start_id, top_n = top_n)
sentence = []
for w_id in sentence_id[0]:
w = idx2word[w_id]
if w == 'end_id':
break
sentence = sentence + [w]
return sentence
decoder_seq_length = 20
model_ = Seq2seq(
decoder_seq_length = decoder_seq_length,
cell_enc=tf.keras.layers.GRUCell,
cell_dec=tf.keras.layers.GRUCell,
n_layer=3,
n_units=256,
embedding_layer=tl.layers.Embedding(vocabulary_size=vocabulary_size, embedding_size=emb_dim),
)
load_weights = tl.files.load_npz(name='model.npz')
tl.files.assign_weights(load_weights, model_)
top_val=''
leng=400
top_n = 3
for i in range(top_n):
sentence = inference(seed, top_n)
value=str(' '.join(sentence)).replace("unk","")
if len(value)<leng:
top_val=value
leng=len(value)
top_val=top_val.strip()
prev=top_val
return top_val