def _train_model(args):
UCAIPService.get().create_training_pipeline(
training_pipeline_name=args["pipelineName"],
dataset_id=args["datasetId"],
model_name=args["modelName"],
target_column=args["targetColumn"],
prediction_type=args["predictionType"],
objective=args["objective"],
budget_hours=args["budgetHours"],
transformations=args["transformations"])
return {"success": True}
def _create_tables_dataset(args):
file_source = args.get("fileSource")
if file_source:
decoded = base64.decodebytes(file_source["data"])
UCAIPService.get().create_dataset_from_file(
display_name=args["displayName"],
file_name=file_source["name"],
file_data=decoded)
else:
UCAIPService.get().create_dataset(
display_name=args["displayName"],
gcs_uri=args.get("gcsSource"),
bigquery_uri=args.get("bigquerySource"))
return {"success": True}
def create_training_pipeline(
display_name: str, dataset_id: str, model_name: str, target_column: str,
prediction_type: str, objective: str, budget_hours: int,
transformations: Dict[str, Dict[str, str]]
) -> aiplatform_v1alpha1.TrainingPipeline:
"""Create a simple training pipeline and train a model from a tables dataset on uCAIP
Args:
display_name (str): The user-defined name of the training pipeline
dataset_id (str): ID of the dataset to train from
model_name (str): The user-defined name of the model to create
target_column (str): Name of the target column
prediction_type (str): Type of prediction on the target column, can be "regression" or "classification"
objective (str): Optimization objective.
Supported binary classification optimisation objectives: maximize-au-roc, minimize-log-loss, maximize-au-prc.
Supported multi-class classification optimisation objective: minimize-log-loss.
Supported regression optimization objectives: minimize-rmse, minimize-mae, minimize-rmsle.
budget_hours (int): Budget of node-hours to allocate to train the model
transformations (Dict[str, Dict[str, str]]): Transformations to apply to each column
Returns:
aiplatform_v1alpha1.TrainingPipeline: The newly created training pipeline
"""
return UCAIPService.get().create_training_pipeline(
display_name, dataset_id, model_name, target_column, prediction_type,
objective, budget_hours, transformations)
def import_dataset(dataset_id: str) -> pandas.DataFrame:
"""Import an existing tables dataset to a Pandas DataFrame
Args:
dataset_id (str): ID of the dataset to import
Returns:
pandas.DataFrame
"""
return UCAIPService.get().import_dataset(dataset_id)
def predict(endpoint_id: str, instance: object) -> object:
"""Send a prediction request to a uCAIP model endpoint
Args:
endpoint_id (str): ID of the uCAIP endpoint
instance (object): The prediction instance, should match the input format that the endpoint expects
Returns:
object: Prediction results from the model
"""
return UCAIPService.get().predict_tables(endpoint_id, instance)
def create_dataset(display_name: str,
dataframe: pandas.DataFrame = None,
file_path: str = None,
gcs_uri: str = None,
bigquery_uri: str = None) -> aiplatform_v1alpha1.Dataset:
"""Create a tabular dataset in uCAIP from a given source.
One of dataframe, file_path, gcs_uri or bigquery_uri must be provided.
Args:
display_name (str): The user-defined name of the dataset
dataframe (pandas.DataFrame, optional): Pandas DataFrame to import data from. Defaults to None.
file_path (str, optional): Local file path to import data from. Defaults to None.
gcs_uri (str, optional): URI of csv in GCS to import data from. Defaults to None.
bigquery_uri (str, optional): URI of bigquery table to import data from. Defaults to None.
Raises:
APIError: Raised if no valid source is provided
Returns:
aiplatform_v1alpha1.Dataset: The newly created dataset
"""
if dataframe is not None:
return UCAIPService.get().create_dataset_from_dataframe(
display_name, dataframe)
elif file_path is not None:
file_name = os.path.basename(file_path)
if not os.path.exists(file_path):
raise APIError("File path " + file_path + " not found.")
with open(file_path, "rb") as f:
return UCAIPService.get().create_dataset_from_file(
display_name, file_name, f.read())
elif gcs_uri is not None:
return UCAIPService.get().create_dataset(display_name=display_name,
gcs_uri=gcs_uri)
elif bigquery_uri is not None:
return UCAIPService.get().create_dataset(display_name=display_name,
bigquery_uri=bigquery_uri)
else:
raise APIError(
"One of { dataframe, file_path, gcs_uri, bigquery_uri } must be provided."
)
def export_saved_model(display_name: str, model_path: str,
framework: ModelFramework) -> aiplatform_v1alpha1.Model:
"""Export a custom pretrained model to uCAIP from a folder containing the saved model
Args:
display_name (str): The user-defined name of the model
model_path (str): Local path to the folder containing saved model artifacts (e.g saved_model.pb)
framework (jupyterlab_ucaip.types.ModelFramework): The framework used to train the model
Returns:
aiplatform_v1alpha1.Model: The newly created model
"""
return UCAIPService.get().export_saved_model(display_name, model_path,
framework)
def _get_all_endpoints(args):
return UCAIPService.get().get_all_endpoints()
def _check_deploying(args):
return UCAIPService.get().get_deploying_endpoints(
model_name=args["modelName"], endpoint_id=args["endpointId"])
def _get_endpoints(args):
return UCAIPService.get().get_endpoints(model_id=args["modelId"])
def _get_pipelines(_):
return UCAIPService.get().get_training_pipelines()
def _get_pipeline(args):
return UCAIPService.get().get_training_pipeline(args["pipelineId"])
def _predict_tables(args):
return UCAIPService.get().predict_tables(endpoint_id=args["endpointId"],
instance=args["inputs"])
def _deploy_model(args):
UCAIPService.get().deploy_model(model_id=args["modelId"],
machine_type=args["machineType"],
endpoint_id=args["endpointId"])
return {"success": True}
def _list_datasets(_):
return UCAIPService.get().get_datasets()
def _delete_endpoint(args):
UCAIPService.get().delete_endpoint(endpoint_id=args["endpointId"])
return {"success": True}
def _delete_model(args):
UCAIPService.get().model_client.delete_model(name=args["modelId"])
return {"success": True}
def _delete_dataset(args):
UCAIPService.get().dataset_client.delete_dataset(name=args["datasetId"])
return {"success": True}
def deploy_model(model_id: str,
machine_type: str,
min_replicas: int = 1,
endpoint_id: str = None):
return UCAIPService.get().deploy_model(model_id, machine_type, min_replicas,
endpoint_id)
def _check_deploying(args):
return UCAIPService.get().check_deploying(model_name=args["modelName"])
def _deploy_model(args):
UCAIPService.get().deploy_model(model_id=args["modelId"])
return {"success": True}
def _list_model_evaluations(args):
return UCAIPService.get().get_model_evaluation(args["modelId"])
def _get_dataset_details(args):
return UCAIPService.get().get_dataset_details(args["datasetId"])
def _undeploy_model(args):
UCAIPService.get().undeploy_model(
deployed_model_id=args["deployedModelId"],
endpoint_id=args["endpointId"])
return {"success": True}
def _list_models(_):
return UCAIPService.get().get_models()
def _table_info(args):
return UCAIPService.get().get_table_specs(args["datasetId"])
