def remote_predict_models(models, test_reader, prediction_file, api, args,
resume=False, output_path=None,
session_file=None, log=None, exclude=None):
"""Retrieve predictions remotely, combine them and save predictions to file
"""
predictions_files = []
prediction_args = {
"tags": args.tag
}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
message_logged = False
raw_input_data_list = []
for input_data in test_reader:
raw_input_data_list.append(input_data)
single_model = len(models) == 1
if single_model:
prediction_file = UnicodeWriter(prediction_file).open_writer()
for model in models:
model = bigml.api.get_model_id(model)
predictions_file = get_predictions_file_name(model,
output_path)
predictions_files.append(predictions_file)
if (not resume or
not c.checkpoint(c.are_predictions_created, predictions_file,
test_reader.number_of_tests(),
debug=args.debug)[0]):
if not message_logged:
message = u.dated("Creating remote predictions.\n")
u.log_message(message, log_file=session_file,
console=args.verbosity)
message_logged = True
with UnicodeWriter(predictions_file) as predictions_file:
for input_data in raw_input_data_list:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(model, input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'],
log_file=log)
prediction_row = prediction_to_row(prediction)
predictions_file.writerow(prediction_row)
if single_model:
write_prediction(prediction_row[0:2], prediction_file,
args.prediction_info,
input_data, exclude)
if single_model:
prediction_file.close_writer()
else:
combine_votes(predictions_files,
Model(models[0]).to_prediction,
prediction_file, args.method,
args.prediction_info, raw_input_data_list, exclude)
def remote_predict(models,
test_reader,
prediction_file,
api,
resume=False,
verbosity=True,
output_path=None,
method=PLURALITY_CODE,
tags="",
session_file=None,
log=None,
debug=False,
prediction_info=None):
"""Retrieve predictions remotely, combine them and save predictions to file
"""
predictions_files = []
prediction_args = {"tags": tags}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
message_logged = False
raw_input_data_list = []
for model in models:
model = bigml.api.get_model_id(model)
predictions_file = get_predictions_file_name(model, output_path)
predictions_files.append(predictions_file)
if (not resume or not c.checkpoint(c.are_predictions_created,
predictions_file,
test_reader.number_of_tests(),
debug=debug)):
if not message_logged:
message = u.dated("Creating remote predictions.")
u.log_message(message,
log_file=session_file,
console=verbosity)
message_logged = True
predictions_file = csv.writer(open(predictions_file, 'w', 0),
lineterminator="\n")
for input_data in test_reader:
raw_input_data_list.append(input_data)
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(model,
input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction)
predictions_file.writerow(prediction_row)
combine_votes(predictions_files,
Model(models[0]).to_prediction, prediction_file, method,
prediction_info, raw_input_data_list)
def remote_predict(models, test_reader, prediction_file, api,
resume=False,
verbosity=True, output_path=None,
method=PLURALITY_CODE, tags="",
session_file=None, log=None, debug=False,
prediction_info=None):
"""Retrieve predictions remotely, combine them and save predictions to file
"""
predictions_files = []
prediction_args = {
"tags": tags
}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
message_logged = False
raw_input_data_list = []
for model in models:
model = bigml.api.get_model_id(model)
predictions_file = get_predictions_file_name(model,
output_path)
predictions_files.append(predictions_file)
if (not resume or
not c.checkpoint(c.are_predictions_created, predictions_file,
test_reader.number_of_tests(), debug=debug)):
if not message_logged:
message = u.dated("Creating remote predictions.")
u.log_message(message, log_file=session_file,
console=verbosity)
message_logged = True
predictions_file = csv.writer(open(predictions_file, 'w', 0),
lineterminator="\n")
for input_data in test_reader:
raw_input_data_list.append(input_data)
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(model, input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction)
predictions_file.writerow(prediction_row)
combine_votes(predictions_files,
Model(models[0]).to_prediction,
prediction_file, method,
prediction_info, raw_input_data_list)
def remote_predict_ensemble(ensemble_id,
test_reader,
prediction_file,
api,
resume=False,
verbosity=True,
output_path=None,
method=PLURALITY_CODE,
tags="",
session_file=None,
log=None,
debug=False,
prediction_info=None):
"""Retrieve predictions remotely and save predictions to file
"""
prediction_args = {"tags": tags, "combiner": method}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
if (not resume or not c.checkpoint(c.are_predictions_created,
prediction_file,
test_reader.number_of_tests(),
debug=debug)):
message = u.dated("Creating remote predictions.")
u.log_message(message, log_file=session_file, console=verbosity)
predictions_file = csv.writer(open(prediction_file, 'w', 0),
lineterminator="\n")
for input_data in test_reader:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(ensemble_id,
input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
prediction = u.check_resource(prediction, api.get_prediction)
u.check_resource_error(prediction, "Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction, prediction_info)
write_prediction(prediction_row, predictions_file, prediction_info,
input_data)
def remote_predict_ensemble(ensemble_id, test_reader, prediction_file, api,
resume=False,
verbosity=True, output_path=None,
method=PLURALITY_CODE, tags="",
session_file=None, log=None, debug=False,
prediction_info=None):
"""Retrieve predictions remotely and save predictions to file
"""
prediction_args = {
"tags": tags,
"combiner": method
}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
if (not resume or
not c.checkpoint(c.are_predictions_created, prediction_file,
test_reader.number_of_tests(), debug=debug)):
message = u.dated("Creating remote predictions.")
u.log_message(message, log_file=session_file,
console=verbosity)
predictions_file = csv.writer(open(prediction_file, 'w', 0),
lineterminator="\n")
for input_data in test_reader:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(ensemble_id, input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
prediction = u.check_resource(prediction,
api.get_prediction)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction, prediction_info)
write_prediction(prediction_row, predictions_file,
prediction_info, input_data)
def remote_predict_ensemble(ensemble_id,
test_reader,
prediction_file,
api,
args,
resume=False,
output_path=None,
session_file=None,
log=None,
exclude=None):
"""Retrieve predictions remotely and save predictions to file
"""
prediction_args = {"tags": args.tag, "combiner": args.method}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
if (not resume or not c.checkpoint(c.are_predictions_created,
prediction_file,
test_reader.number_of_tests(),
debug=args.debug)[0]):
message = u.dated("Creating remote predictions.")
u.log_message(message, log_file=session_file, console=args.verbosity)
with UnicodeWriter(prediction_file) as predictions_file:
for input_data in test_reader:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(ensemble_id,
input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
prediction = u.check_resource(prediction, api.get_prediction)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction,
args.prediction_info)
write_prediction(prediction_row, predictions_file,
args.prediction_info, input_data, exclude)
def remote_predict(models, headers, output_path, number_of_tests, resume,
verbosity, test_reader, exclude, fields, api,
prediction_file, method, tags, objective_field,
session_file, test_set_header, log, debug):
"""Retrieve predictions remotely, combine them and save predictions to file
"""
predictions_files = []
prediction_args = {
"tags": tags
}
for model in models:
if not isinstance(model, basestring) and 'resource' in model:
model = model['resource']
predictions_file = get_predictions_file_name(model,
output_path)
predictions_files.append(predictions_file)
if (not resume or
not u.checkpoint(u.are_predictions_created, predictions_file,
number_of_tests, debug=debug)):
message = u.dated("Creating remote predictions.\n")
u.log_message(message, log_file=session_file,
console=verbosity)
predictions_file = csv.writer(open(predictions_file, 'w', 0))
for row in test_reader:
for index in exclude:
del row[index]
input_data = fields.pair(row, headers, objective_field)
prediction = api.create_prediction(model, input_data,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = u.prediction_to_row(prediction)
predictions_file.writerow(prediction_row)
u.combine_votes(predictions_files,
Model(models[0]).to_prediction,
prediction_file, method)
def remote_predict_ensemble(ensemble_id, test_reader, prediction_file, api,
args, resume=False, output_path=None,
session_file=None, log=None, exclude=None):
"""Retrieve predictions remotely and save predictions to file
"""
prediction_args = {
"tags": args.tag,
"combiner": args.method
}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
if (not resume or not c.checkpoint(
c.are_predictions_created, prediction_file,
test_reader.number_of_tests(), debug=args.debug)[0]):
message = u.dated("Creating remote predictions.")
u.log_message(message, log_file=session_file,
console=args.verbosity)
with UnicodeWriter(prediction_file) as predictions_file:
for input_data in test_reader:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(ensemble_id,
input_data_dict,
by_name=test_set_header,
wait_time=0,
args=prediction_args)
prediction = u.check_resource(prediction,
api.get_prediction)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'], log_file=log)
prediction_row = prediction_to_row(prediction,
args.prediction_info)
write_prediction(prediction_row, predictions_file,
args.prediction_info, input_data, exclude)
def remote_predict_models(models,
test_reader,
prediction_file,
api,
args,
resume=False,
output_path=None,
session_file=None,
log=None,
exclude=None):
"""Retrieve predictions remotely, combine them and save predictions to file
"""
predictions_files = []
prediction_args = {"tags": args.tag}
test_set_header = test_reader.has_headers()
if output_path is None:
output_path = u.check_dir(prediction_file)
message_logged = False
raw_input_data_list = []
for input_data in test_reader:
raw_input_data_list.append(input_data)
single_model = len(models) == 1
if single_model:
prediction_file = UnicodeWriter(prediction_file).open_writer()
for model in models:
model = bigml.api.get_model_id(model)
predictions_file = get_predictions_file_name(model, output_path)
predictions_files.append(predictions_file)
if (not resume or not c.checkpoint(c.are_predictions_created,
predictions_file,
test_reader.number_of_tests(),
debug=args.debug)[0]):
if not message_logged:
message = u.dated("Creating remote predictions.\n")
u.log_message(message,
log_file=session_file,
console=args.verbosity)
message_logged = True
with UnicodeWriter(predictions_file) as predictions_file:
for input_data in raw_input_data_list:
input_data_dict = test_reader.dict(input_data)
prediction = api.create_prediction(model,
input_data_dict,
wait_time=0,
args=prediction_args)
u.check_resource_error(prediction,
"Failed to create prediction: ")
u.log_message("%s\n" % prediction['resource'],
log_file=log)
prediction_row = prediction_to_row(prediction)
predictions_file.writerow(prediction_row)
if single_model:
write_prediction(prediction_row[0:2], prediction_file,
args.prediction_info, input_data,
exclude)
if single_model:
prediction_file.close_writer()
else:
combine_votes(predictions_files,
Model(models[0]).to_prediction, prediction_file,
args.method, args.prediction_info, raw_input_data_list,
exclude)
