merlin package

merlin.set_url(url: str, use_google_oauth: bool = True)

Set Merlin URL

Parameters:url – Merlin URL

merlin.get_url() → Optional[str]

Get currently active Merlin URL

Returns:merlin url if set, otherwise None

merlin.list_project() → List[merlin.model.Project]

List all project in MLP

Returns:list of project

merlin.set_project(project_name: str)

Set active project

Parameters:project_name – project name. If project_name is not found, it will create the project.

merlin.active_project() → Optional[merlin.model.Project]

Get current active project

Returns:active project

merlin.list_environment() → List[merlin.environment.Environment]

List all available environment for deployment

Returns:List[Environment]

merlin.get_environment(env_name: str) → merlin.environment.Environment

Get environment for given env name

Returns:Environment or None

merlin.get_default_environment() → Optional[merlin.environment.Environment]

Get default environment

Returns:Environment or None

merlin.set_model(model_name, model_type: merlin.model.ModelType = None)

Set active model

Parameters:

• model_name – model name to be set as active model. If model name is not found, it will create the model.
• model_type – type of the model

Returns:

merlin.active_model() → Optional[merlin.model.Model]

Get active model

Returns:active model

merlin.new_model_version()

Create new model version under currently active model

Returns:ModelVersion

merlin.log_param(key: str, value: str)

Log parameter to the active model version

Parameters:

• key – parameter key
• value – parameter value

merlin.log_metric(key: str, value: float)

Log a metric to the active model version

Parameters:

• key – metric key
• value – metric value

merlin.set_tag(key: str, value: str)

Set tag in the active model version

Parameters:

• key – tag name
• value – tag value

merlin.delete_tag(key: str)

Delete tag from the active model version

Parameters:key – tag name

merlin.log_artifact(local_path: str, artifact_path: str = None)

Log artifacts for the active model version

Parameters:

• local_path – directory to be uploaded into artifact store
• artifact_path – destination directory in artifact store

merlin.log_pyfunc_model(model_instance: Any, conda_env: str, code_dir: List[str] = None, artifacts: Dict[str, str] = None)

Upload PyFunc based model into artifact storage.

User has to specify model_instance and conda_env. model_instance shall implement all method specified in PyFuncModel. conda_env shall contain all dependency required by the model

Parameters:

• model_instance – instance of python function model
• conda_env – path to conda env.yaml file
• code_dir – additional code directory that will be loaded with ModelType.PYFUNC model
• code_dir – additional code directory to be uploaded
• artifacts – dictionary of artifact that will be stored together with the model. This will be passed to PythonModel.initialize. Example: {“config”: “config/staging.yaml”}

merlin.log_pytorch_model(model_dir: str, model_class_name: str = None)

Upload PyTorch model to artifact storage.

Parameters:

• model_dir – directory containing serialized PyTorch model
• model_class_name – class name of PyTorch model. By default the model class name is ‘PyTorchModel’

merlin.log_model(model_dir)

Upload model to artifact storage. This method is used to upload model for xgboost, tensorflow, and sklearn model.

Parameters:model_dir – directory which contain serialized model

merlin.deploy(model_version: merlin.model.ModelVersion = None, environment_name: str = None, resource_request: merlin.resource_request.ResourceRequest = None, env_vars: Dict[str, str] = None) → merlin.endpoint.VersionEndpoint

Deploy a model version.

Parameters:model_version – If model_version is not given it will deploy active model version Returns:VersionEndpoint

merlin.undeploy(model_version=None, environment_name: str = None)

Delete deployment of a model version.

Parameters:model_version – model version to be undeployed. If model_version is not given it will undeploy active model version

merlin.set_traffic(traffic_rule: Dict[merlin.model.ModelVersion, int]) → merlin.endpoint.ModelEndpoint

Update traffic rule of the active model.

Parameters:traffic_rule – dict of model version and the percentage of traffic. Returns:ModelEndpoint

merlin.serve_traffic(traffic_rule: Dict[VersionEndpoint, int], environment_name: str = None) → merlin.endpoint.ModelEndpoint

Update traffic rule of the active model.

Parameters:

• traffic_rule – dict of version endpoint and the percentage of traffic.
• environment_name – environment in which the traffic rule shall be applied

Returns:

ModelEndpoint

class merlin.ResourceRequest(min_replica: int, max_replica: int, cpu_request: str, memory_request: str)

Bases: object

The resource requirement and replicas requests for model version endpoint.

cpu_request

max_replica

memory_request

