def update_deepnet(deepnet,
deepnet_args,
args,
api=None,
path=None,
session_file=None):
"""Updates deepnet properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating deepnet. %s\n" % get_url(deepnet))
log_message(message, log_file=session_file, console=args.verbosity)
deepnet = api.update_deepnet(deepnet, deepnet_args)
check_resource_error(deepnet,
"Failed to update deepnet: %s" % deepnet['resource'])
deepnet = check_resource(deepnet,
api.get_deepnet,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(deepnet):
message = dated("Shared deepnet link. %s\n" %
get_url(deepnet, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, deepnet)
return deepnet
def update_time_series(time_series,
time_series_args,
args,
api=None,
path=None,
session_file=None):
"""Updates time-series properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating time-series. %s\n" % get_url(time_series))
log_message(message, log_file=session_file, console=args.verbosity)
time_series = api.update_time_series(time_series, \
time_series_args)
check_resource_error(
time_series,
"Failed to update time-series: %s" % time_series['resource'])
time_series = check_resource(time_series,
api.get_time_series,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(time_series):
message = dated("Shared time-series link. %s\n" %
get_url(time_series, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, time_series)
return time_series
def update_logistic_regression(logistic_regression,
logistic_regression_args,
args,
api=None,
path=None,
session_file=None):
"""Updates logistic regression properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating logistic regression. %s\n" %
get_url(logistic_regression))
log_message(message, log_file=session_file, console=args.verbosity)
logistic_regression = api.update_logistic_regression(logistic_regression, \
logistic_regression_args)
check_resource_error(
logistic_regression, "Failed to update logistic regression: %s" %
logistic_regression['resource'])
logistic_regression = check_resource(logistic_regression,
api.get_logistic_regression,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(logistic_regression):
message = dated("Shared logistic regression link. %s\n" %
get_url(logistic_regression, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, logistic_regression)
return logistic_regression
def update_anomaly(anomaly,
anomaly_args,
args,
api=None,
path=None,
session_file=None):
"""Updates anomaly properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating anomaly detector. %s\n" % get_url(anomaly))
log_message(message, log_file=session_file, console=args.verbosity)
anomaly = api.update_anomaly(anomaly, anomaly_args)
check_resource_error(anomaly,
"Failed to update anomaly: %s" % anomaly['resource'])
anomaly = check_resource(anomaly,
api.get_anomaly,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(anomaly):
message = dated("Shared anomaly link. %s\n" %
get_url(anomaly, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, anomaly)
return anomaly
def create_ensembles(datasets, ensemble_ids, ensemble_args, args,
number_of_ensembles=1,
api=None, path=None, session_file=None, log=None):
"""Create ensembles from input data
"""
if api is None:
api = bigml.api.BigML()
ensembles = ensemble_ids[:]
existing_ensembles = len(ensembles)
model_ids = []
ensemble_args_list = []
if isinstance(ensemble_args, list):
ensemble_args_list = ensemble_args
if args.dataset_off and args.evaluate:
args.test_dataset_ids = datasets[:]
if not args.multi_label:
datasets = datasets[existing_ensembles:]
if number_of_ensembles > 0:
message = dated("Creating %s.\n" %
plural("ensemble", number_of_ensembles))
log_message(message, log_file=session_file,
console=args.verbosity)
inprogress = []
for i in range(0, number_of_ensembles):
wait_for_available_tasks(inprogress, args.max_parallel_ensembles,
api, "ensemble",
wait_step=args.number_of_models)
if ensemble_args_list:
ensemble_args = ensemble_args_list[i]
if args.dataset_off and args.evaluate:
multi_dataset = args.test_dataset_ids[:]
del multi_dataset[i + existing_ensembles]
ensemble = api.create_ensemble(multi_dataset,
ensemble_args,
retries=None)
else:
ensemble = api.create_ensemble(datasets, ensemble_args,
retries=None)
ensemble_id = check_resource_error(ensemble,
"Failed to create ensemble: ")
log_message("%s\n" % ensemble_id, log_file=log)
ensemble_ids.append(ensemble_id)
inprogress.append(ensemble_id)
ensembles.append(ensemble)
log_created_resources("ensembles", path, ensemble_id,
mode='a')
models, model_ids = retrieve_ensembles_models(ensembles, api, path)
if number_of_ensembles < 2 and args.verbosity:
message = dated("Ensemble created: %s\n" %
get_url(ensemble))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, ensemble)
return ensembles, ensemble_ids, models, model_ids
def update_sample(sample,
sample_args,
args,
api=None,
path=None,
session_file=None):
"""Updates sample properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating sample. %s\n" % get_url(sample))
log_message(message, log_file=session_file, console=args.verbosity)
sample = api.update_sample(sample, sample_args)
check_resource_error(sample,
"Failed to update sample: %s" % sample['resource'])
sample = check_resource(sample, api.get_sample, raise_on_error=True)
if is_shared(sample):
message = dated("Shared sample link. %s\n" %
get_url(sample, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, sample)
return sample
def update_topic_model(topic_model,
topic_model_args,
args,
api=None,
path=None,
session_file=None):
"""Updates topic model properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating topic model. %s\n" % get_url(topic_model))
log_message(message, log_file=session_file, console=args.verbosity)
topic_model = api.update_topic_model(topic_model, \
topic_model_args)
check_resource_error(
topic_model,
"Failed to update topic model: %s" % topic_model['resource'])
topic_model = check_resource(topic_model,
api.get_topic_model,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(topic_model):
message = dated("Shared topic model link. %s\n" %
get_url(topic_model, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, topic_model)
return topic_model
def create_samples(datasets,
sample_ids,
sample_args,
args,
api=None,
path=None,
session_file=None,
log=None):
"""Create remote samples
"""
if api is None:
api = bigml.api.BigML()
samples = sample_ids[:]
existing_samples = len(samples)
sample_args_list = []
datasets = datasets[existing_samples:]
# if resuming and all samples were created, there will be no datasets left
if datasets:
if isinstance(sample_args, list):
sample_args_list = sample_args
# Only one sample per command, at present
number_of_samples = 1
max_parallel_samples = 1
message = dated("Creating %s.\n" % plural("sample", number_of_samples))
log_message(message, log_file=session_file, console=args.verbosity)
inprogress = []
for i in range(0, number_of_samples):
wait_for_available_tasks(inprogress, max_parallel_samples, api,
"sample")
if sample_args_list:
sample_args = sample_args_list[i]
sample = api.create_sample(datasets[i], sample_args, retries=None)
sample_id = check_resource_error(sample,
"Failed to create sample: ")
log_message("%s\n" % sample_id, log_file=log)
sample_ids.append(sample_id)
inprogress.append(sample_id)
samples.append(sample)
log_created_resources("samples", path, sample_id, mode='a')
if args.verbosity:
if bigml.api.get_status(sample)['code'] != bigml.api.FINISHED:
try:
sample = check_resource(sample,
api.get_sample,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished sample: %s" %
str(exception))
samples[0] = sample
message = dated("Sample created: %s\n" % get_url(sample))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, sample)
def create_clusters(datasets, cluster_ids, cluster_args,
args, api=None, path=None,
session_file=None, log=None):
"""Create remote clusters
"""
if api is None:
api = bigml.api.BigML()
clusters = cluster_ids[:]
existing_clusters = len(clusters)
cluster_args_list = []
datasets = datasets[existing_clusters:]
# if resuming and all clusters were created, there will be no datasets left
if datasets:
if isinstance(cluster_args, list):
cluster_args_list = cluster_args
# Only one cluster per command, at present
number_of_clusters = 1
message = dated("Creating %s.\n" %
plural("cluster", number_of_clusters))
log_message(message, log_file=session_file,
console=args.verbosity)
query_string = FIELDS_QS
inprogress = []
for i in range(0, number_of_clusters):
wait_for_available_tasks(inprogress, args.max_parallel_clusters,
api, "cluster")
if cluster_args_list:
cluster_args = cluster_args_list[i]
cluster = api.create_cluster(datasets, cluster_args, retries=None)
cluster_id = check_resource_error(cluster,
"Failed to create cluster: ")
log_message("%s\n" % cluster_id, log_file=log)
cluster_ids.append(cluster_id)
inprogress.append(cluster_id)
clusters.append(cluster)
log_created_resources("clusters", path, cluster_id, mode='a')
if args.verbosity:
if bigml.api.get_status(cluster)['code'] != bigml.api.FINISHED:
try:
cluster = check_resource(cluster, api.get_cluster,
query_string=query_string,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished cluster: %s" %
str(exception))
clusters[0] = cluster
message = dated("Cluster created: %s\n" %
get_url(cluster))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, cluster)
def create_fusion(models,
fusion,
fusion_args,
args,
api=None,
path=None,
session_file=None,
log=None):
"""Create remote fusion
"""
if api is None:
api = bigml.api.BigML()
fusions = []
fusion_ids = []
if fusion is not None:
fusions = [fusion]
fusion_ids = [fusion]
# if resuming and all fusions were created
if models:
# Only one fusion per command, at present
message = dated("Creating fusion.\n")
log_message(message, log_file=session_file, console=args.verbosity)
query_string = FIELDS_QS
inprogress = []
wait_for_available_tasks(inprogress, args.max_parallel_fusions, api,
"fusion")
fusion = api.create_fusion(models, fusion_args, retries=None)
fusion_id = check_resource_error( \
fusion,
"Failed to create fusion: ")
log_message("%s\n" % fusion_id, log_file=log)
fusion_ids.append(fusion_id)
inprogress.append(fusion_id)
fusions.append(fusion)
log_created_resources("fusions", path, fusion_id, mode='a')
if args.verbosity:
if bigml.api.get_status(fusion)['code'] != bigml.api.FINISHED:
try:
fusion = check_resource( \
fusion, api.get_fusion,
query_string=query_string,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished fusion: %s" %
str(exception))
fusions[0] = fusion
message = dated("Fusion created: %s\n" % get_url(fusion))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, fusion)
def create_ensembles(datasets,
ensemble_ids,
ensemble_args,
args,
number_of_ensembles=1,
api=None,
path=None,
session_file=None,
log=None):
"""Create ensembles from input data
"""
if api is None:
api = bigml.api.BigML()
ensembles = ensemble_ids[:]
model_ids = []
ensemble_args_list = []
if isinstance(ensemble_args, list):
ensemble_args_list = ensemble_args
if number_of_ensembles > 0:
message = dated("Creating %s.\n" %
plural("ensemble", number_of_ensembles))
log_message(message, log_file=session_file, console=args.verbosity)
query_string = ALL_FIELDS_QS
inprogress = []
for i in range(0, number_of_ensembles):
wait_for_available_tasks(inprogress,
args.max_parallel_ensembles,
api.get_ensemble,
"ensemble",
query_string=query_string,
wait_step=args.number_of_models)
if ensemble_args_list:
ensemble_args = ensemble_args_list[i]
ensemble = api.create_ensemble(datasets, ensemble_args)
ensemble_id = check_resource_error(ensemble,
"Failed to create ensemble: ")
log_message("%s\n" % ensemble_id, log_file=log)
ensemble_ids.append(ensemble_id)
inprogress.append(ensemble_id)
ensembles.append(ensemble)
log_created_resources("ensembles",
path,
ensemble_id,
open_mode='a')
models, model_ids = retrieve_ensembles_models(ensembles, api, path)
if number_of_ensembles < 2 and args.verbosity:
message = dated("Ensemble created: %s.\n" % get_url(ensemble))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, ensemble)
return ensembles, ensemble_ids, models, model_ids
def create_ensembles(datasets, ensemble_ids, ensemble_args, args,
number_of_ensembles=1,
api=None, path=None, session_file=None, log=None):
"""Create ensembles from input data
"""
if api is None:
api = bigml.api.BigML()
ensembles = ensemble_ids[:]
model_ids = []
ensemble_args_list = []
if isinstance(ensemble_args, list):
ensemble_args_list = ensemble_args
if number_of_ensembles > 0:
message = dated("Creating %s.\n" %
plural("ensemble", number_of_ensembles))
log_message(message, log_file=session_file,
console=args.verbosity)
query_string = ALL_FIELDS_QS
inprogress = []
for i in range(0, number_of_ensembles):
wait_for_available_tasks(inprogress, args.max_parallel_ensembles,
api.get_ensemble, "ensemble",
query_string=query_string,
wait_step=args.number_of_models)
if ensemble_args_list:
ensemble_args = ensemble_args_list[i]
ensemble = api.create_ensemble(datasets, ensemble_args)
ensemble_id = check_resource_error(ensemble,
"Failed to create ensemble: ")
log_message("%s\n" % ensemble_id, log_file=log)
ensemble_ids.append(ensemble_id)
inprogress.append(ensemble_id)
ensembles.append(ensemble)
log_created_resources("ensembles", path, ensemble_id,
open_mode='a')
models, model_ids = retrieve_ensembles_models(ensembles, api, path)
if number_of_ensembles < 2 and args.verbosity:
message = dated("Ensemble created: %s.\n" %
get_url(ensemble))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, ensemble)
return ensembles, ensemble_ids, models, model_ids
def update_dataset(dataset, dataset_args, args,
api=None, path=None, session_file=None):
"""Updates dataset properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating dataset. %s\n" %
get_url(dataset))
log_message(message, log_file=session_file,
console=args.verbosity)
dataset = api.update_dataset(dataset, dataset_args)
if is_shared(dataset):
message = dated("Shared dataset link. %s\n" %
get_url(dataset, shared=True))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, dataset)
check_resource_error(dataset, "Failed to update dataset: ")
return dataset
def update_dataset(dataset,
dataset_args,
args,
api=None,
path=None,
session_file=None):
"""Updates dataset properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating dataset. %s\n" % get_url(dataset))
log_message(message, log_file=session_file, console=args.verbosity)
dataset = api.update_dataset(dataset, dataset_args)
if is_shared(dataset):
message = dated("Shared dataset link. %s\n" %
get_url(dataset, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, dataset)
check_resource_error(dataset, "Failed to update dataset: ")
return dataset
def update_model(model, model_args, args,
api=None, path=None, session_file=None):
"""Updates model properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating model. %s\n" %
get_url(model))
log_message(message, log_file=session_file,
console=args.verbosity)
model = api.update_model(model, model_args)
check_resource_error(model, "Failed to update model: %s"
% model['resource'])
if is_shared(model):
message = dated("Shared model link. %s\n" %
get_url(model, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, model)
return model
def update_evaluation(evaluation, evaluation_args, args,
api=None, path=None, session_file=None):
"""Updates evaluation properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating evaluation. %s\n" %
get_url(evaluation))
log_message(message, log_file=session_file,
console=args.verbosity)
evaluation = api.update_evaluation(evaluation, evaluation_args)
check_resource_error(evaluation, "Failed to update evaluation: %s"
% evaluation['resource'])
if is_shared(evaluation):
message = dated("Shared evaluation link. %s\n" %
get_url(evaluation, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, evaluation)
return evaluation
def update_pca(pca, pca_args, args, api=None, path=None, session_file=None):
"""Updates pca properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating PCA. %s\n" % get_url(pca))
log_message(message, log_file=session_file, console=args.verbosity)
pca = api.update_pca(pca, pca_args)
check_resource_error(pca, "Failed to update PCA: %s" % pca['resource'])
pca = check_resource(pca,
api.get_pca,
query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(pca):
message = dated("Shared PCA link. %s\n" % get_url(pca, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, pca)
return pca
def update_model(model,
model_args,
args,
api=None,
path=None,
session_file=None):
"""Updates model properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating model. %s\n" % get_url(model))
log_message(message, log_file=session_file, console=args.verbosity)
model = api.update_model(model, model_args)
check_resource_error(model,
"Failed to update model: %s" % model['resource'])
if is_shared(model):
message = dated("Shared model link. %s\n" %
get_url(model, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, model)
return model
def update_evaluation(evaluation,
evaluation_args,
args,
api=None,
path=None,
session_file=None):
"""Updates evaluation properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating evaluation. %s\n" % get_url(evaluation))
log_message(message, log_file=session_file, console=args.verbosity)
evaluation = api.update_evaluation(evaluation, evaluation_args)
check_resource_error(
evaluation, "Failed to update evaluation: %s" % evaluation['resource'])
if is_shared(evaluation):
message = dated("Shared evaluation link. %s\n" %
get_url(evaluation, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, evaluation)
return evaluation
def update_cluster(cluster, cluster_args, args,
api=None, path=None, session_file=None):
"""Updates cluster properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating cluster. %s\n" %
get_url(cluster))
log_message(message, log_file=session_file,
console=args.verbosity)
cluster = api.update_cluster(cluster, cluster_args)
check_resource_error(cluster, "Failed to update cluster: %s"
% cluster['resource'])
cluster = check_resource(cluster, api.get_cluster, query_string=FIELDS_QS,
raise_on_error=True)
if is_shared(cluster):
message = dated("Shared cluster link. %s\n" %
get_url(cluster, shared=True))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, cluster)
return cluster
def create_anomalies(datasets,
anomaly_ids,
anomaly_args,
args,
api=None,
path=None,
session_file=None,
log=None):
"""Create remote anomalies
"""
if api is None:
api = bigml.api.BigML()
anomalies = anomaly_ids[:]
existing_anomalies = len(anomalies)
anomaly_args_list = []
datasets = datasets[existing_anomalies:]
# if resuming and all anomalies were created,
# there will be no datasets left
if datasets:
if isinstance(anomaly_args, list):
anomaly_args_list = anomaly_args
# Only one anomaly per command, at present
number_of_anomalies = 1
message = dated("Creating %s.\n" %
plural("anomaly detector", number_of_anomalies))
log_message(message, log_file=session_file, console=args.verbosity)
query_string = FIELDS_QS
inprogress = []
for i in range(0, number_of_anomalies):
wait_for_available_tasks(inprogress, args.max_parallel_anomalies,
api, "anomaly")
if anomaly_args_list:
anomaly_args = anomaly_args_list[i]
anomaly = api.create_anomaly(datasets, anomaly_args, retries=None)
anomaly_id = check_resource_error(anomaly,
"Failed to create anomaly: ")
log_message("%s\n" % anomaly_id, log_file=log)
anomaly_ids.append(anomaly_id)
inprogress.append(anomaly_id)
anomalies.append(anomaly)
log_created_resources("anomalies", path, anomaly_id, mode='a')
if args.verbosity:
if bigml.api.get_status(anomaly)['code'] != bigml.api.FINISHED:
try:
anomaly = check_resource(anomaly,
api.get_anomaly,
query_string=query_string,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished anomaly: %s" %
str(exception))
anomalies[0] = anomaly
message = dated("Anomaly created: %s\n" % get_url(anomaly))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, anomaly)
path=None,
log=None):
"""Creates remote batch projection
"""
if api is None:
api = bigml.api.BigML()
message = dated("Creating batch projection.\n")
log_message(message, log_file=session_file, console=args.verbosity)
batch_projection = api.create_batch_projection( \
pca, test_dataset, batch_projection_args, retries=None)
log_created_resources( \
"batch_projection", path,
bigml.api.get_batch_projection_id(batch_projection), mode='a')
batch_projection_id = check_resource_error(
batch_projection, "Failed to create batch projection: ")
try:
batch_projection = check_resource( \
batch_projection, api.get_batch_projection,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished batch projection: %s" %
str(exception))
message = dated("Batch projection created: %s\n" %
get_url(batch_projection))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % batch_projection_id, log_file=log)
if args.reports:
report(args.reports, path, batch_projection)
return batch_projection
def create_evaluations(model_ids,
datasets,
evaluation_args,
args,
api=None,
path=None,
session_file=None,
log=None,
existing_evaluations=0):
"""Create evaluations for a list of models
``model_ids``: list of model ids to create an evaluation of
``datasets``: dataset objects or ids to evaluate with
``evaluation_args``: arguments for the ``create_evaluation`` call
``args``: input values for bigmler flags
``api``: api to remote objects in BigML
``path``: directory to store the BigMLer generated files in
``session_file``: file to store the messages of that session
``log``: user provided log file
``existing_evaluations``: evaluations found when attempting resume
"""
evaluations = []
dataset = datasets[0]
evaluation_args_list = []
if isinstance(evaluation_args, list):
evaluation_args_list = evaluation_args
if api is None:
api = bigml.api.BigML()
remaining_ids = model_ids[existing_evaluations:]
number_of_evaluations = len(remaining_ids)
message = dated("Creating evaluations.\n")
log_message(message, log_file=session_file, console=args.verbosity)
inprogress = []
for i in range(0, number_of_evaluations):
model = remaining_ids[i]
wait_for_available_tasks(inprogress, args.max_parallel_evaluations,
api.get_evaluation, "evaluation")
if evaluation_args_list != []:
evaluation_args = evaluation_args_list[i]
if args.cross_validation_rate > 0:
new_seed = get_basic_seed(i + existing_evaluations)
evaluation_args.update(seed=new_seed)
evaluation = api.create_evaluation(model, dataset, evaluation_args)
evaluation_id = check_resource_error(evaluation,
"Failed to create evaluation: ")
inprogress.append(evaluation_id)
log_created_resources("evaluations",
path,
evaluation_id,
open_mode='a')
evaluations.append(evaluation)
log_message("%s\n" % evaluation['resource'], log_file=log)
if (args.number_of_evaluations < 2 and len(evaluations) == 1
and args.verbosity):
evaluation = evaluations[0]
if bigml.api.get_status(evaluation)['code'] != bigml.api.FINISHED:
try:
evaluation = check_resource(evaluation, api.get_evaluation)
except ValueError, exception:
sys.exit("Failed to get a finished evaluation: %s" %
str(exception))
evaluations[0] = evaluation
message = dated("Evaluation created: %s.\n" % get_url(evaluation))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, evaluation)
def create_logistic_regressions(datasets,
logistic_regression_ids,
logistic_regression_args,
args,
api=None,
path=None,
session_file=None,
log=None):
"""Create remote logistic regressions
"""
if api is None:
api = bigml.api.BigML()
logistic_regressions = logistic_regression_ids[:]
existing_logistic_regressions = len(logistic_regressions)
logistic_regression_args_list = []
datasets = datasets[existing_logistic_regressions:]
# if resuming and all logistic regressions were created,
# there will be no datasets left
if datasets:
if isinstance(logistic_regression_args, list):
logistic_regression_args_list = logistic_regression_args
# Only one logistic regression per command, at present
number_of_logistic_regressions = 1
message = dated(
"Creating %s.\n" %
plural("logistic regression", number_of_logistic_regressions))
log_message(message, log_file=session_file, console=args.verbosity)
query_string = FIELDS_QS
inprogress = []
for i in range(0, number_of_logistic_regressions):
wait_for_available_tasks(inprogress,
args.max_parallel_logistic_regressions,
api, "logisticregression")
if logistic_regression_args_list:
logistic_regression_args = logistic_regression_args_list[i]
if args.cross_validation_rate > 0:
new_seed = get_basic_seed(i + existing_logistic_regressions)
logistic_regression_args.update(seed=new_seed)
if (args.test_datasets and args.evaluate):
dataset = datasets[i]
logistic_regression = api.create_logistic_regression( \
dataset, logistic_regression_args, retries=None)
elif args.dataset_off and args.evaluate:
multi_dataset = args.test_dataset_ids[:]
del multi_dataset[i + existing_logistic_regressions]
logistic_regression = api.create_logistic_regression( \
multi_dataset, logistic_regression_args, retries=None)
else:
logistic_regression = api.create_logistic_regression( \
datasets, logistic_regression_args, retries=None)
logistic_regression_id = check_resource_error( \
logistic_regression, "Failed to create logistic regression: ")
log_message("%s\n" % logistic_regression_id, log_file=log)
logistic_regression_ids.append(logistic_regression_id)
inprogress.append(logistic_regression_id)
logistic_regressions.append(logistic_regression)
log_created_resources("logistic_regressions",
path,
logistic_regression_id,
mode='a')
if args.verbosity:
if bigml.api.get_status(logistic_regression)['code'] != \
bigml.api.FINISHED:
try:
logistic_regression = check_resource( \
logistic_regression, api.get_logistic_regression,
query_string=query_string, raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished logistic regression:"
" %s" % str(exception))
logistic_regressions[0] = logistic_regression
message = dated("Logistic regression created: %s\n" %
get_url(logistic_regression))
log_message(message, log_file=session_file, console=args.verbosity)
if args.reports:
report(args.reports, path, logistic_regression)
external_connector_id = check_resource_error( \
external_connector,
"Failed to create external connector: ")
try:
external_connector = check_resource( \
external_connector, api=api, raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished external connector: %s" % \
str(exception))
message = dated("External connector \"%s\" has been created.\n" %
external_connector['object']['name'])
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % external_connector_id, log_file=log)
try:
if args.reports:
report(args.reports, path, external_connector)
except AttributeError:
pass
return external_connector
def update_external_connector(external_connector_args,
args,
api=None,
session_file=None,
log=None):
"""Updates external connector properties
"""
if api is None:
api = bigml.api.BigML()
model = api.create_model(cluster, model_args, retries=None)
suffix = "" if model_type is None else "_%s" % model_type
log_created_resources("models%s" % suffix, path,
bigml.api.get_model_id(model), mode='a')
model_id = check_resource_error(model, "Failed to create model: ")
try:
model = check_resource(model, api.get_model,
query_string=ALL_FIELDS_QS,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished model: %s" % str(exception))
message = dated("Model created: %s\n" % get_url(model))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % model_id, log_file=log)
if args.reports:
report(args.reports, path, model)
return model
def update_model(model, model_args, args,
api=None, path=None, session_file=None):
"""Updates model properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating model. %s\n" %
get_url(model))
log_message(message, log_file=session_file,
console=args.verbosity)
model = api.update_model(model, model_args)
log_created_resources("project",
path,
bigml.api.get_project_id(project),
mode='a')
project_id = check_resource_error(project, "Failed to create project: ")
try:
project = check_resource(project, api=api, raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished project: %s" % str(exception))
message = dated("Project \"%s\" has been created.\n" %
project['object']['name'])
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % project_id, log_file=log)
try:
if args.reports:
report(args.reports, path, project)
except AttributeError:
pass
return project
def update_project(project_args, args, api=None, session_file=None, log=None):
"""Updates project properties
"""
if api is None:
api = bigml.api.BigML()
message = dated("Updating project attributes.\n")
log_message(message, log_file=session_file, console=args.verbosity)
project = api.update_project(args.project_id, project_args)
check_resource_error(project,
def create_models(datasets, model_ids, model_args,
args, api=None, path=None,
session_file=None, log=None):
"""Create remote models
"""
if api is None:
api = bigml.api.BigML()
models = model_ids[:]
existing_models = len(models)
model_args_list = []
if args.dataset_off and args.evaluate:
args.test_dataset_ids = datasets[:]
if not args.multi_label:
datasets = datasets[existing_models:]
# if resuming and all models were created, there will be no datasets left
if datasets:
dataset = datasets[0]
if isinstance(model_args, list):
model_args_list = model_args
if args.number_of_models > 0:
message = dated("Creating %s.\n" %
plural("model", args.number_of_models))
log_message(message, log_file=session_file,
console=args.verbosity)
single_model = args.number_of_models == 1 and existing_models == 0
# if there's more than one model the first one must contain
# the entire field structure to be used as reference.
query_string = (FIELDS_QS if single_model and (args.test_header \
and not args.export_fields) else ALL_FIELDS_QS)
inprogress = []
for i in range(0, args.number_of_models):
wait_for_available_tasks(inprogress, args.max_parallel_models,
api, "model")
if model_args_list:
model_args = model_args_list[i]
if args.cross_validation_rate > 0:
new_seed = get_basic_seed(i + existing_models)
model_args.update(seed=new_seed)
# one model per dataset (--max-categories or single model)
if (args.max_categories > 0 or
(args.test_datasets and args.evaluate)):
dataset = datasets[i]
model = api.create_model(dataset, model_args, retries=None)
elif args.dataset_off and args.evaluate:
multi_dataset = args.test_dataset_ids[:]
del multi_dataset[i + existing_models]
model = api.create_model(multi_dataset, model_args,
retries=None)
else:
model = api.create_model(datasets, model_args,
retries=None)
model_id = check_resource_error(model,
"Failed to create model: ")
log_message("%s\n" % model_id, log_file=log)
model_ids.append(model_id)
inprogress.append(model_id)
models.append(model)
log_created_resources("models", path, model_id, mode='a')
if args.number_of_models < 2 and args.verbosity:
if bigml.api.get_status(model)['code'] != bigml.api.FINISHED:
try:
model = check_resource(model, api.get_model,
query_string=query_string,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished model: %s" %
str(exception))
models[0] = model
message = dated("Model created: %s\n" %
get_url(model))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, model)
"""Creates remote batch_centroid
"""
if api is None:
api = bigml.api.BigML()
message = dated("Creating batch centroid.\n")
log_message(message, log_file=session_file, console=args.verbosity)
batch_centroid = api.create_batch_centroid(cluster,
test_dataset,
batch_centroid_args,
retries=None)
log_created_resources("batch_centroid", path,
bigml.api.get_batch_centroid_id(batch_centroid),
mode='a')
batch_centroid_id = check_resource_error(
batch_centroid, "Failed to create batch prediction: ")
try:
batch_centroid = check_resource(batch_centroid,
api.get_batch_centroid,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished batch centroid: %s"
% str(exception))
message = dated("Batch centroid created: %s\n"
% get_url(batch_centroid))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % batch_centroid_id, log_file=log)
if args.reports:
report(args.reports, path, batch_centroid)
return batch_centroid
def create_models(datasets, model_ids, model_args,
args, api=None, path=None,
session_file=None, log=None):
"""Create remote models
"""
if api is None:
api = bigml.api.BigML()
models = model_ids[:]
existing_models = len(models)
model_args_list = []
if not args.multi_label:
datasets = datasets[existing_models:]
dataset = datasets[0]
if isinstance(model_args, list):
model_args_list = model_args
if args.number_of_models > 0:
message = dated("Creating %s.\n" %
plural("model", args.number_of_models))
log_message(message, log_file=session_file,
console=args.verbosity)
single_model = args.number_of_models == 1 and existing_models == 0
# if there's more than one model the first one must contain
# the entire field structure to be used as reference.
query_string = (FIELDS_QS if single_model
else ALL_FIELDS_QS)
inprogress = []
for i in range(0, args.number_of_models):
wait_for_available_tasks(inprogress, args.max_parallel_models,
api.get_model, "model",
query_string=query_string)
if model_args_list:
model_args = model_args_list[i]
if args.cross_validation_rate > 0:
new_seed = get_basic_seed(i + existing_models)
model_args.update(seed=new_seed)
# one model per dataset (--max-categories or single model)
if args.max_categories > 0:
dataset = datasets[i]
model = api.create_model(dataset, model_args)
else:
model = api.create_model(datasets, model_args)
model_id = check_resource_error(model, "Failed to create model: ")
log_message("%s\n" % model_id, log_file=log)
model_ids.append(model_id)
inprogress.append(model_id)
models.append(model)
log_created_resources("models", path, model_id, open_mode='a')
if args.number_of_models < 2 and args.verbosity:
if bigml.api.get_status(model)['code'] != bigml.api.FINISHED:
try:
model = check_resource(model, api.get_model,
query_string=query_string)
except ValueError, exception:
sys.exit("Failed to get a finished model: %s" %
str(exception))
models[0] = model
message = dated("Model created: %s.\n" %
get_url(model))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, model)
with open("%s/source%s" % (path, suffix), 'w', 0) as source_file:
source_file.write("%s\n" % source['resource'])
source_file.write("%s\n" % source['object']['name'])
except IOError, exc:
sys.exit("%s: Failed to write %s/source" % (str(exc), path))
source_id = check_resource_error(source, "Failed to create source: ")
try:
source = check_resource(source, api.get_source,
query_string=ALL_FIELDS_QS)
except ValueError, exception:
sys.exit("Failed to get a finished source: %s" % str(exception))
message = dated("Source created: %s\n" % get_url(source))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % source_id, log_file=log)
if args.reports:
report(args.reports, path, source)
return source
def data_to_source(training_set, test_set,
training_set_header, test_set_header, args):
"""Extracts the flags info to create a source object
"""
data_set = None
data_set_header = None
if (training_set and not args.source and not args.dataset and
not args.model and not args.models):
data_set = training_set
data_set_header = training_set_header
elif (args.evaluate and test_set and not args.source):
source_file.write("%s\n" % source['resource'])
source_file.write("%s\n" % source['object']['name'])
except IOError, exc:
sys.exit("%s: Failed to write %s/source" % (str(exc), path))
source_id = check_resource_error(source, "Failed to create source: ")
try:
source = check_resource(source,
api.get_source,
query_string=ALL_FIELDS_QS)
except ValueError, exception:
sys.exit("Failed to get a finished source: %s" % str(exception))
message = dated("Source created: %s\n" % get_url(source))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % source_id, log_file=log)
if args.reports:
report(args.reports, path, source)
return source
def data_to_source(training_set, test_set, training_set_header,
test_set_header, args):
"""Extracts the flags info to create a source object
"""
data_set = None
data_set_header = None
if (training_set and not args.source and not args.dataset
and not args.model and not args.models):
data_set = training_set
data_set_header = training_set_header
elif (args.evaluate and test_set and not args.source):
log=None):
"""Creates remote forecast
"""
if api is None:
api = bigml.api.BigML()
message = dated("Creating remote forecast.\n")
log_message(message, log_file=session_file, console=args.verbosity)
forecast = api.create_forecast(time_series,
input_data,
forecast_args,
retries=None)
log_created_resources("forecast",
path,
bigml.api.get_forecast_id(forecast),
mode='a')
forecast_id = check_resource_error(forecast, "Failed to create forecast: ")
try:
forecast = check_resource(forecast,
api.get_forecast,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished forecast: %s" % str(exception))
message = dated("Forecast created: %s\n" % get_url(forecast))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % forecast_id, log_file=log)
if args.reports:
report(args.reports, path, forecast)
return forecast
"""Creates remote batch topic distribution
"""
if api is None:
api = bigml.api.BigML()
message = dated("Creating batch topic distribution.\n")
log_message(message, log_file=session_file, console=args.verbosity)
batch_topic_distribution = api.create_batch_topic_distribution( \
topic_model, test_dataset, batch_topic_distribution_args, retries=None)
log_created_resources( \
"batch_topic_distribution", path,
bigml.api.get_batch_topic_distribution_id(batch_topic_distribution),
mode='a')
batch_topic_distribution_id = check_resource_error(
batch_topic_distribution,
"Failed to create batch topic distribution: ")
try:
batch_topic_distribution = check_resource( \
batch_topic_distribution, api.get_batch_topic_distribution,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished batch topic distribution: %s" %
str(exception))
message = dated("Batch topic distribution created: %s\n" %
get_url(batch_topic_distribution))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % batch_topic_distribution_id, log_file=log)
if args.reports:
report(args.reports, path, batch_topic_distribution)
return batch_topic_distribution
def create_evaluations(model_ids, datasets, evaluation_args, args, api=None,
path=None, session_file=None, log=None,
existing_evaluations=0):
"""Create evaluations for a list of models
``model_ids``: list of model ids to create an evaluation of
``datasets``: dataset objects or ids to evaluate with
``evaluation_args``: arguments for the ``create_evaluation`` call
``args``: input values for bigmler flags
``api``: api to remote objects in BigML
``path``: directory to store the BigMLer generated files in
``session_file``: file to store the messages of that session
``log``: user provided log file
``existing_evaluations``: evaluations found when attempting resume
"""
evaluations = []
dataset = datasets[0]
evaluation_args_list = []
if isinstance(evaluation_args, list):
evaluation_args_list = evaluation_args
if api is None:
api = bigml.api.BigML()
remaining_ids = model_ids[existing_evaluations:]
number_of_evaluations = len(remaining_ids)
message = dated("Creating evaluations.\n")
log_message(message, log_file=session_file,
console=args.verbosity)
inprogress = []
for i in range(0, number_of_evaluations):
model = remaining_ids[i]
wait_for_available_tasks(inprogress, args.max_parallel_evaluations,
api.get_evaluation, "evaluation")
if evaluation_args_list != []:
evaluation_args = evaluation_args_list[i]
if args.cross_validation_rate > 0:
new_seed = get_basic_seed(i + existing_evaluations)
evaluation_args.update(seed=new_seed)
evaluation = api.create_evaluation(model, dataset, evaluation_args)
evaluation_id = check_resource_error(evaluation,
"Failed to create evaluation: ")
inprogress.append(evaluation_id)
log_created_resources("evaluations", path, evaluation_id,
open_mode='a')
evaluations.append(evaluation)
log_message("%s\n" % evaluation['resource'], log_file=log)
if (args.number_of_evaluations < 2 and len(evaluations) == 1
and args.verbosity):
evaluation = evaluations[0]
if bigml.api.get_status(evaluation)['code'] != bigml.api.FINISHED:
try:
evaluation = check_resource(evaluation, api.get_evaluation)
except ValueError, exception:
sys.exit("Failed to get a finished evaluation: %s" %
str(exception))
evaluations[0] = evaluation
message = dated("Evaluation created: %s.\n" %
get_url(evaluation))
log_message(message, log_file=session_file,
console=args.verbosity)
if args.reports:
report(args.reports, path, evaluation)
"""
if api is None:
api = bigml.api.BigML()
message = dated("Creating batch prediction.\n")
log_message(message, log_file=session_file, console=args.verbosity)
batch_prediction = api.create_batch_prediction(model_or_ensemble,
test_dataset,
batch_prediction_args,
retries=None)
log_created_resources("batch_prediction",
path,
bigml.api.get_batch_prediction_id(batch_prediction),
mode='a')
batch_prediction_id = check_resource_error(
batch_prediction, "Failed to create batch prediction: ")
try:
batch_prediction = check_resource(batch_prediction,
api.get_batch_prediction,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished batch prediction: %s" %
str(exception))
message = dated("Batch prediction created: %s\n" %
get_url(batch_prediction))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % batch_prediction_id, log_file=log)
if args.reports:
report(args.reports, path, batch_prediction)
return batch_prediction
source['resource'],
mode='ab',
comment=(u"%s\n" % source['object']['name']))
source_id = check_resource_error(source, "Failed to create source: ")
try:
source = check_resource(source,
api.get_source,
query_string=ALL_FIELDS_QS,
raise_on_error=True)
except Exception, exception:
sys.exit("Failed to get a finished source: %s" % str(exception))
message = dated("Source created: %s\n" % get_url(source))
log_message(message, log_file=session_file, console=args.verbosity)
log_message("%s\n" % source_id, log_file=log)
if args.reports:
report(args.reports, path, source)
return source
def data_to_source(args):
"""Extracts the flags info to create a source object
"""
data_set = None
data_set_header = None
if (args.training_set and not args.source and not args.dataset
and not args.has_models_):
data_set = args.training_set
data_set_header = args.train_header
elif (hasattr(args, 'evaluate') and args.evaluate and args.test_set
and not args.source):
