def train(model_name=None, hparams=None, train_csv_path=None, train_clip_dir=None,
class_map_path=None, train_dir=None, sample_rate=None):
"""Runs the training loop."""
print('\nTraining model:{} with hparams:{} and class map:{}'.format(model_name, hparams, class_map_path))
print('Training data: clip dir {} and labels {}'.format(train_clip_dir, train_csv_path))
print('Training dir {}\n'.format(train_dir))
with tf.Graph().as_default():
# Create the input pipeline.
features, labels, num_classes, input_init = inputs.train_input(
train_csv_path=train_csv_path, train_clip_dir=train_clip_dir, class_map_path=class_map_path,
hparams=hparams, sample_rate=sample_rate)
# Create the model in training mode.
global_step, prediction, loss_tensor, train_op = model.define_model(
model_name=model_name, features=features, labels=labels, num_classes=num_classes,
hparams=hparams, training=True)
# Define our own checkpoint saving hook, instead of using the built-in one,
# so that we can specify additional checkpoint retention settings.
saver = tf.train.Saver(
max_to_keep=30, keep_checkpoint_every_n_hours=0.25)
saver_hook = tf.train.CheckpointSaverHook(
save_steps=250, checkpoint_dir=train_dir, saver=saver)
summary_op = tf.summary.merge_all()
summary_hook = tf.train.SummarySaverHook(
save_steps=50, output_dir=train_dir, summary_op=summary_op)
with tf.train.SingularMonitoredSession(hooks=[saver_hook, summary_hook],
checkpoint_dir=train_dir) as sess:
sess.raw_session().run(input_init)
while not sess.should_stop():
step, _, pred, loss = sess.run([global_step, train_op, prediction, loss_tensor])
print(step, loss)
sys.stdout.flush()
def eval(model_name=None,
hparams=None,
test_csv_path=None,
test_clip_dir=None,
class_map_path=None,
checkpoint_path=None):
with tf.Graph().as_default():
label_class_index_table, num_classes = input.get_class_map(
class_map_path)
csv_record = tf.placeholder(tf.string, [])
features, labels = input.record_to_labeled_log_mel_examples(
csv_record,
clip_dir=test_clip_dir,
hparams=hparams,
label_class_index_table=label_class_index_table,
num_classes=num_classes)
global_step, prediction, _, _ = model.define_model(
model_name=model_name,
features=features,
num_classes=num_classes,
hparams=hparams,
training=False)
saver = tf.train.Saver()
with tf.train.SingularMonitoredSession(
checkpoint_filename_with_path=checkpoint_path) as sess:
class_map = {
int(row[0]): row[1]
for row in csv.reader(open(class_map_path))
}
ap_counts = defaultdict(int)
ap_sums = defaultdict(float)
test_records = open(test_csv_path).readlines()
for (i, record) in enumerate(test_records[1:]):
record = record.strip()
actual, predicted = sess.run([labels, prediction],
{csv_record: record})
actual_class = np.argmax(actual[0])
predicted = np.average(predicted, axis=0)
predicted_classes = np.argsort(predicted)[::-1][:TOP_N]
ap = avg_precision(actual=actual_class,
predicted=predicted_classes)
print(actual_class, predicted_classes, ap)
ap_counts[actual_class] += 1
ap_sums[actual_class] += ap
if i % 50 == 0:
print_maps(ap_sums=ap_sums,
ap_counts=ap_counts,
class_map=class_map)
sys.stdout.flush()
print_maps(ap_sums=ap_sums,
ap_counts=ap_counts,
class_map=class_map)
def train(model_name=None,
hparams=None,
train_csv_path=None,
train_clip_dir=None,
class_map_path=None,
train_dir=None,
sample_rate=None):
"""Runs the training loop."""
print('\nTraining model:{} with hparams:{} and class map:{}'.format(
model_name, hparams, class_map_path))
print('Training data: clip dir {} and labels {}'.format(
train_clip_dir, train_csv_path))
print('Training dir {}\n'.format(train_dir))
with tf.Graph().as_default():
# Create the input pipeline.
features, labels, num_classes, input_init = inputs.train_input(
train_csv_path=train_csv_path,
train_clip_dir=train_clip_dir,
class_map_path=class_map_path,
hparams=hparams,
sample_rate=sample_rate)
# Create the model in training mode.
global_step, prediction, loss_tensor, train_op = model.define_model(
model_name=model_name,
features=features,
labels=labels,
num_classes=num_classes,
hparams=hparams,
training=True)
# Define our own checkpoint saving hook, instead of using the built-in one,
# so that we can specify additional checkpoint retention settings.
saver = tf.train.Saver(max_to_keep=30,
keep_checkpoint_every_n_hours=0.25)
saver_hook = tf.train.CheckpointSaverHook(save_steps=250,
checkpoint_dir=train_dir,
saver=saver)
summary_op = tf.summary.merge_all()
summary_hook = tf.train.SummarySaverHook(save_steps=50,
output_dir=train_dir,
summary_op=summary_op)
with tf.train.SingularMonitoredSession(
hooks=[saver_hook,
summary_hook], checkpoint_dir=train_dir) as sess:
sess.raw_session().run(input_init)
while not sess.should_stop():
step, _, pred, loss = sess.run(
[global_step, train_op, prediction, loss_tensor])
print(step, loss)
sys.stdout.flush()
def __init__(self):
self.TRAINING_DATA_DIRECTORY = "./dataset/train"
self.VALIDATION_DATA_DIRECTORY = "./dataset/validation"
self.EPOCHS = 10
self.BATCH_SIZE = 64
self.IMAGE_HEIGHT = 224
self.IMAGE_WIDTH = 224
self.CHANNELS = 3
self.NUMBER_OF_TRAINING_IMAGES = 3198
self.NUMBER_OF_VALIDATION_IMAGES = 100
self.model = define_model()
self.training_generator = None
self.validation_generator = None
def inference(model_name=None,
hparams=None,
test_clip_dir=None,
class_map_path=None,
checkpoint_path=None,
predictions_csv_path=None):
with tf.Graph().as_default():
_, num_classes = input.get_class_map(class_map_path)
clip = tf.placeholder(tf.string, [])
features = input.clip_to_log_mel_examples(clip,
clip_dir=test_clip_dir,
hparams=hparams)
_, prediction, _, _ = model.define_model(model_name=model_name,
features=features,
num_classes=num_classes,
hparams=hparams,
training=False)
saver = tf.train.Saver()
with tf.train.SingularMonitoredSession(
checkpoint_filename_with_path=checkpoint_path) as sess:
class_map = {
int(row[0]): row[1]
for row in csv.reader(open(class_map_path))
}
test_clips = sorted(os.listdir(test_clip_dir))
pred_writer = csv.DictWriter(open(predictions_csv_path, 'w'),
fieldnames=['fname', 'label'])
for (i, test_clip) in enumerate(test_clips):
print(i, test_clip)
sys.stdout.flush()
# Hack to avoid passing empty files through the model.
if os.path.getsize(os.path.join(test_clip_dir,
test_clip)) == 44:
print('empty file, skipped model')
label = ''
else:
predicted = sess.run(prediction, {clip: test_clip})
predicted = np.average(predicted, axis=0)
predicted_classes = np.argsort(predicted)[::-1][:TOP_N]
label = ' '.join([class_map[c] for c in predicted_classes])
pred_writer.writerow({'fname': test_clip, 'label': label})
print(label)
sys.stdout.flush()
def train(model_name=None,
hparams=None,
train_csv_path=None,
train_clip_dir=None,
class_map_path=None):
with tf.Graph().as_default():
features, labels, num_classes, input_init = input.train_input(
train_csv_path=train_csv_path,
train_clip_dir=train_clip_dir,
class_map_path=class_map_path,
hparams=hparams)
global_step, prediction, loss_tensor, train_op = model.define_model(
model_name=model_name,
features=features,
labels=labels,
num_classes=num_classes,
hparams=hparams,
training=True)
saver = tf.train.Saver(max_to_keep=30,
keep_checkpoint_every_n_hours=0.25)
saver_hook = tf.train.CheckpointSaverHook(save_steps=250,
checkpoint_dir='train',
saver=saver)
summary_op = tf.summary.merge_all()
summary_hook = tf.train.SummarySaverHook(save_steps=50,
output_dir='train',
summary_op=summary_op)
with tf.train.SingularMonitoredSession(
hooks=[saver_hook, summary_hook]) as sess:
sess.raw_session().run(input_init)
while not sess.should_stop():
step, _, loss = sess.run([global_step, train_op, loss_tensor])
print(step, loss)
sys.stdout.flush()
from utilits import load_data, preprocess_data
from model import define_model, train_and_validate
if __name__ == "__main__":
# 下载数据
# download()
# 加载数据
X_train, y_train, X_test, y_test, class_names = load_data('data')
# 数据预处理
# 模型使用规模为[N, 28, 28, 1]的批处理，输出规模为[N, 100]的概率
X_train, y_train, X_test, y_test = preprocess_data(X_train, y_train,
X_test, y_test,
class_names)
# 定义模型
model = define_model(X_train.shape[1:])
# 训练并测试模型
model = train_and_validate(X_train, y_train, X_test, y_test, model)
# 保存h5格式的模型
model.save('quick_draw.h5')
def main(_):
config = tf.ConfigProto(inter_op_parallelism_threads=num_inter_op_threads,
intra_op_parallelism_threads=num_intra_op_threads)
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata() # For Tensorflow trace
cluster = tf.train.ClusterSpec({"ps": ps_list, "worker": worker_list})
server = tf.train.Server(cluster, job_name=job_name, task_index=task_index)
is_sync = (FLAGS.is_sync == 1) # Synchronous or asynchronous updates
is_chief = (task_index == 0) # Am I the chief node (always task 0)
greedy = tf.contrib.training.GreedyLoadBalancingStrategy(
num_tasks=len(ps_hosts), load_fn=tf.contrib.training.byte_size_load_fn)
if job_name == "ps":
with tf.device(
tf.train.replica_device_setter(
worker_device="/job:ps/task:{}".format(task_index),
ps_tasks=len(ps_hosts),
ps_strategy=greedy,
cluster=cluster)):
sess = tf.Session(server.target, config=config)
queue = create_done_queue(task_index)
print("*" * 30)
print("\nParameter server #{} on {}.\n\n" \
"Waiting on workers to finish.\n\nPress CTRL-\\ to terminate early.\n" \
.format(task_index, ps_hosts[task_index]))
print("*" * 30)
# wait until all workers are done
for i in range(len(worker_hosts)):
sess.run(queue.dequeue())
print("Worker #{} reports job finished.".format(i))
print("Parameter server #{} is quitting".format(task_index))
print("Training complete.")
elif job_name == "worker":
if is_chief:
print("I am chief worker {} with task #{}".format(
worker_hosts[task_index], task_index))
else:
print("I am worker {} with task #{}".format(
worker_hosts[task_index], task_index))
if len(ps_list) > 0:
setDevice = tf.train.replica_device_setter(
worker_device="/job:worker/task:{}".format(task_index),
ps_tasks=len(ps_hosts),
ps_strategy=greedy,
cluster=cluster)
else:
setDevice = "/cpu:0" # No parameter server so put variables on chief worker
with tf.device(setDevice):
global_step = tf.Variable(0, name="global_step", trainable=False)
# Load the data
imgs_train, msks_train, imgs_test, msks_test = load_all_data()
train_length = imgs_train.shape[0] # Number of train datasets
test_length = imgs_test.shape[0] # Number of test datasets
"""
BEGIN: Define our model
"""
imgs = tf.placeholder(tf.float32,
shape=(None, msks_train.shape[1],
msks_train.shape[2],
msks_train.shape[3]))
msks = tf.placeholder(tf.float32,
shape=(None, msks_train.shape[1],
msks_train.shape[2],
msks_train.shape[3]))
preds = define_model(imgs, FLAGS.use_upsampling,
settings_dist.OUT_CHANNEL_NO)
print('Model defined')
loss_value = dice_coef_loss(msks, preds)
dice_value = dice_coef(msks, preds)
sensitivity_value = sensitivity(msks, preds)
specificity_value = specificity(msks, preds)
test_loss_value = tf.placeholder(tf.float32, ())
test_dice_value = tf.placeholder(tf.float32, ())
test_sensitivity_value = tf.placeholder(tf.float32, ())
test_specificity_value = tf.placeholder(tf.float32, ())
"""
END: Define our model
"""
# Decay learning rate from initial_learn_rate to initial_learn_rate*fraction in decay_steps global steps
if FLAGS.const_learningrate:
learning_rate = tf.convert_to_tensor(FLAGS.learning_rate,
dtype=tf.float32)
else:
learning_rate = tf.train.exponential_decay(FLAGS.learning_rate,
global_step,
FLAGS.decay_steps,
FLAGS.lr_fraction,
staircase=False)
# Compensate learning rate for asynchronous distributed
# THEORY: We need to cut the learning rate by at least the number
# of workers since there are likely to be that many times increased
# parameter updates.
# if not is_sync:
# learning_rate /= len(worker_hosts)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate)
# #optimizer = tf.train.AdagradOptimizer(learning_rate)
# else:
# optimizer = tf.train.AdamOptimizer(learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate)
grads_and_vars = optimizer.compute_gradients(loss_value)
if is_sync:
rep_op = tf.train.SyncReplicasOptimizer(
optimizer,
replicas_to_aggregate=len(worker_hosts),
total_num_replicas=len(worker_hosts),
use_locking=True)
train_op = rep_op.apply_gradients(grads_and_vars,
global_step=global_step)
init_token_op = rep_op.get_init_tokens_op()
chief_queue_runner = rep_op.get_chief_queue_runner()
else:
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
init_op = tf.global_variables_initializer()
saver = tf.train.Saver()
# These are the values we wish to print to TensorBoard
tf.summary.scalar("loss", loss_value)
tf.summary.histogram("loss", loss_value)
tf.summary.scalar("dice", dice_value)
tf.summary.histogram("dice", dice_value)
tf.summary.scalar("sensitivity", sensitivity_value)
tf.summary.histogram("sensitivity", sensitivity_value)
tf.summary.scalar("specificity", specificity_value)
tf.summary.histogram("specificity", specificity_value)
tf.summary.image("predictions",
preds,
max_outputs=settings_dist.TENSORBOARD_IMAGES)
tf.summary.image("ground_truth",
msks,
max_outputs=settings_dist.TENSORBOARD_IMAGES)
tf.summary.image("images",
imgs,
max_outputs=settings_dist.TENSORBOARD_IMAGES)
print("Loading epoch")
epoch = get_epoch(batch_size, imgs_train, msks_train)
num_batches = len(epoch)
print("Loaded")
# Print the percent steps complete to TensorBoard
# so that we know how much of the training remains.
num_steps_tf = tf.constant(num_batches * FLAGS.epochs, tf.float32)
percent_done_value = tf.constant(100.0) * tf.to_float(
global_step) / num_steps_tf
tf.summary.scalar("percent_complete", percent_done_value)
# Need to remove the checkpoint directory before each new run
# import shutil
# shutil.rmtree(CHECKPOINT_DIRECTORY, ignore_errors=True)
# Send a signal to the ps when done by simply updating a queue in the shared graph
enq_ops = []
for q in create_done_queues():
qop = q.enqueue(1)
enq_ops.append(qop)
# Only the chief does the summary
if is_chief:
summary_op = tf.summary.merge_all()
else:
summary_op = None
# Add summaries for test data
# These summary ops are not part of the merge all op.
# This way we can call these separately.
test_loss_value = tf.placeholder(tf.float32, ())
test_dice_value = tf.placeholder(tf.float32, ())
test_loss_summary = tf.summary.scalar("loss_test", test_loss_value)
test_dice_summary = tf.summary.scalar("dice_test", test_dice_value)
test_sens_summary = tf.summary.scalar("sensitivity_test",
test_sensitivity_value)
test_spec_summary = tf.summary.scalar("specificity_test",
test_specificity_value)
# TODO: Theoretically I can pass the summary_op into
# the Supervisor and have it handle the TensorBoard
# log entries. However, doing so seems to hang the code.
# For now, I just handle the summary calls explicitly.
# import time
# logDirName = CHECKPOINT_DIRECTORY + "/run" + \
# time.strftime("_%Y%m%d_%H%M%S")
if FLAGS.use_upsampling:
method_up = "upsample2D"
else:
method_up = "conv2DTranspose"
logDirName = CHECKPOINT_DIRECTORY + "/unet," + \
"lr={},{},intra={},inter={}".format(FLAGS.learning_rate,
method_up, num_intra_op_threads,
num_inter_op_threads)
sv = tf.train.Supervisor(
is_chief=is_chief,
logdir=logDirName,
init_op=init_op,
summary_op=None,
saver=saver,
global_step=global_step,
save_model_secs=60 # Save the model (with weights) everty 60 seconds
)
# TODO:
# I'd like to use managed_session for this as it is more abstract
# and probably less sensitive to changes from the TF team. However,
# I am finding that the chief worker hangs on exit if I use managed_session.
with sv.prepare_or_wait_for_session(server.target,
config=config) as sess:
#with sv.managed_session(server.target) as sess:
if sv.is_chief and is_sync:
sv.start_queue_runners(sess, [chief_queue_runner])
sess.run(init_token_op)
step = 0
progressbar = trange(num_batches * FLAGS.epochs)
last_step = 0
# Start TensorBoard on the chief worker
if sv.is_chief:
cmd = 'tensorboard --logdir={}'.format(CHECKPOINT_DIRECTORY)
tb_process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
shell=True,
preexec_fn=os.setsid)
while (not sv.should_stop()) and (step <
(num_batches * FLAGS.epochs)):
batch_idx = step % num_batches # Which batch is the epoch?
data = epoch[batch_idx, 0]
labels = epoch[batch_idx, 1]
# For n workers, break up the batch into n sections
# Send each worker a different section of the batch
data_range = int(batch_size / len(worker_hosts))
start = data_range * task_index
end = start + data_range
feed_dict = {imgs: data[start:end], msks: labels[start:end]}
history, loss_v, dice_v, step = sess.run(
[train_op, loss_value, dice_value, global_step],
feed_dict=feed_dict)
# Print summary only on chief
if sv.is_chief:
summary = sess.run(summary_op, feed_dict=feed_dict)
sv.summary_computed(sess, summary) # Update the summary
# Calculate metric on test dataset every epoch
if (batch_idx == 0) and (step > num_batches):
dice_v_test = 0.0
loss_v_test = 0.0
sens_v_test = 0.0
spec_v_test = 0.0
for idx in tqdm(
range(0, imgs_test.shape[0] - batch_size,
batch_size),
desc="Calculating metrics on test dataset",
leave=False):
x_test = imgs_test[idx:(idx + batch_size)]
y_test = msks_test[idx:(idx + batch_size)]
feed_dict = {imgs: x_test, msks: y_test}
l_v, d_v, st_v, sp_v = sess.run(
[
loss_value, dice_value, sensitivity_value,
specificity_value
],
feed_dict=feed_dict)
dice_v_test += d_v / (test_length // batch_size)
loss_v_test += l_v / (test_length // batch_size)
sens_v_test += st_v / (test_length // batch_size)
spec_v_test += sp_v / (test_length // batch_size)
print("\nEpoch {} of {}: TEST DATASET\nloss = {:.4f}\nDice = {:.4f}\n" \
"Sensitivity = {:.4f}\nSpecificity = {:.4f}" \
.format((step // num_batches), FLAGS.epochs,
loss_v_test, dice_v_test, sens_v_test, spec_v_test))
# Add our test summary metrics to TensorBoard
sv.summary_computed(
sess,
sess.run(test_loss_summary,
feed_dict={test_loss_value: loss_v_test}))
sv.summary_computed(
sess,
sess.run(test_dice_summary,
feed_dict={test_dice_value: dice_v_test}))
sv.summary_computed(
sess,
sess.run(test_sens_summary,
feed_dict={
test_sensitivity_value: sens_v_test
}))
sv.summary_computed(
sess,
sess.run(test_spec_summary,
feed_dict={
test_specificity_value: spec_v_test
}))
saver.save(
sess,
CHECKPOINT_DIRECTORY + "/last_good_model.cpkt")
# Shuffle every epoch
if (batch_idx == 0) and (step > num_batches):
print("Shuffling epoch")
epoch = get_epoch(batch_size, imgs_train, msks_train)
# Print the loss and dice metric in the progress bar.
progressbar.set_description(
"(loss={:.4f}, dice={:.4f})".format(loss_v, dice_v))
progressbar.update(step - last_step)
last_step = step
# Perform the final test set metric
if sv.is_chief:
dice_v_test = 0.0
loss_v_test = 0.0
for idx in tqdm(range(0, imgs_test.shape[0] - batch_size,
batch_size),
desc="Calculating metrics on test dataset",
leave=False):
x_test = imgs_test[idx:(idx + batch_size)]
y_test = msks_test[idx:(idx + batch_size)]
feed_dict = {imgs: x_test, msks: y_test}
l_v, d_v = sess.run([loss_value, dice_value],
feed_dict=feed_dict)
dice_v_test += d_v / (test_length // batch_size)
loss_v_test += l_v / (test_length // batch_size)
print("\nEpoch {} of {}: Test loss = {:.4f}, Test Dice = {:.4f}" \
.format((step // num_batches), FLAGS.epochs,
loss_v_test, dice_v_test))
sv.summary_computed(
sess,
sess.run(test_loss_summary,
feed_dict={test_loss_value: loss_v_test}))
sv.summary_computed(
sess,
sess.run(test_dice_summary,
feed_dict={test_dice_value: dice_v_test}))
saver.save(sess,
CHECKPOINT_DIRECTORY + "/last_good_model.cpkt")
if sv.is_chief:
export_model(
sess, imgs, preds
) # Save the final model as protbuf for TensorFlow Serving
os.killpg(os.getpgid(tb_process.pid),
signal.SIGTERM) # Stop TensorBoard process
# Send a signal to the ps when done by simply updating a queue in the shared graph
for op in enq_ops:
sess.run(
op
) # Send the "work completed" signal to the parameter server
print("\n\nFinished work on this node.")
import time
time.sleep(3) # Sleep for 3 seconds then exit
sv.request_stop()
def train_model():
learning_rate = 0.0001
batch_size = 128
c_dim = 1
n_batch = 10000 // batch_size
x_input = tf.placeholder(tf.float32, [None, None, None, c_dim],
name='x_input')
y_label2 = tf.placeholder(tf.float32, [None, None, None, c_dim],
name='y_label2')
x1_bic_add = tf.placeholder(tf.float32, [None, None, None, c_dim],
name='x1_bic_add')
output = define_model(x_input, x1_bic_add)
mse_loss = tf.reduce_mean(tf.square(y_label2 - output))
train = tf.train.GradientDescentOptimizer(learning_rate).minimize(mse_loss)
saver = tf.train.Saver(max_to_keep=4)
tf.add_to_collection("predict", output)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
# load train set
x1d = load_h5('Y_dataset.h5', 'train_cut_l')
x2d = load_h5('Y_dataset.h5', 'train_cut_h')
x1_b = load_h5('Y_dataset.h5', 'train_cut_b')
x1_data = x1d[:10000, :, :, :] / 255
x2_data = x2d[:10000, :, :, :] / 255
x1_bic = x1_b[:10000, :, :, :] / 255
print(x1_data.shape, x2_data.shape, x1_bic.shape)
counter = 0
for i in range(2001):
for idx in range(0, n_batch):
batch_images = x1_data[idx * batch_size:(idx + 1) * batch_size]
batch_bic = x1_bic[idx * batch_size:(idx + 1) * batch_size]
batch_labels = x2_data[idx * batch_size:(idx + 1) * batch_size]
sess.run(train,
feed_dict={
x_input: batch_images,
y_label2: batch_labels,
x1_bic_add: batch_bic
})
counter += 1
if counter % 50 == 0:
print(
'Epoh', i, 'n_batch', idx, 'Train loss:',
sess.run(mse_loss,
feed_dict={
x_input: batch_images,
y_label2: batch_labels,
x1_bic_add: batch_bic
}))
rands(x1_data, x2_data, x1_bic)
if i % 10 == 0:
saver.save(sess,
r'./checkpoint/' + "model_conv/my-model",
global_step=i)
print("save the model")
def evaluate(model_name=None, hparams=None, eval_csv_path=None, eval_clip_dir=None,
class_map_path=None, checkpoint_path=None):
"""Runs the evaluation loop."""
print('\nEvaluation for model:{} with hparams:{} and class map:{}'.format(model_name, hparams, class_map_path))
print('Evaluation data: clip dir {} and labels {}'.format(eval_clip_dir, eval_csv_path))
print('Checkpoint: {}\n'.format(checkpoint_path))
with tf.Graph().as_default():
label_class_index_table, num_classes = inputs.get_class_map(class_map_path)
csv_record = tf.placeholder(tf.string, []) # fed during evaluation loop.
# Use a simpler in-order input pipeline for eval than the one used in
# training, since we don't want to shuffle examples across clips.
# The features consist of a batch of all possible framed log mel spectrum
# examples from the same clip. The labels in this case will contain a batch
# of identical 1-hot vectors.
features, labels = inputs.record_to_labeled_log_mel_examples(
csv_record, clip_dir=eval_clip_dir, hparams=hparams,
label_class_index_table=label_class_index_table, num_classes=num_classes)
# Create the model in prediction mode.
global_step, prediction, _, _ = model.define_model(
model_name=model_name, features=features, num_classes=num_classes,
hparams=hparams, training=False)
with tf.train.SingularMonitoredSession(checkpoint_filename_with_path=checkpoint_path) as sess:
# Read in class map CSV into a class index -> class name map.
class_map = {int(row[0]): row[1] for row in csv.reader(open(class_map_path))}
# Keep running counters to aid printing incremental AP stats.
ap_counts = defaultdict(int) # maps class index to the number of clips with that label.
ap_sums = defaultdict(float) # maps class index to the sum of AP for all clips with that label.
# Read in the validation CSV, skippign the header.
eval_records = open(eval_csv_path).readlines()[1:]
# Shuffle the lines so that as we print incremental stats, we get good
# coverage across classes and get a quick initial impression of how well
# the model is doing even before evaluation is completely done.
random.shuffle(eval_records)
for (i,record) in enumerate(eval_records):
record = record.strip()
actual, predicted = sess.run([labels, prediction], {csv_record: record})
# By construction, actual consists of identical rows, where each row is
# the same 1-hot label (because we are looking at features from the same
# clip). np.argmax() of any of the rows (and in particular [0]) will
# give us the class index corresponding to the label.
actual_class = np.argmax(actual[0])
predicted_classes = get_top_predicted_classes(predicted)
# Compute AP for this item, update running counters/sums, and print the
# prediction vs actual.
ap = avg_precision(actual=actual_class, predicted=predicted_classes)
ap_counts[actual_class] += 1
ap_sums[actual_class] += ap
print(class_map[actual_class], [class_map[index] for index in predicted_classes], ap)
# Periodically print per-class and overall AP stats.
if i % 50 == 0:
print_maps(ap_sums=ap_sums, ap_counts=ap_counts, class_map=class_map)
sys.stdout.flush()
# Final AP stats.
print_maps(ap_sums=ap_sums, ap_counts=ap_counts, class_map=class_map)
def train(model_name=None,
hparams=None,
class_map_path=None,
train_csv_path=None,
train_clip_dir=None,
train_dir=None,
epoch_batches=None,
warmstart_checkpoint=None,
warmstart_include_scopes=None,
warmstart_exclude_scopes=None):
"""Runs the training loop."""
print('\nTraining model:{} with hparams:{} and class map:{}'.format(
model_name, hparams, class_map_path))
print('Training data: clip dir {} and labels {}'.format(
train_clip_dir, train_csv_path))
print('Training dir {}\n'.format(train_dir))
with tf.Graph().as_default():
# Create the input pipeline.
features, labels, num_classes, input_init = inputs.train_input(
train_csv_path=train_csv_path,
train_clip_dir=train_clip_dir,
class_map_path=class_map_path,
hparams=hparams)
# Create the model in training mode.
global_step, prediction, loss_tensor, train_op = model.define_model(
model_name=model_name,
features=features,
labels=labels,
num_classes=num_classes,
hparams=hparams,
epoch_batches=epoch_batches,
training=True)
# Define our own checkpoint saving hook, instead of using the built-in one,
# so that we can specify additional checkpoint retention settings.
saver = tf.train.Saver(max_to_keep=10000,
keep_checkpoint_every_n_hours=0.25)
saver_hook = tf.train.CheckpointSaverHook(save_steps=100,
checkpoint_dir=train_dir,
saver=saver)
summary_op = tf.summary.merge_all()
summary_hook = tf.train.SummarySaverHook(save_steps=10,
output_dir=train_dir,
summary_op=summary_op)
if hparams.warmstart:
var_include_scopes = warmstart_include_scopes
if not var_include_scopes: var_include_scopes = None
var_exclude_scopes = warmstart_exclude_scopes
if not var_exclude_scopes: var_exclude_scopes = None
restore_vars = tf.contrib.framework.get_variables_to_restore(
include=var_include_scopes, exclude=var_exclude_scopes)
# Only restore trainable variables, we don't want to restore
# batch-norm or optimizer-specific local variables.
trainable_vars = set(
tf.contrib.framework.get_trainable_variables())
restore_vars = [
var for var in restore_vars if var in trainable_vars
]
print('Warm-start: restoring variables:\n%s\n' %
'\n'.join([x.name for x in restore_vars]))
print('Warm-start: restoring from ', warmstart_checkpoint)
assert restore_vars, 'No warm-start variables to restore!'
restore_op, feed_dict = tf.contrib.framework.assign_from_checkpoint(
model_path=warmstart_checkpoint,
var_list=restore_vars,
ignore_missing_vars=True)
scaffold = tf.train.Scaffold(init_fn=lambda scaffold, session:
session.run(restore_op, feed_dict),
summary_op=summary_op,
saver=saver)
else:
scaffold = None
with tf.train.SingularMonitoredSession(
hooks=[saver_hook, summary_hook],
checkpoint_dir=train_dir,
scaffold=scaffold) as sess:
sess.raw_session().run(input_init)
while not sess.should_stop():
step, _, pred, loss = sess.run(
[global_step, train_op, prediction, loss_tensor])
print(step, loss)
sys.stdout.flush()
def train_and_evaluate(model_name=None, hparams=None, class_map_path=None, train_csv_path=None, train_clip_dir=None,
train_dir=None, epoch_batches=None, warmstart_checkpoint=None,
warmstart_include_scopes=None, warmstart_exclude_scopes=None,
eval_csv_path=None, eval_clip_dir=None, eval_dir=None):
"""Runs the training loop."""
print('\nTraining model:{} with hparams:{} and class map:{}'.format(model_name, hparams, class_map_path))
print('Training data: clip dir {} and labels {}'.format(train_clip_dir, train_csv_path))
print('Training dir {}\n'.format(train_dir))
class_map = {int(row[0]): row[1] for row in csv.reader(open(class_map_path))}
with tf.Graph().as_default():
# Create the input pipeline.
features, labels, num_classes, input_init = inputs.train_input(
train_csv_path=train_csv_path, train_clip_dir=train_clip_dir, class_map_path=class_map_path,
hparams=hparams)
# Create the model in training mode.
global_step, prediction, loss_tensor, train_op = model.define_model(
model_name=model_name, features=features, labels=labels, num_classes=num_classes,
hparams=hparams, epoch_batches=epoch_batches, training=True)
# evaluation graph
label_class_index_table, num_classes = inputs.get_class_map(class_map_path)
csv_record = tf.placeholder(tf.string, []) # fed during evaluation loop.
eval_features, eval_labels = inputs.record_to_labeled_log_mel_examples(
csv_record, clip_dir=eval_clip_dir, hparams=hparams,
label_class_index_table=label_class_index_table, num_classes=num_classes)
# Create the model in prediction mode.
global_step, eval_predictions, eval_loss_tensor, _ = model.define_model(
model_name=model_name, features=eval_features, labels=eval_labels, num_classes=num_classes,
hparams=hparams, training=False, evaluating=True)
# Write evaluation graph to checkpoint directory.
tf.train.write_graph(tf.get_default_graph().as_graph_def(add_shapes=True),
eval_dir, 'eval.pbtxt')
eval_writer = tf.summary.FileWriter(eval_dir, tf.get_default_graph())
# Define our own checkpoint saving hook, instead of using the built-in one,
# so that we can specify additional checkpoint retention settings.
saver = tf.train.Saver(
max_to_keep=10, keep_checkpoint_every_n_hours=0.25)
saver_hook = tf.train.CheckpointSaverHook(
save_steps=100, checkpoint_dir=train_dir, saver=saver)
summary_op = tf.summary.merge_all()
summary_hook = tf.train.SummarySaverHook(
save_steps=10, output_dir=train_dir, summary_op=summary_op)
if hparams.warmstart:
var_include_scopes = warmstart_include_scopes
if not var_include_scopes: var_include_scopes = None
var_exclude_scopes = warmstart_exclude_scopes
if not var_exclude_scopes: var_exclude_scopes = None
restore_vars = tf.contrib.framework.get_variables_to_restore(
include=var_include_scopes, exclude=var_exclude_scopes)
# Only restore trainable variables, we don't want to restore
# batch-norm or optimizer-specific local variables.
trainable_vars = set(tf.contrib.framework.get_trainable_variables())
restore_vars = [var for var in restore_vars if var in trainable_vars]
print('Warm-start: restoring variables:\n%s\n' % '\n'.join([x.name for x in restore_vars]))
print('Warm-start: restoring from ', warmstart_checkpoint)
assert restore_vars, 'No warm-start variables to restore!'
restore_op, feed_dict = tf.contrib.framework.assign_from_checkpoint(
model_path=warmstart_checkpoint, var_list=restore_vars, ignore_missing_vars=True)
scaffold = tf.train.Scaffold(
init_fn=lambda scaffold, session: session.run(restore_op, feed_dict),
summary_op=summary_op, saver=saver)
else:
scaffold = None
with tf.train.SingularMonitoredSession(hooks=[saver_hook, summary_hook],
checkpoint_dir=train_dir,
scaffold=scaffold,
config=tf.ConfigProto(log_device_placement=True)) as sess:
sess.raw_session().run(input_init)
while not sess.should_stop():
# train
step, _, pred, loss = sess.run([global_step, train_op, prediction, loss_tensor])
print(step, loss)
sys.stdout.flush()
# evaluates every 100 steps
if step > 0 and step % 100 == 0:
# Loop through all checkpoints in the training directory.
checkpoint_state = tf.train.get_checkpoint_state(train_dir)
lwlrap = eval_batch(eval_csv_path, sess, eval_labels, eval_predictions, csv_record, step, eval_writer, class_map, eval_loss_tensor)
from parameters import medical_centers, medics, modules, days, notification_rates, time_between, medical_centers_boxes, fine_cost, action_plan_cost
from model import define_model
from get_output import get_model_output
params = {
'medical_centers': medical_centers,
'medics': medics,
'modules': modules,
'days': days,
'notification_rates': notification_rates,
'time_between': time_between,
'medical_centers_boxes': medical_centers_boxes,
'fine_cost': fine_cost,
'action_plan_cost': action_plan_cost
}
model = define_model(**params)
model.optimize()
get_model_output(model)
def predict(model_name=None,
hparams=None,
test_clip_dir=None,
class_map_path=None,
checkpoint_path=None,
predictions_csv_path=None):
"""Runs the prediction loop, producting prediction output in Kaggle submission format."""
print('\nPrediction for model:{} with hparams:{} and class map:{}'.format(
model_name, hparams, class_map_path))
print('Prediction data: clip dir {} and checkpoint {}'.format(
test_clip_dir, checkpoint_path))
print('Predictions in CSV {}\n'.format(predictions_csv_path))
with tf.Graph().as_default():
_, num_classes = inputs.get_class_map(class_map_path)
clip = tf.placeholder(tf.string, []) # Fed during prediction loop.
# Use a simpler in-order input pipeline without labels for prediction
# compared to the one used in training. The features consist of a batch of
# all possible framed log mel spectrum examples from the same clip.
features = inputs.clip_to_log_mel_examples(clip,
clip_dir=test_clip_dir,
hparams=hparams)
# Creates the model in prediction mode.
_, prediction, _, _ = model.define_model(model_name=model_name,
features=features,
num_classes=num_classes,
hparams=hparams,
training=False)
with tf.train.SingularMonitoredSession(
checkpoint_filename_with_path=checkpoint_path) as sess:
# Read in class map CSV into a class index -> class name map.
class_map = {
int(row[0]): row[1]
for row in csv.reader(open(class_map_path))
}
test_clips = sorted(os.listdir(test_clip_dir))
pred_writer = csv.DictWriter(open(predictions_csv_path, 'w'),
fieldnames=['fname', 'label'])
pred_writer.writeheader()
for (i, test_clip) in enumerate(test_clips):
print(i, test_clip)
sys.stdout.flush()
# Hack to avoid passing empty files through the model.
if os.path.getsize(os.path.join(test_clip_dir,
test_clip)) == 44:
print('empty file, skipped model')
label = ''
else:
predicted = sess.run(prediction, {clip: test_clip})
predicted_classes = evaluation.get_top_predicted_classes(
predicted)
label = ' '.join([class_map[c] for c in predicted_classes])
pred_writer.writerow({'fname': test_clip, 'label': label})
print(label)
sys.stdout.flush()
def evaluate(model_name=None,
hparams=None,
eval_csv_path=None,
eval_clip_dir=None,
class_map_path=None,
checkpoint_path=None):
"""Runs the evaluation loop."""
print('\nEvaluation for model:{} with hparams:{} and class map:{}'.format(
model_name, hparams, class_map_path))
print('Evaluation data: clip dir {} and labels {}'.format(
eval_clip_dir, eval_csv_path))
print('Checkpoint: {}\n'.format(checkpoint_path))
with tf.Graph().as_default():
label_class_index_table, num_classes = inputs.get_class_map(
class_map_path)
csv_record = tf.placeholder(tf.string,
[]) # fed during evaluation loop.
# Use a simpler in-order input pipeline for eval than the one used in
# training, since we don't want to shuffle examples across clips.
# The features consist of a batch of all possible framed log mel spectrum
# examples from the same clip. The labels in this case will contain a batch
# of identical 1-hot vectors.
features, labels = inputs.record_to_labeled_log_mel_examples(
csv_record,
clip_dir=eval_clip_dir,
hparams=hparams,
label_class_index_table=label_class_index_table,
num_classes=num_classes)
# Create the model in prediction mode.
global_step, prediction, _, _ = model.define_model(
model_name=model_name,
features=features,
num_classes=num_classes,
hparams=hparams,
training=False)
with tf.train.SingularMonitoredSession(
checkpoint_filename_with_path=checkpoint_path) as sess:
# Read in class map CSV into a class index -> class name map.
class_map = {
int(row[0]): row[1]
for row in csv.reader(open(class_map_path))
}
# Keep running counters to aid printing incremental AP stats.
ap_counts = defaultdict(
int
) # maps class index to the number of clips with that label.
ap_sums = defaultdict(
float
) # maps class index to the sum of AP for all clips with that label.
# Read in the validation CSV, skippign the header.
eval_records = open(eval_csv_path).readlines()[1:]
# Shuffle the lines so that as we print incremental stats, we get good
# coverage across classes and get a quick initial impression of how well
# the model is doing even before evaluation is completely done.
random.shuffle(eval_records)
for (i, record) in enumerate(eval_records):
record = record.strip()
actual, predicted = sess.run([labels, prediction],
{csv_record: record})
# By construction, actual consists of identical rows, where each row is
# the same 1-hot label (because we are looking at features from the same
# clip). np.argmax() of any of the rows (and in particular [0]) will
# give us the class index corresponding to the label.
actual_class = np.argmax(actual[0])
predicted_classes = get_top_predicted_classes(predicted)
# Compute AP for this item, update running counters/sums, and print the
# prediction vs actual.
ap = avg_precision(actual=actual_class,
predicted=predicted_classes)
ap_counts[actual_class] += 1
ap_sums[actual_class] += ap
print(class_map[actual_class],
[class_map[index] for index in predicted_classes], ap)
# Periodically print per-class and overall AP stats.
if i % 50 == 0:
print_maps(ap_sums=ap_sums,
ap_counts=ap_counts,
class_map=class_map)
sys.stdout.flush()
# Final AP stats.
print_maps(ap_sums=ap_sums,
ap_counts=ap_counts,
class_map=class_map)
def main():
faces, label = input_faces()
n_class = len(list(set(label)))
N_faces = len(faces)
print(n_class), N_faces
with tf.Graph().as_default():
# 入力画像のプレースホルダー
images = tf.placeholder(tf.float32,
[BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 1])
# ラベル 0: 1:
labels = tf.placeholder(tf.int64, shape=(BATCH_SIZE, ))
# モデルの定義
model = define_model(images=images)
# 誤差関数
loss = define_loss(model, labels=labels)
# 誤差を保存、TensorBoardで可視化できる。
tf.scalar_summary("loss", loss)
# 学習の演算を定義する。
train_op = training(loss, learning_rate=0.01)
# 評価方法を定義、正解数を計算する。
evaluation_op = evaluation(model, labels)
# TensorBoardへの記載
tf.image_summary('images', images, max_images=100)
summary = tf.merge_all_summaries()
saver = tf.train.Saver()
# 変数初期化を行う。
with tf.Session() as session:
# 全ての変数を初期化する。
tf.initialize_all_variables().run()
# 計算グラフを定義
summary_writer = tf.train.SummaryWriter("./log", session.graph)
count = 0
# 学習を行う。 何周学習を行うか
for epoch in range(EPOCHS):
perm = np.random.permutation(N_faces)
loss_value = 0.0
# バッチ学習を行う。
for index, step in enumerate(
range(0, N_faces - BATCH_SIZE, BATCH_SIZE)):
start_time = time.time()
batch_start = step
batch_end = step + BATCH_SIZE
feed_dict = {
images: faces[perm[batch_start:batch_end]],
labels: label[perm[batch_start:batch_end]]
}
# ①演算を行う。
_, loss_value, eval_value = session.run(
[train_op, loss, evaluation_op], feed_dict=feed_dict)
duration = time.time() - start_time
count += 1
print('Step %d: loss = %.2f (%.3f sec)' %
(index + epoch * N_faces // BATCH_SIZE, loss_value,
duration))
summary_str = session.run(summary, feed_dict=feed_dict)
summary_writer.add_summary(
summary_str, index + epoch * N_faces // BATCH_SIZE)
summary_writer.flush()
# 学習が一周完了した段階で出力する。
print(epoch, loss_value)
# ②学習結果を保存する。
saver.save(session, "model.ckpt")
encoder = LabelEncoder()
onehot = OneHotEncoder(handle_unknown='ignore')
# Fit Transform X and y
X = cv.fit_transform(X).toarray()
print('Shape of the features X : ', X.shape)
y = encoder.fit_transform(y)
y = onehot.fit_transform(y.reshape(-1, 1)).toarray()
print('Shape of the Label y : ', y.shape)
# Train Test Split (0.8, 0.2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)
n_words = X_train.shape[1]
# Create Model
model = define_model(n_words)
# Train the model.
model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
epochs=100,
verbose=2)
# Predict Outcome
pred = model.predict(X_test)
print(pred.shape)
print(type(pred))
y_pred = []
for i in range(pred.shape[0]):
from tensorflow.keras.callbacks import LearningRateScheduler
from model import define_model
import h5py
from sklearn.metrics import log_loss, f1_score
df_model=define_model()
df_model.load_weights('./MesoInception_DF')
f2f_model=define_model()
f2f_model.load_weights('./MesoInception_F2F')
file = h5py.File('train2.h5','r')
X,y,Val_X, Val_y = file['train_imgs'], file['train_gts'],file['test_imgs'],file['test_gts']
y = y[:len(X)]
Val_y = Val_y[:len(Val_X)]
print(X.shape,y.shape,Val_X.shape,Val_y.shape)
lrs=[1e-3,5e-4,1e-4]
def schedule(epoch):
return lrs[epoch]
LOAD_PRETRAIN=True
import gc
kfolds=5
losses=[]
if LOAD_PRETRAIN:
import keras.backend as K
df_models=[]
f2f_models=[]
i=0
while len(df_models)<kfolds:
model=define_model((150,150,3))
img_width=img_width)
validation_images, validation_labels = decode_data(
val_test_batch,
validation_filenames,
'validation',
img_height=img_height,
img_width=img_width)
images_placeholder = tf.placeholder(
tf.float32, shape=[None, img_height, img_width])
labels_placeholder = tf.placeholder(tf.int32, shape=None)
dropout_placeholder = tf.placeholder(tf.bool, shape=())
# ops
train_op, loss, accuracy, softmax_logits, merged = define_model(
images_placeholder, labels_placeholder, dropout_placeholder, eta,
num_classes)
# visualization and saving
saver = tf.train.Saver()
train_writer = tf.summary.FileWriter(
'summaries/' + model_name + '/train', sess.graph)
val_writer = tf.summary.FileWriter('summaries/' + model_name +
'/validation')
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
if os.path.isdir('models/' + model_name):
saver.restore(sess, 'models/' + model_name + '/model.ckpt')
help='optional arguement, needed if training with global features\
Of the format [x,y,z] corresponding to voxel dimenstions',required=False)
parser.add_argument('--train_directory', type=str,
help='Directory with pointclouds for training')
parser.add_argument('--test_directory', type=str,
help='Directory with pointclouds for testing')
args = parser.parse_args()
if args.train_with_global_features:
voxel_size = args.voxel_size.split(",")
voxel_size = [int(x) for x in voxel_size]
input_size = (voxel_size[0] * voxel_size[1] * voxel_size[2])+33
model = define_model("global",input_size)
X_train,y_train=feature_extraction_with_voxel_occupancy(args.train_directory,voxel_size,1000)
X_test,y_test=feature_extraction_with_voxel_occupancy(args.test_directory,voxel_size,1000)
if args.train_with_local_features:
model=define_model("local",input_size=33)
X_train,y_train=feature_extraction(args.train_directory)
X_test,y_test=feature_extraction(args.test_directory)
model.compile(optimizer='adam', loss='binary_crossentropy',metrics=['accuracy'])
epoch_to_use) #Added here
#trained_model = os.path.join('./trained_model',opt.model,'epoch_24.pth')
data_dir = opt.data_dir
#epoch_to_use = 'epoch_'+str(opt.epoch)+'.pth'
#trained_model = '/home/ghumphries/Projects/whale/trained_model/MODEL_NO_W1/'+epoch_to_use
#data_dir = '/home/ghumphries/Projects/whale/Data/fulldata/test/single_whale'
test_transforms = s.data_transforms['test']
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
torch.set_default_tensor_type('torch.cuda.FloatTensor')
#model_ft = torchvision.models.resnet18(pretrained=True)
model_ft = define_model(name=opt.modtype)
## Scrubbed these because they're in model.py now
#num_ftrs = model_ft.fc.in_features
#model_ft.fc = nn.Linear(num_ftrs, 2)
model_ft = model_ft.to(device)
model_ft.load_state_dict(torch.load(trained_model))
model_ft.eval()
#image_dataset = datasets.ImageFolder(data_dir, s.data_transforms['test'])
image_datasets = ImageFolderWithPaths(data_dir, s.data_transforms['test'])
#image_datasets = datasets.ImageFolder(data_dir, s.data_transforms['test'])
dataloaders = torch.utils.data.DataLoader(image_datasets,
batch_size=10,
import random
from collections import deque
import matplotlib
# Force matplotlib to not use any Xwindows backend.
matplotlib.use('Agg')
state_size = [None, 80, 80, 4]
single_image_shape = [1, 80, 80, 4]
disc_rate = 0.99
sess = tf.Session()
with tf.name_scope("active_model"):
inp = tf.placeholder(dtype=tf.float32, shape=state_size)
model = define_model(inp)
action_choice = tf.reshape(tf.multinomial(model.output, num_samples=1),
shape=[1])
greedy_action = tf.argmax(model.output)
with tf.name_scope("frozen_model"):
inp_frozen = tf.placeholder(dtype=tf.float32, shape=state_size)
frozen_model = define_model(inp_frozen)
frozen_model.trainable = False
def loss(a, r):
with tf.name_scope("loss"):
rng = tf.reshape(tf.range(tf.shape(a)[0]), shape=[-1])
indices = tf.stack([rng, a], axis=1)
def predict(model_name=None, hparams=None, test_clip_dir=None,
class_map_path=None, checkpoint_path=None, predictions_csv_path=None):
soundfile = "The Fast and the Furious.wav"
samplingFrequency, signalData = wavfile.read(soundfile)
start = 0
end = 1
count = 0
while True:
tmp = signalData[start*samplingFrequency : end*samplingFrequency]
file_name = "divide_audio/"+str(count).zfill(8) + ".wav"
write(file_name,44100,tmp)
count += 1
start += 1
end += 1
if (end * samplingFrequency) > signalData.size:
start = 0
end = 1
break
with tf.Graph().as_default():
_, num_classes = inputs.get_class_map(class_map_path)
clip = tf.placeholder(tf.string, []) # Fed during prediction loop.
# Use a simpler in-order input pipeline without labels for prediction
# compared to the one used in training. The features consist of a batch of
# all possible framed log mel spectrum examples from the same clip.
features = inputs.clip_to_log_mel_examples(
clip, clip_dir=test_clip_dir, hparams=hparams)
# Creates the model in prediction mode.
_, prediction, _, _ = model.define_model(
model_name=model_name, features=features, num_classes=num_classes,
hparams=hparams, training=False)
f = open("Total.txt",'w')
with tf.train.SingularMonitoredSession(checkpoint_filename_with_path=checkpoint_path) as sess:
class_map = {int(row[0]): row[1] for row in csv.reader(open(class_map_path))}
test_clips = sorted(os.listdir(test_clip_dir))
for (i, test_clip) in enumerate(test_clips):
print(i, test_clip)
sys.stdout.flush()
# Hack to avoid passing empty files through the model.
if os.path.getsize(os.path.join(test_clip_dir, test_clip)) == 44:
print('empty file, skipped model')
label = ''
else:
predicted = sess.run(prediction, {clip: test_clip})
predicted_classes = evaluation.get_top_predicted_classes(predicted)
label = ' '.join([class_map[c] for c in predicted_classes])
f.write('audio/residential_area/a001.wav\t' + str(start) +"\t" + str(end) + "\t" + label + "\n")
start += 1
end += 1
sys.stdout.flush()
f.close()
filename3 = 'C:/Users/admin/Downloads/imageCpation/features.pkl'
test_features = loadData.load_photo_features(filename3, test)
print("Photos: train = %d" % len(test_features))
#prepare tokenizer
#tokenizer = loadData.create_tokenizer(test_descriptions)
#vocab_size = len(tokenizer.word_index) + 1
#print("Vocabulary size : %d" %vocab_size)
#prepare the sequences
X1test, X2test, ytest = loadData.create_sequences(tokenizer, max_length,
test_descriptions,
test_features, vocab_size)
#define the model
model = model.define_model(vocab_size, max_length)
#define checkpoint callback
filepath = 'model-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5'
checkpoint = ModelCheckpoint(filepath,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
#fit the model
model.fit([X1train, X2train],
ytrain,
epochs=20,
verbose=2,
callbacks=[checkpoint],
from utils import BS,BASE_DIR
from generator import csv_image_generator
from keras.models import load_model
from keras.metrics import categorical_accuracy
from sklearn.metrics import accuracy_score
from utils import BASE_DIR, encoding
import numpy as np
import cv2
import os
from utils import SAMPLE_DIR
import pickle
from model import define_model
model = define_model()
model.load_weights('model_1.h5')
with open('X_test_1.pkl', 'rb') as f:
X_test = pickle.load(f)
f.close()
with open('y_test_1.pkl', 'rb') as f:
y_test = pickle.load(f)
f.close()
y_pred = model.predict(X_test)
y_pred = (y_pred > 0.5)
idx = np.argmax(y_pred, axis=-1)
y_pred = np.zeros(y_pred.shape)
y_pred[np.arange(y_pred.shape[0]), idx] = 1
# acc = categorical_accuracy(y_test, y_pred)
y = []
for i in range(0, len(y_test)):
lab = [0, 0, 0, 0, 0, 0, 0, 0]
lab[encoding[y_test[i]] - 1] = 1
from utils import extract_spectrogram_windows
from scipy.stats import mode
dictionary = sorted(os.listdir('downloaded_data'))
model_name = 'model1'
num_classes = len(dictionary)
img_width = 512
img_height = 128
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
images_placeholder = tf.placeholder(tf.float32, shape=[None, img_height, img_width])
labels_placeholder = tf.placeholder(tf.int32, shape=None)
dropout_placeholder = tf.placeholder(tf.bool, shape=())
_, _, _, softmax_logits, _ = define_model(images_placeholder, labels_placeholder, dropout_placeholder, eta=0.001, num_classes=num_classes)
classes = tf.argmax(softmax_logits, axis=1)
saver = tf.train.Saver()
if os.path.isdir('models/' + model_name):
saver.restore(sess, 'models/' + model_name + '/model.ckpt')
print('Model read')
else:
raise Exception("Model not found! Check if model_name is correct!")
while True:
filename = input("Type filename (or 'q' to quit): ")
path = os.path.join('sample_audio', filename)
if filename == 'q':
break
elif os.path.isfile(path):
def evaluate(model_name=None,
hparams=None,
class_map_path=None,
eval_csv_path=None,
eval_clip_dir=None,
eval_dir=None,
train_dir=None):
"""Runs the evaluation loop."""
print('\nEvaluation for model:{} with hparams:{} and class map:{}'.format(
model_name, hparams, class_map_path))
print('Evaluation data: clip dir {} and labels {}'.format(
eval_clip_dir, eval_csv_path))
# Read in class map CSV into a class index -> class name map.
class_map = {
int(row[0]): row[1]
for row in csv.reader(open(class_map_path))
}
with tf.Graph().as_default():
label_class_index_table, num_classes = inputs.get_class_map(
class_map_path)
csv_record = tf.placeholder(tf.string,
[]) # fed during evaluation loop.
# Use a simpler in-order input pipeline for eval than the one used in
# training, since we don't want to shuffle examples across clips.
# The features consist of a batch of all possible framed log mel spectrum
# examples from the same clip. The labels in this case will contain a batch
# of identical 1-hot vectors.
features, labels = inputs.record_to_labeled_log_mel_examples(
csv_record,
clip_dir=eval_clip_dir,
hparams=hparams,
label_class_index_table=label_class_index_table,
num_classes=num_classes)
# Create the model in prediction mode.
global_step, prediction, _, _ = model.define_model(
model_name=model_name,
features=features,
num_classes=num_classes,
hparams=hparams,
training=False)
# Write evaluation graph to checkpoint directory.
tf.train.write_graph(
tf.get_default_graph().as_graph_def(add_shapes=True), eval_dir,
'eval.pbtxt')
summary_writer = tf.summary.FileWriter(eval_dir,
tf.get_default_graph())
# Loop through all checkpoints in the training directory.
checkpoint_state = tf.train.get_checkpoint_state(train_dir)
for checkpoint_path in checkpoint_state.all_model_checkpoint_paths:
checkpoint_num = get_checkpoint_num(checkpoint_path)
if eval_done(eval_dir, checkpoint_num):
print("Checkpoint %d already evaluated, skipping" %
checkpoint_num)
continue
lwlrap = eval_checkpoint(checkpoint_path, eval_dir, summary_writer,
eval_csv_path, class_map, csv_record,
global_step, labels, prediction)
write_eval_marker(eval_dir, checkpoint_num, lwlrap)
sess = tf.Session(config=config)
tf.keras.backend.set_session(sess)
global_step = tf.Variable(0, name="global_step", trainable=False)
# Define the shape of the input images
# For segmentation models, the label (mask) is the same shape.
shape = (None, args.dim_length, args.dim_length, args.dim_length,
args.num_channels)
img = tf.placeholder(tf.float32, shape=shape) # Input tensor
msk = tf.placeholder(tf.float32, shape=shape) # Label tensor
# Define the model
# Predict the output mask
preds = define_model(img,
learning_rate=args.lr,
use_upsampling=args.use_upsampling,
print_summary=args.print_model)
# Performance metrics for model
loss = dice_coef_loss(msk,
preds) # Loss is the dice between mask and prediction
dice_score = dice_coef(msk, preds)
sensitivity_score = sensitivity(msk, preds)
specificity_score = specificity(msk, preds)
train_op = tf.train.AdamOptimizer(args.lr).minimize(loss,
global_step=global_step)
# Just feed completely random data in for the benchmark testing
imgs = np.random.rand(args.bz, args.dim_length, args.dim_length,
args.dim_length, args.num_channels)
else:
np.append(X, [image], axis=0)
y.append(sam)
combined = list(zip(X, y))
random.shuffle(combined)
X[:], y[:] = zip(*combined)
# skf = StratifiedKFold(n_splits=10, shuffle=True)
# skf.get_n_splits(X, y)
X_test = np.array(X)
y_test = np.array(y)
accs = []
model = None
model = define_model() # 8分类网络、新型网络、深度分离网络
model.summary()
with open("X_train" + ".pkl", 'wb') as f:
pickle.dump(X_train, f, protocol=4)
f.close()
with open("X_test" + ".pkl", 'wb') as f:
pickle.dump(X_test, f, protocol=4)
f.close()
with open("y_train" + ".pkl", 'wb') as f:
pickle.dump(y_train, f, protocol=4)
f.close()
with open("y_test" + ".pkl", 'wb') as f:
pickle.dump(y_test, f, protocol=4)
f.close()
import cv2
BATCH_SIZE = 1
NUM_CHANNELS = 1
IMAGE_SIZE = 28
cap = cv2.VideoCapture(0)
cascade_path = "INPUT YOUR FACE MODEL PATH"
cascade = cv2.CascadeClassifier(cascade_path)
with tf.Graph().as_default():
# 入力画像のプレースホルダ
images = tf.placeholder(tf.float32,
[BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 1])
# モデル定義
model = define_model(images=images)
# 出力定義
softmax_op = tf.nn.softmax(model)
# セーバーの初期化
saver = tf.train.Saver()
# 変数初期化を行う。
with tf.Session() as session:
# モデルの読み出し
saver.restore(session, "./model.ckpt")
# ユーザが割り込むまで、実行し続ける。
while True:
response, frame = cap.read()
image_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
scale_height = 512.0 / image_gray.shape[1]
scale_width = 512.0 / image_gray.shape[0]
def main(_):
start_time = datetime.now()
tf.logging.info("Data path: {}".format(FLAGS.data_path))
tf.logging.info("Output path: {}".format(FLAGS.output_path))
tf.logging.info("Starting at: {}".format(start_time))
tf.logging.info("Batch size: {} images per step".format(FLAGS.batch_size))
last_epoch_start_time = start_time
# Load datasets
imgs_train, msks_train, imgs_test, msks_test = load_datasets(FLAGS)
if not FLAGS.no_horovod:
# Initialize Horovod.
hvd.init()
# Define model
model = define_model(imgs_train.shape, msks_train.shape, FLAGS)
if not FLAGS.no_horovod:
# Horovod: adjust learning rate based on number workers
opt = tf.train.AdamOptimizer(learning_rate=FLAGS.learningrate,
epsilon=tf.keras.backend.epsilon())
#opt = tf.train.RMSPropOptimizer(0.0001 * hvd.size())
# tf.logging.info("HOROVOD: New learning rate is {}".\
# format(FLAGS.learningrate * hvd.size()))
else:
opt = tf.train.AdamOptimizer(learning_rate=FLAGS.learningrate,
epsilon=tf.keras.backend.epsilon())
#opt = tf.train.RMSPropOptimizer(0.0001)
# Wrap optimizer with Horovod Distributed Optimizer.
if not FLAGS.no_horovod:
tf.logging.info("HOROVOD: Wrapped optimizer")
opt = hvd.DistributedOptimizer(opt)
global_step = tf.train.get_or_create_global_step()
train_op = opt.minimize(model["loss"], global_step=global_step)
train_length = len(imgs_train)
total_steps = (FLAGS.epochs * train_length) // FLAGS.batch_size
if not FLAGS.no_horovod:
last_step = total_steps // hvd.size()
validation_steps = train_length // FLAGS.batch_size // hvd.size()
else:
last_step = total_steps
validation_steps = train_length // FLAGS.batch_size
def formatter_log(tensors):
"""
Format the log output
"""
if FLAGS.no_horovod:
logstring = "Step {} of {}: " \
" training Dice loss = {:.4f}," \
" training Dice = {:.4f}".format(tensors["step"],
last_step,
tensors["loss"], tensors["dice"])
else:
logstring = "HOROVOD (Worker #{}), Step {} of {}: " \
" training Dice loss = {:.4f}," \
" training Dice = {:.4f}".format(
hvd.rank(),
tensors["step"],
last_step,
tensors["loss"], tensors["dice"])
return logstring
hooks = [
tf.train.StopAtStepHook(last_step=last_step),
# Prints the loss and step every log_steps steps
tf.train.LoggingTensorHook(tensors={
"step": global_step,
"loss": model["loss"],
"dice": model["metric_dice"]
},
every_n_iter=FLAGS.log_steps,
formatter=formatter_log),
]
# Horovod: BroadcastGlobalVariablesHook broadcasts
# initial variable states from rank 0 to all other
# processes. This is necessary to ensure consistent
# initialization of all workers when training is
# started with random weights
# or restored from a checkpoint.
if not FLAGS.no_horovod:
hooks.append(hvd.BroadcastGlobalVariablesHook(0))
# Horovod: save checkpoints only on worker 0 to prevent other workers from
# corrupting them.
if hvd.rank() == 0:
checkpoint_dir = "{}/{}-workers/{}".format(
FLAGS.output_path, hvd.size(),
datetime.now().strftime("%Y%m%d-%H%M%S"))
print(checkpoint_dir)
else:
checkpoint_dir = None
else:
checkpoint_dir = "{}/no_hvd/{}".format(
FLAGS.output_path,
datetime.now().strftime("%Y%m%d-%H%M%S"))
# The MonitoredTrainingSession takes care of session initialization,
# restoring from a checkpoint, saving to a checkpoint,
# and closing when done or an error occurs.
current_step = 0
startidx = 0
epoch_idx = 0
with tf.train.MonitoredTrainingSession(
checkpoint_dir=checkpoint_dir,
hooks=hooks,
save_summaries_steps=FLAGS.log_steps,
log_step_count_steps=FLAGS.log_steps,
config=config) as mon_sess:
while not mon_sess.should_stop():
# Run a training step synchronously.
image_, mask_ = get_batch(imgs_train, msks_train, FLAGS.batch_size)
# Do batch in order
# stopidx = startidx + FLAGS.batch_size
# if (stopidx > train_length):
# stopidx = train_length
#
# image_ = imgs_train[startidx:stopidx]
# mask_ = msks_train[startidx:stopidx]
mon_sess.run(train_op,
feed_dict={
model["input"]: image_,
model["label"]: mask_
})
current_step += 1
# # Get next batch (loop around if at end)
# startidx += FLAGS.batch_size
# if (startidx > train_length):
# startidx = 0
stop_time = datetime.now()
tf.logging.info("Stopping at: {}".format(stop_time))
tf.logging.info("Elapsed time was: {}".format(stop_time - start_time))
#print(len(train))
train_descriptions = u.load_clean_dict(train)
#print(len(train_descriptions))
train_features = u.load_photos('features.pkl', train)
#print(len(train_features))
tokenizer = u.create_tokenizer(train_descriptions)
vocab_size = len(tokenizer.word_index) + 1
#print('Vocabulary Size: %d' % vocab_size)
maxlen = u.max_length(train_descriptions)
train = u.make_set(m.TRAIN_IMG_NAME)
#print('Dataset: %d' % len(train))
train_descriptions = u.load_clean_dict(train)
#print('Descriptions: train=%d' % len(train_descriptions))
train_features = u.load_photos('features.pkl', train)
#print('Photos: train=%d' % len(train_features))
vocab_size = len(tokenizer.word_index) + 1
model = mo.define_model(vocab_size, maxlen)
### Since I already trained this, I am loading a model instead of training once again
model = m.load_model('model_9.h5')
epochs = 10
steps = len(train_descriptions)
### Do uncomment if the model is to be trained again
#for i in range(epochs):
#generator = data_generator(train_descriptions, train_features, tokenizer, max_length, vocab_size)
#model.fit_generator(generator, epochs=1, steps_per_epoch=steps, verbose=1)
#model.save('model_' + str(i) + '.h5')