min_replica

validate()

merlin.create_prediction_job(job_config: merlin.batch.config.PredictionJobConfig, sync: bool = True) → client.models.prediction_job.PredictionJob

Parameters:

• sync –
• job_config –

Returns:

Subpackages

• merlin.batch package
  • Submodules
  • merlin.batch.big_query_util module
  • merlin.batch.config module
  • merlin.batch.job module
  • merlin.batch.sink module
  • merlin.batch.source module
• merlin.docker package
  • Submodules
  • merlin.docker.docker module

Submodules

merlin.client module

class merlin.client.MerlinClient(merlin_url: str, use_google_oauth: bool = True)

Bases: object

deploy(model_version: merlin.model.ModelVersion, environment_name: str = None, resource_request: merlin.resource_request.ResourceRequest = None, env_vars: Dict[str, str] = None) → merlin.endpoint.VersionEndpoint

get_default_environment() → Optional[merlin.environment.Environment]

Return default environment

Returns:Environment or None

get_environment(env_name: str) → Optional[merlin.environment.Environment]

Get environment for given env name

Returns:Environment or None

get_model(model_name: str, project_name: str) → Optional[merlin.model.Model]

Get model with given name

Parameters:

• model_name – model name to be retrieved
• project_name – project name

Returns:

Model or None

get_or_create_model(model_name: str, project_name: str, model_type: merlin.model.ModelType = None) → merlin.model.Model

Get or create a model under a project

If project_name is not given it will use currently active project otherwise will raise Exception

Parameters:

• model_type –
• model_name – model name
• project_name – project name (optional)
• model_type – model type

Returns:

Model

get_or_create_project(project_name: str) → merlin.model.Project

get_project(project_name: str) → merlin.model.Project

Get a project in Merlin and optionally assign list of readers and administrators. The identity used for creating the project will be automatically included as project’s administrators.

Parameters:project_name – project name Returns:project

list_environment() → List[merlin.environment.Environment]

List all available environment for deployment

Returns:list of Environment

list_project() → List[merlin.model.Project]

List project in the connected MLP server

Returns:list of Project

new_model_version(model_name: str, project_name: str) → merlin.model.ModelVersion

Create new model version for the given model and project

Parameters:

• model_name –
• project_name –

Returns:

undeploy(model_version: merlin.model.ModelVersion, environment_name: str = None)

url

merlin.endpoint module

class merlin.endpoint.ModelEndpoint(endpoint: client.models.model_endpoint.ModelEndpoint)

Bases: object

environment

environment_name

id

status

url

class merlin.endpoint.Status

Bases: enum.Enum

An enumeration.

FAILED = 'failed'

PENDING = 'pending'

RUNNING = 'running'

SERVING = 'serving'

TERMINATED = 'terminated'

class merlin.endpoint.VersionEndpoint(endpoint: client.models.version_endpoint.VersionEndpoint, log_url: str = None)

Bases: object

env_vars

environment

environment_name

id

log_url

status

url

merlin.environment module

class merlin.environment.Environment(env: client.models.environment.Environment)

Bases: object

cluster

default_resource_request

is_default

name

merlin.fluent module

merlin.fluent.active_model() → Optional[merlin.model.Model]

Get active model

Returns:active model

merlin.fluent.active_project() → Optional[merlin.model.Project]

Get current active project

Returns:active project

merlin.fluent.create_prediction_job(job_config: merlin.batch.config.PredictionJobConfig, sync: bool = True) → client.models.prediction_job.PredictionJob

Parameters:

• sync –
• job_config –

Returns:

merlin.fluent.delete_tag(key: str)

Delete tag from the active model version

Parameters:key – tag name

merlin.fluent.deploy(model_version: merlin.model.ModelVersion = None, environment_name: str = None, resource_request: merlin.resource_request.ResourceRequest = None, env_vars: Dict[str, str] = None) → merlin.endpoint.VersionEndpoint

Deploy a model version.

Parameters:model_version – If model_version is not given it will deploy active model version Returns:VersionEndpoint

merlin.fluent.download_artifact(destination_path: str)

Download artifact from the active model version

Parameters:destination_path – destination of file when downloaded

merlin.fluent.get_default_environment() → Optional[merlin.environment.Environment]

Get default environment

Returns:Environment or None

merlin.fluent.get_environment(env_name: str) → merlin.environment.Environment

Get environment for given env name

Returns:Environment or None

merlin.fluent.get_metric(key: str) → Optional[float]

