def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (models.get_model_config(FLAGS.model, FLAGS.config_name) if
FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(model_class,
config.hparams,
model_dir=FLAGS.model_dir)
# Read and process the input features.
features = _process_tce(config.inputs.features)
print(type(features))
print(features)
# Create an input function.
def input_fn():
return {
"time_series_features":
tf.estimator.inputs.numpy_input_fn(features,
batch_size=1,
shuffle=False,
queue_capacity=1)()
}
# Generate the predictions.
for predictions in estimator.predict(input_fn):
assert len(predictions) == 1
print("Prediction:", predictions[0])
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(
model_class, config.hparams, model_dir=FLAGS.model_dir)
# Read and process the input features.
features = _process_tce(config.inputs.features)
# Create an input function.
def input_fn():
return tf.data.Dataset.from_tensors({"time_series_features": features})
# Generate the predictions.
for predictions in estimator.predict(input_fn):
assert len(predictions) == 1
print("Prediction:", predictions[0])
def __init__(self, model_name, model_dir, config_name=None):
"""Initializes the DoFn.
Args:
model_name: Name of the model class.
model_dir: Directory containing a model checkpoint.
config_name: Optional name of the model configuration. If not specified,
the file 'config.json' in model_dir is used.
"""
# Look up the model class.
model_class = models.get_model_class(model_name)
# Find the latest checkpoint.
checkpoint_file = tf.train.latest_checkpoint(model_dir)
if not checkpoint_file:
raise ValueError(
"No checkpoint file found in: {}".format(model_dir))
# Get the model configuration.
if config_name:
config = models.get_model_config(model_name, config_name)
else:
with tf.gfile.Open(os.path.join(model_dir, "config.json")) as f:
config = json.load(f)
config = configdict.ConfigDict(config)
self.model_class = model_class
self.checkpoint_file = checkpoint_file
self.config = config
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(
model_class, config.hparams, model_dir=FLAGS.model_dir)
# Create an input function that reads the evaluation dataset.
input_fn = estimator_util.create_input_fn(
file_pattern=FLAGS.eval_files,
input_config=config.inputs,
mode=tf.estimator.ModeKeys.EVAL)
# Run evaluation. This will log the result to stderr and also write a summary
# file in the model_dir.
estimator_util.evaluate(estimator, input_fn, eval_name=FLAGS.eval_name)
def main(_):
config = models.get_model_config(FLAGS.model, FLAGS.config_name)
model_class = models.get_model_class(FLAGS.model)
model = model_class(config)
train(model, config)
def main(_):
# Look up the model class.
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
if (FLAGS.config_name is None) == (FLAGS.config_json is None):
raise ValueError("Exactly one of config_name or config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
if FLAGS.average:
model_dirs = glob.glob(FLAGS.model_dir+'/*')
else:
model_dirs = [FLAGS.model_dir]
y_pred = defaultdict(list)
for model_dir in model_dirs:
# append a new prediction to y_pred for each TCE every time
y_pred = predict(model_dir, config, model_class, y_pred)
y_pred_average = []
for tce in y_pred:
average_pred = np.mean(y_pred[tce])
y_pred_average.append([tce, average_pred])
np.savetxt('prediction_'+FLAGS.suffix+'.txt', np.array(y_pred_average), fmt=['%d', '%4.3f'])
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(
model_class, config.hparams, model_dir=FLAGS.model_dir)
# Read and process the input features.
features = _process_tce(config.inputs.features)
# Create an input function.
def input_fn():
return {
"time_series_features":
tf.estimator.inputs.numpy_input_fn(
features, batch_size=1, shuffle=False, queue_capacity=1)()
}
# Generate the predictions.
for predictions in estimator.predict(input_fn):
assert len(predictions) == 1
print("Prediction:", predictions[0])
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(
model_class, config.hparams, model_dir=FLAGS.model_dir)
# Print no. of trainable parameters to console.
var_names = [v for v in estimator.get_variable_names()]
n_params = np.sum([len(estimator.get_variable_value(v).flatten()) for v in var_names])
print("Trainable parameters in model:", int(n_params))
# Create an input function that reads the evaluation dataset.
input_fn = estimator_util.create_input_fn(
file_pattern=FLAGS.eval_files,
input_config=config.inputs,
mode=tf.estimator.ModeKeys.EVAL)
# Run evaluation. This will log the result to stderr and also write a summary
# file in the model_dir.
estimator_util.evaluate(estimator, input_fn, eval_name=FLAGS.eval_name)
def main(_):
config = models.get_model_config(FLAGS.model, FLAGS.config_name)
model_class = models.get_model_class(FLAGS.model)
study = study_config(config)
client = initialize_client()
print('Study:')
pprint.pprint(create_study(client, study))
tune(client, model_class, config, FLAGS.ensemble_count)
print('All done. Study name:', study_name())
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (
models.get_model_config(FLAGS.model, FLAGS.config_name)
if FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
config_util.log_and_save_config(config, FLAGS.model_dir)
# Create the estimator.
run_config = tf.estimator.RunConfig(keep_checkpoint_max=1)
estimator = estimator_util.create_estimator(model_class, config.hparams,
run_config, FLAGS.model_dir)
# Create an input function that reads the training dataset. We iterate through
# the dataset once at a time if we are alternating with evaluation, otherwise
# we iterate infinitely.
train_input_fn = estimator_util.create_input_fn(
file_pattern=FLAGS.train_files,
input_config=config.inputs,
mode=tf.estimator.ModeKeys.TRAIN,
shuffle_values_buffer=FLAGS.shuffle_buffer_size,
repeat=1 if FLAGS.eval_files else None)
if not FLAGS.eval_files:
estimator.train(train_input_fn, max_steps=FLAGS.train_steps)
else:
eval_input_fn = estimator_util.create_input_fn(
file_pattern=FLAGS.eval_files,
input_config=config.inputs,
mode=tf.estimator.ModeKeys.EVAL)
eval_args = {
"val": (eval_input_fn, None) # eval_name: (input_fn, eval_steps)
}
for _ in estimator_runner.continuous_train_and_eval(
estimator=estimator,
train_input_fn=train_input_fn,
eval_args=eval_args,
train_steps=FLAGS.train_steps):
# continuous_train_and_eval() yields evaluation metrics after each
# training epoch. We don't do anything here.
pass
def main(_):
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
assert (FLAGS.config_name is None) != (FLAGS.config_json is None), (
"Exactly one of --config_name or --config_json is required.")
config = (models.get_model_config(FLAGS.model, FLAGS.config_name) if
FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
# Create the estimator.
estimator = estimator_util.create_estimator(model_class,
config.hparams,
model_dir=FLAGS.model_dir)
# Read and process the input features.
tce_table = pd.read_csv(FLAGS.input_tce_csv_file,
header=0,
usecols=[0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13, 18],
dtype={
'Sectors': int,
'camera': int,
'ccd': int
})
for ind, tce in tce_table.iterrows():
features = _process_tce(config.inputs.features, tce)
# Create an input function.
def input_fn():
return {
"time_series_features":
tf.compat.v1.estimator.inputs.numpy_input_fn(
features, batch_size=1, shuffle=False, queue_capacity=1)()
}
# Generate the predictions.
for predictions in estimator.predict(input_fn):
assert len(predictions) == 1
print(tce.tic_id, "Prediction:", predictions[0])
print(str(tce.tic_id) + ' ' + str(predictions[0]),
file=open(FLAGS.output_file, 'a'))
def main(_):
# Look up the model class.
model_class = models.get_model_class(FLAGS.model)
# Look up the model configuration.
if (FLAGS.config_name is None) == (FLAGS.config_json is None):
raise ValueError(
"Exactly one of config_name or config_json is required.")
config = (models.get_model_config(FLAGS.model, FLAGS.config_name) if
FLAGS.config_name else config_util.parse_json(FLAGS.config_json))
config = configdict.ConfigDict(config)
if FLAGS.average:
model_dirs = glob.glob(FLAGS.model_dir + '/*')
else:
model_dirs = [FLAGS.model_dir]
y_pred = defaultdict(list)
true_disp = defaultdict(list)
for model_dir in model_dirs:
# append a new prediction to y_pred for each TCE every time
y_pred, true_disp = predict(model_dir, config, model_class, y_pred,
true_disp)
y_pred_average = []
is_pc = []
cnt = 0
num_tces = len(y_pred)
for tce in y_pred:
# Plotting takes quite long. There's probably a better way to do it.
if cnt % 100 == 0:
tf.logging.info("Averaging %d of %d", cnt, num_tces)
disposition = true_disp[tce]
y_true = disposition in ['PC', 'EB']
is_pc.append(disposition == 'PC')
average_pred = np.mean(y_pred[tce])
if average_pred >= 0.1:
label = "PC/EB"
else:
label = "junk"
if FLAGS.plot and disposition == 'PC' and average_pred < 0.1:
kepid, sector = tce.split('-')
ex = find_tce(int(kepid), int(sector))
plot_tce(ex.features.feature["tic_id"].int64_list.value[0],
ex.features.feature['Sectors'].int64_list.value[0], label,
average_pred)
y_pred_average.append([y_true, average_pred])
cnt += 1
threshold = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
y_true = np.array(y_pred_average)[:, 0]
y_pred = np.array(y_pred_average)[:, 1]
is_pc = np.array(is_pc)
for t in threshold:
tp = len(np.where((y_true == 1) & (y_pred >= t))[0])
fp = len(np.where((y_true == 0) & (y_pred >= t))[0])
fn = len(np.where((y_true == 1) & (y_pred < t))[0])
tn = len(np.where((y_true == 0) & (y_pred < t))[0])
precision = float(tp) / (tp + fp)
recall = float(tp) / (tp + fn)
print(1 - float(fp) / (tn + fp))
num_pc = len(np.where((is_pc == True) & (y_pred < t))[0])
print(
"Threshold %s: precision=%s, recall=%s. Number of PCs in FNs = %s"
% (t, precision, recall, num_pc))
np.savetxt('true_vs_pred_' + FLAGS.suffix + '.txt',
np.array(y_pred_average),
fmt=['%f', '%4.3f'])
pc_count = len(np.where(is_pc == True)[0])
print('Total %s PCs' % pc_count)
def create_config(model_name="AstroCNNModel", config_name="local_global"):
config = (models.get_model_config(model_name, config_name)
if config_name else config_util.parse_json("config_json"))
return configdict.ConfigDict(config)
