print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
# embed()
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
# embed()
if (MODEL_TO_RUN == 0):
model = CNN_LSTM(seq_legth, num_classes, embedding_dim,
filter_sizes, num_filters, num_hidden)
elif (MODEL_TO_RUN == 1):
model = LSTM_CNN(seq_legth, num_classes, embedding_dim,
filter_sizes, num_filters, num_hidden)
# elif (MODEL_TO_RUN == 2):
# model = CNN(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),
# embedding_dim,filter_sizes,num_filters,l2_reg_lambda)
# elif (MODEL_TO_RUN == 3):
# model = LSTM(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim)
else:
print(
"PLEASE CHOOSE A VALID MODEL!\n0 = CNN_LSTM\n1 = LSTM_CNN\n2 = CNN\n3 = LSTM\n"
)
exit()
# Define Training procedure
print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev)))
# embed()
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
# embed()
if (MODEL_TO_RUN == 0):
model = CNN_LSTM(x_train.shape[1], y_train.shape[1],
len(vocab_processor.vocabulary_), embedding_dim,
filter_sizes, num_filters, l2_reg_lambda)
elif (MODEL_TO_RUN == 1):
model = LSTM_CNN(x_train.shape[1], y_train.shape[1],
len(vocab_processor.vocabulary_), embedding_dim,
filter_sizes, num_filters, l2_reg_lambda)
elif (MODEL_TO_RUN == 2):
model = CNN(x_train.shape[1], y_train.shape[1],
len(vocab_processor.vocabulary_), embedding_dim,
filter_sizes, num_filters, l2_reg_lambda)
elif (MODEL_TO_RUN == 3):
model = LSTM(x_train.shape[1], y_train.shape[1],
len(vocab_processor.vocabulary_), embedding_dim)
else:
print
"PLEASE CHOOSE A VALID MODEL!\n0 = CNN_LSTM\n1 = LSTM_CNN\n2 = CNN\n3 = LSTM\n"
batch_size=args.batch_size,
shuffle=True,
num_workers=16)
validloader = DataLoader(valid,
batch_size=args.batch_size,
shuffle=False,
num_workers=16)
testloader = DataLoader(test,
batch_size=args.batch_size,
shuffle=False,
num_workers=16)
if args.model == "CNN_MLP":
model = CNN_MLP(args)
elif args.model == "CNN_LSTM":
model = CNN_LSTM(args)
elif args.model == "Resnet18_MLP":
model = Resnet18_MLP(args)
if args.resume:
model.load_model(args.save, 0)
print('Loaded model')
if args.cuda:
model = model.cuda()
def train(epoch):
model.train()
train_loss = 0
accuracy = 0
def main(embdFilePath, embdDim, outFolderName, num_epochs):
# Load data
print("Loading data...")
x_text, y = batchgen.get_dataset(goodfile, badfile,
5000) #TODO: MAX LENGTH
max_document_length = max([len(x.split(" ")) for x in x_text])
x, y, vocab_processor = generateData(embdFilePath, embdDim, x_text, y,
max_document_length)
# Randomly shuffle data
np.random.seed(42)
shuffle_indices = np.random.permutation(np.arange(len(y)))
x_shuffled = x[shuffle_indices]
y_shuffled = y[shuffle_indices]
# Split train/test set
# TODO: This is very crude, should use cross-validation
dev_sample_index = -1 * int(dev_size * float(len(y)))
x_train, x_dev = x_shuffled[:dev_sample_index], x_shuffled[
dev_sample_index:]
y_train, y_dev = y_shuffled[:dev_sample_index], y_shuffled[
dev_sample_index:]
print("Vocabulary Size: {:d}".format(len(vocab_processor.vocabulary_)))
print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev)))
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
model = CNN_LSTM(x_train.shape[1], y_train.shape[1],
len(vocab_processor.vocabulary_), embdDim,
filter_sizes, num_filters, l2_reg_lambda)
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(model.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in grads_and_vars:
if g is not None:
grad_hist_summary = tf.summary.histogram(
"{}/grad/hist".format(v.name), g)
sparsity_summary = tf.summary.scalar(
"{}/grad/sparsity".format(v.name),
tf.nn.zero_fraction(g))
grad_summaries.append(grad_hist_summary)
grad_summaries.append(sparsity_summary)
grad_summaries_merged = tf.summary.merge(grad_summaries)
# Output directory for models and summaries
timestamp = str(int(time.time()))
out_dir = os.path.abspath(
os.path.join(os.path.curdir, outFolderName, timestamp))
print("Writing to {}\n".format(out_dir))
# Summaries for loss and accuracy
loss_summary = tf.summary.scalar("loss", model.loss)
acc_summary = tf.summary.scalar("accuracy", model.accuracy)
# Train Summaries
train_summary_op = tf.summary.merge(
[loss_summary, acc_summary, grad_summaries_merged])
train_summary_dir = os.path.join(out_dir, "summaries", "train")
train_summary_writer = tf.summary.FileWriter(
train_summary_dir, sess.graph)
# Dev summaries
dev_summary_op = tf.summary.merge([loss_summary, acc_summary])
dev_summary_dir = os.path.join(out_dir, "summaries", "dev")
dev_summary_writer = tf.summary.FileWriter(dev_summary_dir,
sess.graph)
# Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it
checkpoint_dir = os.path.abspath(
os.path.join(out_dir, "checkpoints"))
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
saver = tf.train.Saver(tf.global_variables(),
max_to_keep=num_checkpoints)
# Write vocabulary
vocab_processor.save(os.path.join(out_dir, "vocab"))
# Initialize all variables
sess.run(tf.global_variables_initializer())
#TRAINING STEP
def train_step(x_batch, y_batch, save=False):
feed_dict = {
model.input_x: x_batch,
model.input_y: y_batch,
model.dropout_keep_prob: dropout_prob
}
_, step, summaries, loss, accuracy = sess.run([
train_op, global_step, train_summary_op, model.loss,
model.accuracy
], feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(
time_str, step, loss, accuracy))
if save:
train_summary_writer.add_summary(summaries, step)
#EVALUATE MODEL
def dev_step(x_batch, y_batch, writer=None, save=False):
feed_dict = {
model.input_x: x_batch,
model.input_y: y_batch,
model.dropout_keep_prob: 0.5
}
step, summaries, loss, accuracy = sess.run(
[global_step, dev_summary_op, model.loss, model.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(
time_str, step, loss, accuracy))
if save:
if writer:
writer.add_summary(summaries, step)
#CREATE THE BATCHES GENERATOR
batches = batchgen.gen_batch(list(zip(x_train, y_train)),
batch_size, num_epochs)
#TRAIN FOR EACH BATCH
for batch in batches:
x_batch, y_batch = zip(*batch)
train_step(x_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % evaluate_every == 0:
print("\nEvaluation:")
dev_step(x_dev, y_dev, writer=dev_summary_writer)
print("")
if current_step % checkpoint_every == 0:
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
dev_step(x_dev, y_dev, writer=dev_summary_writer)
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
x_train = x[train_index, :, :]
y_test = y[test_index, :]
y_train = y[train_index, :]
print(x_train.shape)
print(y_train.shape)
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
# embed()
if (MODEL_TO_RUN == 0):
model = CNN_LSTM(x_train.shape[1], y_train.shape[1], embedding_dim,
filter_sizes, num_filters, num_hidden)
elif (MODEL_TO_RUN == 1):
model = LSTM_CNN(x_train.shape[1], y_train.shape[1], 21,
embedding_dim, filter_sizes, num_filters,
l2_reg_lambda)
elif (MODEL_TO_RUN == 2):
model = CNN(x_train.shape[1], y_train.shape[1], 26, embedding_dim,
filter_sizes, num_filters, l2_reg_lambda)
elif (MODEL_TO_RUN == 3):
model = LSTM(x_train.shape[1], y_train.shape[1], 26, embedding_dim)
else:
print
"PLEASE CHOOSE A VALID MODEL!\n0 = CNN_LSTM\n1 = LSTM_CNN\n2 = CNN\n3 = LSTM\n"
exit()
# Define Training procedure
def pre(seq, value):
global pres0, pres
X = []
for sequence in seq:
sequence = sequence.tolist()
for i, t in enumerate(sequence):
t = id2word.get((int(t)))
if t is None:
sequence[i] = '0'
else:
sequence[i] = t
sequences = []
sequence = ''.join(sequence)
sequence = sequence.replace('X', '0')
sequence = sequence.replace('U', '0')
sequence = sequence.replace('O', '0')
sequence = sequence.replace('B', 'N')
sequence = sequence.replace('Z', 'Q')
sequence = sequence.replace('J', 'L')
sequence = list(sequence)
if len(sequence) >= max_sequence_size:
a = int((len(sequence) - max_sequence_size))
for i in list(range(a)):
sequence.pop(51)
# sequences.append(list((ord(t)-64) for t in sequence))
sequences.append(sequence)
else:
b = int((max_sequence_size - len(sequence)))
for i in list(range(b)):
sequence.insert(int((len(sequence))), '0')
sequences.append(sequence)
X.append(sequences[0])
acid_letters = [
'0', 'A', 'C', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'M', 'L', 'N', 'Q',
'P', 'S', 'R', 'T', 'W', 'V', 'Y'
]
le = LabelEncoder()
datas = np_utils.to_categorical(le.fit_transform(acid_letters))
def two2three(x):
xx = []
for _, m in enumerate(x):
k = []
for j, t in enumerate(m):
if t not in acid_letters:
t = '0'
n = acid_letters.index(t)
k.append(datas[n])
xx.append(k)
return np.array(xx)
x_train = np.array(two2three(X))
print(x_train.shape)
# Training
# ==================================================
batches = batchgen.gen_batch(x_train, batch_size, num_epochs)
with tf.Graph().as_default():
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
model = CNN_LSTM(x_train.shape[1], embedding_dim, filter_sizes,
num_filters, num_hidden)
# Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it
checkpoint_dir = os.path.abspath(
os.path.join("runs_deeploc", "checkpoints"))
saver = tf.train.Saver(tf.global_variables(),
max_to_keep=num_checkpoints)
sess.run(tf.global_variables_initializer())
# EVALUATE MODEL
def dev_step(x_batch, writer=None):
feed_dict = {
model.input_x: x_batch,
model.dropout_keep_prob: 1
}
pre = sess.run(model.predictions, feed_dict)
return pre
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
saver.restore(sess, ckpt.model_checkpoint_path)
new_posi = []
new_nege = []
'''
for i,batch in enumerate(batches):
if i == 0:
pres0 = dev_step(batch)
elif i == 1:
pres1 = dev_step(batch)
pres = np.concatenate((pres0, pres1))
else:
press = dev_step(batch)
pres = np.concatenate((pres, press))
'''
pres = dev_step(x_train)
# ['Cell.membrane', 'Cytoplasm', 'Endoplasmic.reticulum', 'Extracellular', 'Golgi apparatus', 'Lysosome/Vacuole', 'Mitochandrion', 'Nucleus', 'Peroxisome', 'Plastid']
# ['Cell.membrane', 'Cytoplasm', 'Endoplasmic.reticulum', 'Golgi.apparatus', 'Lysosome/Vacuole', 'Mitochondrion', 'Nucleus', 'Peroxisome', 'Plastid', 'Extracellular'] [0, 1, 2, 4, 5, 6, 7, 8, 9, 3]
print(len(pres))
for i, t in enumerate(pres):
#print(np.argmax(t))
if t[7] >= value:
new_posi.append(seq[i])
elif t[3] >= value:
new_nege.append(seq[i])
print(len(new_posi))
accuracy = len(new_posi) / len(pres)
print(accuracy)
with open("acc_0.65.txt", "a") as f:
f.write(str(accuracy))
f.write("\n")
return new_posi, new_nege
print('test data:', len(x_test), len(y_test))
print("Vocabulary Size: {:d}".format(n_symbols))
print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_test)))
# Training
# ==================================================
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False,
gpu_options=gpu_options)
sess = tf.Session(config=session_conf)
with sess.as_default():
#embed()
if (MODEL_TO_RUN == 0):
model = CNN_LSTM(max_seq_legth, 1, 5000, 300, filter_sizes,
num_filters, l2_reg_lambda)
elif (MODEL_TO_RUN == 1):
model = LSTM_CNN(max_seq_legth,
1,
n_symbols,
200,
filter_sizes,
num_filters,
l2_reg_lambda,
weight=embedding_weights)
# elif (MODEL_TO_RUN == 2):
# model = CNN(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim,filter_sizes,num_filters,l2_reg_lambda)
# elif (MODEL_TO_RUN == 3):
# model = LSTM(x_train.shape[1],y_train.shape[1],len(vocab_processor.vocabulary_),embedding_dim)
else:
print(