Get metric value from the active model version

Parameters:key – metric name

merlin.fluent.get_param(key: str) → Optional[str]

Get param value from the active model version

Parameters:key – param name

merlin.fluent.get_tag(key: str) → Optional[str]

Get tag value from the active model version

Parameters:key – tag name

merlin.fluent.get_url() → Optional[str]

Get currently active Merlin URL

Returns:merlin url if set, otherwise None

merlin.fluent.list_environment() → List[merlin.environment.Environment]

List all available environment for deployment

Returns:List[Environment]

merlin.fluent.list_model_endpoints() → List[merlin.endpoint.ModelEndpoint]

Get list of all serving model endpoints.

Returns:List of model endpoints.

merlin.fluent.list_project() → List[merlin.model.Project]

List all project in MLP

Returns:list of project

merlin.fluent.list_tag() → Dict[str, str]

Get list of tag from the active model version

merlin.fluent.log_artifact(local_path: str, artifact_path: str = None)

Log artifacts for the active model version

Parameters:

• local_path – directory to be uploaded into artifact store
• artifact_path – destination directory in artifact store

merlin.fluent.log_metric(key: str, value: float)

Log a metric to the active model version

Parameters:

• key – metric key
• value – metric value

merlin.fluent.log_model(model_dir)

Upload model to artifact storage. This method is used to upload model for xgboost, tensorflow, and sklearn model.

Parameters:model_dir – directory which contain serialized model

merlin.fluent.log_param(key: str, value: str)

Log parameter to the active model version

Parameters:

• key – parameter key
• value – parameter value

merlin.fluent.log_pyfunc_model(model_instance: Any, conda_env: str, code_dir: List[str] = None, artifacts: Dict[str, str] = None)

Upload PyFunc based model into artifact storage.

User has to specify model_instance and conda_env. model_instance shall implement all method specified in PyFuncModel. conda_env shall contain all dependency required by the model

Parameters:

• model_instance – instance of python function model
• conda_env – path to conda env.yaml file
• code_dir – additional code directory that will be loaded with ModelType.PYFUNC model
• code_dir – additional code directory to be uploaded
• artifacts – dictionary of artifact that will be stored together with the model. This will be passed to PythonModel.initialize. Example: {“config”: “config/staging.yaml”}

merlin.fluent.log_pytorch_model(model_dir: str, model_class_name: str = None)

Upload PyTorch model to artifact storage.

Parameters:

• model_dir – directory containing serialized PyTorch model
• model_class_name – class name of PyTorch model. By default the model class name is ‘PyTorchModel’

merlin.fluent.new_model_version()

Create new model version under currently active model

Returns:ModelVersion

merlin.fluent.serve_traffic(traffic_rule: Dict[VersionEndpoint, int], environment_name: str = None) → merlin.endpoint.ModelEndpoint

Update traffic rule of the active model.

Parameters:

• traffic_rule – dict of version endpoint and the percentage of traffic.
• environment_name – environment in which the traffic rule shall be applied

Returns:

ModelEndpoint

merlin.fluent.set_model(model_name, model_type: merlin.model.ModelType = None)

Set active model

Parameters:

• model_name – model name to be set as active model. If model name is not found, it will create the model.
• model_type – type of the model

Returns:

merlin.fluent.set_project(project_name: str)

Set active project

Parameters:project_name – project name. If project_name is not found, it will create the project.

merlin.fluent.set_tag(key: str, value: str)

Set tag in the active model version

Parameters:

• key – tag name
• value – tag value

merlin.fluent.set_traffic(traffic_rule: Dict[merlin.model.ModelVersion, int]) → merlin.endpoint.ModelEndpoint

Update traffic rule of the active model.

Parameters:traffic_rule – dict of model version and the percentage of traffic. Returns:ModelEndpoint

merlin.fluent.set_url(url: str, use_google_oauth: bool = True)

Set Merlin URL

Parameters:url – Merlin URL

merlin.fluent.stop_serving_traffic(environment_name: str = None)

Stop serving traffic for a given model endpoint in given environment.

Parameters:environment_name – environment in which the model endpoint will be stopped.

merlin.fluent.undeploy(model_version=None, environment_name: str = None)

Delete deployment of a model version.

Parameters:model_version – model version to be undeployed. If model_version is not given it will undeploy active model version

merlin.merlin module

merlin.model module

class merlin.model.Model(model: client.models.model.Model, project: merlin.model.Project, api_client: client.api_client.ApiClient)

Bases: object

Model representation

