def create(self, req, body):
"""Creates a new experiment."""
context = req.environ['meteos.context']
if not self.is_valid_body(body, 'experiment'):
raise exc.HTTPUnprocessableEntity()
experiment = body['experiment']
LOG.debug("Create experiment with request: %s", experiment)
try:
template = self.engine_api.get_template(context,
experiment['template_id'])
utils.is_valid_status(template.__class__.__name__, template.status,
constants.STATUS_AVAILABLE)
except exception.NotFound:
raise exc.HTTPNotFound()
except exception.InvalidStatus:
raise
display_name = experiment.get('display_name')
display_description = experiment.get('display_description')
template_id = experiment.get('template_id')
key_name = experiment.get('key_name')
neutron_management_network = experiment.get(
'neutron_management_network')
new_experiment = self.engine_api.create_experiment(
context, display_name, display_description, template_id, key_name,
neutron_management_network)
return self._view_builder.detail(req, new_experiment)
def delete_experiment(self, context, id, force=False):
"""Delete experiment."""
policy.check_policy(context, 'experiment', 'delete')
experiment = self.db.experiment_get(context, id)
utils.is_valid_status(experiment.__class__.__name__,
experiment['status'], DELETE_VALID_STATUSES)
self.engine_rpcapi.delete_experiment(context, id)
def delete_template(self, context, id, force=False):
"""Delete template."""
policy.check_policy(context, 'template', 'delete')
template = self.db.template_get(context, id)
utils.is_valid_status(template.__class__.__name__, template['status'],
DELETE_VALID_STATUSES)
self.engine_rpcapi.delete_template(context, id)
def delete_model(self, context, id, force=False, recreate=False):
"""Delete model."""
policy.check_policy(context, 'model', 'delete')
model = self.db.model_get(context, id)
utils.is_valid_status(model.__class__.__name__, model['status'],
DELETE_VALID_STATUSES)
self.engine_rpcapi.delete_model(context, model['cluster_id'],
model['job_id'], id, recreate)
def delete_dataset(self, context, id, force=False):
"""Delete dataset."""
policy.check_policy(context, 'dataset', 'delete')
dataset = self.db.dataset_get(context, id)
utils.is_valid_status(dataset.__class__.__name__, dataset['status'],
DELETE_VALID_STATUSES)
self.engine_rpcapi.delete_dataset(context, dataset['cluster_id'],
dataset['job_id'], id)
def delete_learning(self, context, id, force=False):
"""Delete learning."""
policy.check_policy(context, 'learning', 'delete')
learning = self.db.learning_get(context, id)
utils.is_valid_status(learning.__class__.__name__, learning['status'],
DELETE_VALID_STATUSES)
if learning.job_id:
self.engine_rpcapi.delete_learning(context, learning['cluster_id'],
learning['job_id'], id)
else:
self.db.learning_delete(context, id)
def create(self, req, body):
"""Creates a new dataset."""
context = req.environ['meteos.context']
if not self.is_valid_body(body, 'dataset'):
raise exc.HTTPUnprocessableEntity()
dataset = body['dataset']
LOG.debug("Create dataset with request: %s", dataset)
try:
experiment = self.engine_api.get_experiment(
context, dataset['experiment_id'])
utils.is_valid_status(experiment.__class__.__name__,
experiment.status,
constants.STATUS_AVAILABLE)
template = self.engine_api.get_template(context,
experiment.template_id)
except exception.NotFound:
raise exc.HTTPNotFound()
except exception.InvalidStatus:
raise
display_name = dataset.get('display_name')
display_description = dataset.get('display_description')
method = dataset.get('method')
experiment_id = dataset.get('experiment_id')
source_dataset_url = dataset.get('source_dataset_url')
params = dataset.get('params')
swift_tenant = dataset.get('swift_tenant')
swift_username = dataset.get('swift_username')
swift_password = dataset.get('swift_password')
percent_train = dataset.get('percent_train', '0.7')
percent_test = dataset.get('percent_test', '0.3')
if (method == 'split'
and not float(percent_train) + float(percent_test) == 1.0):
raise exc.HTTPUnprocessableEntity()
new_dataset = self.engine_api.create_dataset(
context, display_name, display_description, method,
source_dataset_url, params, template.id, template.job_template_id,
experiment_id, experiment.cluster_id, swift_tenant, swift_username,
swift_password, percent_train, percent_test)
return self._view_builder.detail(req, new_dataset)
def delete_model_evaluation(self, context, id, force=False):
"""Delete model evaluation."""
policy.check_policy(context, 'model_evaluation', 'delete')
model_evaluation = self.db.model_evaluation_get(context, id)
utils.is_valid_status(model_evaluation.__class__.__name__,
model_evaluation['status'],
DELETE_VALID_STATUSES)
if model_evaluation.job_id:
self.engine_rpcapi\
.delete_model_evaluation(context,
model_evaluation['cluster_id'],
model_evaluation['job_id'],
id)
else:
self.db.model_evaluation_delete(context, id)
def create(self, req, body):
"""Creates a new model evaluation."""
context = req.environ['meteos.context']
if not self.is_valid_body(body, 'model_evaluation'):
raise exc.HTTPUnprocessableEntity()
model_evaluation = body['model_evaluation']
LOG.debug("Create model evaluation with request: %s", model_evaluation)
display_name = model_evaluation.get('display_name')
model_id = model_evaluation.get('model_id')
source_dataset_url = model_evaluation.get('source_dataset_url')
swift_tenant = model_evaluation.get('swift_tenant')
swift_username = model_evaluation.get('swift_username')
swift_password = model_evaluation.get('swift_password')
try:
model = self.engine_api.get_model(context, model_id)
utils.is_valid_status(model.__class__.__name__, model.status,
constants.STATUS_AVAILABLE)
experiment = self.engine_api.get_experiment(
context, model.experiment_id)
utils.is_valid_status(experiment.__class__.__name__,
experiment.status,
constants.STATUS_AVAILABLE)
template = self.engine_api.get_template(context,
experiment.template_id)
except exception.NotFound:
raise exc.HTTPNotFound()
except exception.InvalidStatus:
raise
new_model_evaluation = self.engine_api.create_model_evaluation(
context, display_name, source_dataset_url, model_id,
model.model_type, model.dataset_format, template.id,
template.job_template_id, model.experiment_id,
experiment.cluster_id, swift_tenant, swift_username,
swift_password)
return self._view_builder.detail(req, new_model_evaluation)
def create(self, req, body):
"""Creates a new learning."""
context = req.environ['meteos.context']
if not self.is_valid_body(body, 'learning'):
raise exc.HTTPUnprocessableEntity()
learning = body['learning']
LOG.debug("Create learning with request: %s", learning)
display_name = learning.get('display_name')
display_description = learning.get('display_description')
model_id = learning.get('model_id')
method = learning.get('method')
args = learning.get('args')
try:
model = self.engine_api.get_model(context, model_id)
utils.is_valid_status(
model.__class__.__name__, model.status,
(constants.STATUS_AVAILABLE, constants.STATUS_ACTIVE))
experiment = self.engine_api.get_experiment(
context, model.experiment_id)
utils.is_valid_status(experiment.__class__.__name__,
experiment.status,
constants.STATUS_AVAILABLE)
template = self.engine_api.get_template(context,
experiment.template_id)
except exception.NotFound:
raise exc.HTTPNotFound()
except exception.InvalidStatus:
raise
new_learning = self.engine_api.create_learning(
context, display_name, display_description, model.status, model_id,
method, model.model_type, model.dataset_format, args, template.id,
template.job_template_id, model.experiment_id,
experiment.cluster_id)
return self._view_builder.detail(req, new_learning)
def _recreate(self, req, id, body):
"""Recreate model with new Dataset"""
context = req.environ['meteos.context']
if not self.is_valid_body(body, 'os-recreate'):
raise exc.HTTPUnprocessableEntity()
b_model = body['os-recreate']
LOG.debug("Recreate model with request: %s", b_model)
try:
model = self.engine_api.get_model(context, id)
utils.is_valid_status(model.__class__.__name__, model.status,
constants.STATUS_AVAILABLE)
experiment = self.engine_api.get_experiment(
context, model.experiment_id)
template = self.engine_api.get_template(context,
experiment.template_id)
except exception.NotFound:
raise exc.HTTPNotFound()
display_name = b_model.get('display_name')
display_description = b_model.get('display_description')
source_dataset_url = b_model.get('source_dataset_url')
dataset_format = b_model.get('dataset_format', 'csv')
model_type = b_model.get('model_type')
model_params = b_model.get('model_params')
swift_tenant = b_model.get('swift_tenant')
swift_username = b_model.get('swift_username')
swift_password = b_model.get('swift_password')
new_model = self.engine_api.recreate_model(
id, context, display_name, display_description, source_dataset_url,
dataset_format, model_type, model_params, template.id,
template.job_template_id, experiment.id, experiment.cluster_id,
swift_tenant, swift_username, swift_password)
return self._view_builder.detail(req, new_model)
def _load(self, req, id, body):
"""Load model for online prediction"""
context = req.environ['meteos.context']
LOG.debug("Load model with request: %s", id)
try:
model = self.engine_api.get_model(context, id)
utils.is_valid_status(model.__class__.__name__, model.status,
constants.STATUS_AVAILABLE)
experiment = self.engine_api.get_experiment(
context, model.experiment_id)
template = self.engine_api.get_template(context,
experiment.template_id)
except exception.NotFound:
raise exc.HTTPNotFound()
self.engine_api.load_model(context, id, model.dataset_format,
model.model_type, template.job_template_id,
model.experiment_id, model.cluster_id)
return {'model': {'id': id}}