created_at

endpoint

Get endpoint of this model that is deployed in default environment

Returns:Endpoint if exist, otherwise None

get_version(id: int) → Optional[merlin.model.ModelVersion]

Get version with specific ID

Parameters:id – version id to retrieve Returns:

id

list_endpoint() → List[merlin.endpoint.ModelEndpoint]

List all model endpoint assosiated with this model

Returns:List[ModelEndpoint]

list_version() → List[merlin.model.ModelVersion]

List all version of the model List all version of the model

Returns:list of ModelVersion

mlflow_experiment_id

mlflow_url

name

new_model_version() → merlin.model.ModelVersion

Create a new version of this model

Returns:new ModelVersion

project

serve_traffic(traffic_rule: Dict[VersionEndpoint, int], environment_name: str = None) → merlin.endpoint.ModelEndpoint

Set traffic rule for this model.

Parameters:

• traffic_rule – dict of version endpoint and the percentage of traffic.
• environment_name – target environment in which the model endpoint will be created. If left empty it will create in default environment.

Returns:

ModelEndpoint

set_traffic(traffic_rule: Dict[ModelVersion, int]) → merlin.endpoint.ModelEndpoint

Set traffic rule for this model.

This method is deprecated, use serve_traffic instead

Parameters:traffic_rule – dict of model version and the percentage of traffic. Returns:ModelEndpoint

stop_serving_traffic(environment_name: str = None)

Stop serving traffic for this model in given environment.

Parameters:environment_name – environment name in which the endpoint should be stopped from serving traffic. If environment_name is empty it will attempt to undeploy the model from default environment.

type

updated_at

class merlin.model.ModelType

Bases: enum.Enum

Model type supported by merlin

ONNX = 'onnx'

PYFUNC = 'pyfunc'

PYFUNC_V2 = 'pyfunc_v2'

PYTORCH = 'pytorch'

SKLEARN = 'sklearn'

TENSORFLOW = 'tensorflow'

XGBOOST = 'xgboost'

class merlin.model.ModelVersion(version: client.models.version.Version, model: merlin.model.Model, api_client: client.api_client.ApiClient)

Bases: object

Representation of version in a model

MODEL_TYPE_TO_IMAGE_MAP = {<ModelType.SKLEARN: 'sklearn'>: 'gcr.io/kfserving/sklearnserver:0.2.2', <ModelType.TENSORFLOW: 'tensorflow'>: 'tensorflow/serving:1.14.0', <ModelType.XGBOOST: 'xgboost'>: 'gcr.io/kfserving/xgbserver:0.2.2', <ModelType.PYTORCH: 'pytorch'>: 'gcr.io/kfserving/pytorchserver:0.2.2'}

artifact_uri

create_prediction_job(job_config: merlin.batch.config.PredictionJobConfig, sync: bool = True) → merlin.batch.job.PredictionJob

Create and run prediction job with given config using this model version

Parameters:

• sync – boolean to set synchronicity of job. The default is set to True.
• job_config – prediction job config

Returns:

prediction job

created_at

delete_tag(key)

Delete tag in a model version

Parameters:key – Returns:

deploy(environment_name: str = None, resource_request: merlin.resource_request.ResourceRequest = None, env_vars: Dict[str, str] = None) → merlin.endpoint.VersionEndpoint

Deploy current model to MLP One of log_model, log_pytorch_model, and log_pyfunc_model has to be called beforehand

Parameters:

• environment_name – target environment to which the model version will be deployed to. If left empty it will deploy to default environment.
• resource_request – The resource requirement and replicas requests for model version endpoint.

Returns:

Endpoint object

download_artifact(destination_path)

Download artifact

Parameters:destination_path – Returns:

endpoint

Return endpoint of this model version that is deployed in default environment

Returns:Endpoint or None

finish()

Finalize a model version

Returns:

get_metric(key) → Optional[float]

Get metric value from metric name(key)

Parameters:key – Return value:

get_param(key) → Optional[str]

Get param value for specific param name(key)

Parameters:key – Return value:

get_run() → Optional[mlflow.entities.run.Run]

Get MLFlow Run in a model version

get_run_data() → Optional[mlflow.entities.run_data.RunData]

get_tag(key) → Optional[str]

Get tag value from name(key)

Parameters:key – Return value:

id

list_endpoint() → List[merlin.endpoint.VersionEndpoint]

Return all endpoint deployment for this particular model version

Returns:List of VersionEndpoint

list_prediction_job() → List[merlin.batch.job.PredictionJob]

List all prediction job created from the model version

Returns:list of prediction jobs

list_tag() → Dict[str, str]

Get all tags

Return list of tags:  

log_artifact(local_path, artifact_path=None)

Log artifact

Parameters:

• local_path –
• artifact_path –

Returns:

log_artifacts(local_dir, artifact_path=None)

Log artifacts

Parameters:

• local_dir –
• artifact_path –

Returns:

log_metric(key, value)

Log a metric to model version

Parameters:

• key –
• value –

Returns:

log_model(model_dir=None)

Upload model to artifact storage. This method is used to upload model for xgboost, tensorflow, and sklearn model.

Parameters:model_dir – directory which contain serialized model

log_param(key, value)

Log param to a model version

Parameters:

• key –
• value –

Returns:

log_pyfunc_model(model_instance, conda_env, code_dir=None, artifacts=None)

Upload PyFunc based model into artifact storage. User has to specify model_instance and conda_env. model_instance shall implement all method specified in PyFuncModel. conda_env shall contain all dependency required by the model

Parameters:

• model_instance – instance of python function model
• conda_env – path to conda env.yaml file
• code_dir – additional code directory that will be loaded with ModelType.PYFUNC model
• artifacts – dictionary of artifact that will be stored together with the model. This will be passed to PythonModel.initialize. Example: {“config” : “config/staging.yaml”}

log_pytorch_model(model_dir, model_class_name=None)

Upload PyTorch model to artifact storage.

Parameters:

• model_dir – directory containing serialized PyTorch model
• model_class_name – class name of PyTorch model. By default the model class name is ‘PyTorchModel’

mlflow_run_id

mlflow_url

model

properties

set_tag(key, value)

Set tag in a model version

Parameters:

• key –
• value –

Returns:

start()

Start a model version

Returns:

start_server(env_vars: Dict[str, str] = None, port: int = 8080, pyfunc_base_image: str = None, kill_existing_server: bool = False, tmp_dir: Optional[str] = None, build_image: bool = False)

Start a local server running the model version

Parameters:

• env_vars – dictionary of environment variables to be passed to the server
• port – host port that will be used to expose model server
• pyfunc_base_image – (optional, default=None) docker image to be used as base image for building pyfunc model
• kill_existing_server – (optional, default=False) kill existing server if has been started previously
• tmp_dir – (optional, default=None) specify base path for storing model artifact
• build_image – (optional, default=False) build image for standard model instead of directly mounting the model artifact to model container

Returns:

undeploy(environment_name: str = None)

Delete deployment of the model version

Parameters:environment_name – environment name in which the endpoint should be undeployed from. If environment_name is empty it will attempt to undeploy the model from default environment

updated_at

url

class merlin.model.Project(project: client.models.project.Project, mlp_url: str, api_client: client.api_client.ApiClient)

Bases: object

administrators

create_secret(name: str, data: str)

Create a secret within the project

Parameters:

• name – secret name
• data – secret data

Returns:

created_at

delete_secret(name: str)

Delete secret with given name

Parameters:name – secret to be removed Returns:

get_or_create_model(model_name: str, model_type: Optional[merlin.model.ModelType] = None) → merlin.model.Model

Get or create a model with given name

Parameters:

• model_name – model name
• model_type – type of model, mandatory when creation is needed

Returns:

Model instance

id

list_model() → List[merlin.model.Model]

List all model available within the project :return: list of Model

list_secret() → List[str]

List all secret name within the project

Returns:

mlflow_tracking_url

name

readers

update_secret(name: str, data: str)

Update secret with given name

Parameters:

• name – secret name
• data – new secret data

Returns:

updated_at

url

class merlin.model.PyFuncModel

Bases: mlflow.pyfunc.model.PythonModel

infer(request: dict, **kwargs) → dict

Do inference This method MUST be implemented by concrete implementation of PyFuncModel. This method accept ‘request’ which is the body content of incoming request. Implementation should return inference a json object of response.

Parameters:

• request – Dictionary containing incoming request body content
• **kwargs –

  See below.

Returns:

Dictionary containing response body

Keyword Arguments:  

arguments –

• headers (dict): Dictionary containing incoming HTTP request headers

initialize(artifacts: dict)

Implementation of PyFuncModel can specify initialization step which will be called one time during model initialization.

Parameters:artifacts – dictionary of artifacts passed to log_model method

load_context(context)

Loads artifacts from the specified PythonModelContext that can be used by predict() when evaluating inputs. When loading an MLflow model with load_pyfunc(), this method is called as soon as the PythonModel is constructed.

The same PythonModelContext will also be available during calls to predict(), but it may be more efficient to override this method and load artifacts from the context at model load time.

Parameters:context – A PythonModelContext instance containing artifacts that the model can use to perform inference.

predict(model_input, **kwargs)

Evaluates a pyfunc-compatible input and produces a pyfunc-compatible output. For more information about the pyfunc input/output API, see the pyfunc-inference-api.

Parameters:

• context – A PythonModelContext instance containing artifacts that the model can use to perform inference.
• model_input – A pyfunc-compatible input for the model to evaluate.

class merlin.model.PyFuncV2Model

Bases: mlflow.pyfunc.model.PythonModel

infer(model_input: pandas.core.frame.DataFrame) → Union[numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame]

Infer method is the main method that will be called when calculating the inference result for both online prediction and batch prediction. The method accepts pandas Dataframe and returns either another panda Dataframe / pandas Series / ndarray of the same length as the input. In the batch prediction case the model_input will contain an arbitrary partition of the whole dataset that the user defines as the data source. As such, it is advisable not to do aggregation within the infer method, as it will be incorrect since it will only apply to the partition in contrary to the whole dataset.

Parameters:model_input – input to the model (pandas.DataFrame) Returns:inference result as numpy.ndarray or pandas.Series or pandas.DataFrame

initialize(artifacts: dict)

Implementation of PyFuncModel can specify initialization step which will be called one time during model initialization.

Parameters:artifacts – dictionary of artifacts passed to log_model method

load_context(context)

Loads artifacts from the specified PythonModelContext that can be used by predict() when evaluating inputs. When loading an MLflow model with load_pyfunc(), this method is called as soon as the PythonModel is constructed.

The same PythonModelContext will also be available during calls to predict(), but it may be more efficient to override this method and load artifacts from the context at model load time.

Parameters:context – A PythonModelContext instance containing artifacts that the model can use to perform inference.

postprocess(model_result: Union[numpy.ndarray, pandas.core.series.Series, pandas.core.frame.DataFrame]) → dict

Postprocess prediction result returned by infer method into dictionary representing the response body of the model. This method will not be called during batch prediction.

Parameters:model_result – output of the model’s infer method Returns:dictionary containing the response body

predict(context, model_input)

Evaluates a pyfunc-compatible input and produces a pyfunc-compatible output. For more information about the pyfunc input/output API, see the pyfunc-inference-api.

Parameters:

• context – A PythonModelContext instance containing artifacts that the model can use to perform inference.
• model_input – A pyfunc-compatible input for the model to evaluate.

preprocess(request: dict) → pandas.core.frame.DataFrame

Preprocess incoming request into a pandas Dataframe that will be passed to the infer method. This method will not be called during batch prediction.

Parameters:request – dictionary representing the incoming request body Returns:pandas.DataFrame that will be passed to infer method

raw_infer(request: dict) → dict

Do inference This method MUST be implemented by concrete implementation of PyFuncV2Model. This method accept ‘request’ which is the body content of incoming request. This method will not be called during batch prediction.

Implementation should return inference a json object of response.

Parameters:request – Dictionary containing incoming request body content Returns:Dictionary containing response body

merlin.resource_request module

class merlin.resource_request.ResourceRequest(min_replica: int, max_replica: int, cpu_request: str, memory_request: str)

Bases: object

The resource requirement and replicas requests for model version endpoint.

cpu_request

max_replica

memory_request

min_replica

validate()

merlin.util module

merlin.util.autostr(cls)

merlin.util.download_files_from_gcs(gcs_uri: str, destination_path: str)

merlin.util.get_bucket_name(gcs_uri: str) → str

merlin.util.get_gcs_path(gcs_uri: str) → str

merlin.util.guess_mlp_ui_url(mlp_api_url: str) → str

merlin.util.valid_name_check(input_name: str) → bool

Checks if inputted name for project and model is url-friendly

• has to be lower case
• can only contain character (a-z) number (0-9) and some limited symbols

merlin.validation module

merlin.validation.validate_model_dir(input_model_type, target_model_type, model_dir)

Validates user-provided model directory based on file structure. For tensorflow models, checking is only done on the subdirectory with the largest version number.

Parameters:

• input_model_type – type of given model
• target_model_type – type of supposed model, dependent on log_<model type>(…)
• model_dir – directory containing serialised model file

merlin.version module