def create_resnet_image_config(conda_file="img_env.yml",
execution_script="driver.py"):
"""
:param conda_file:
:param execution_script:
:return:
"""
conda_pack = ["tensorflow-gpu==1.14.0"]
requirements = [
"keras==2.2.0", "Pillow==5.2.0", "azureml-defaults",
"azureml-contrib-services", "toolz==0.9.0"
]
imgenv = CondaDependencies.create(conda_packages=conda_pack,
pip_packages=requirements)
with open("img_env.yml", "w") as file:
file.write(imgenv.serialize_to_string())
description = "Image for AKS Deployment Tutorial"
dependencies = ["resnet152.py"]
tags = {"name": "AKS", "project": "AML"}
return ContainerImage.image_configuration(
execution_script=execution_script,
runtime="python",
conda_file=conda_file,
description=description,
tags=tags,
dependencies=dependencies,
enable_gpu=True)
def build_container():
cd = CondaDependencies.create(pip_packages=[
'azureml-sdk==1.0.39', 'scikit-learn==0.21.1', 'joblib==0.13.2'
])
cd.save_to_file(base_directory='./', conda_file_path='myenv.yml')
model = get_best_model(model_name)
print('model', model)
img_config = ContainerImage.image_configuration(
execution_script='score.py',
runtime='python',
conda_file='myenv.yml',
dependencies=['.'])
image_name = model_name.replace("_", "").lower()
print("Image name:", image_name)
image = Image.create(name=image_name,
models=[model],
image_config=img_config,
workspace=ws)
image.wait_for_creation(show_output=True)
if image.creation_state != 'Succeeded':
raise Exception('Image creation status: {image.creation_state}')
print('{}(v.{} [{}]) stored at {} with build log {}'.format(
image.name, image.version, image.creation_state, image.image_location,
image.image_build_log_uri))
def create_or_get_image(self):
image_params = self.__config['image']
images = ContainerImage.list(self.__ws,
image_name=image_config['name'])
image = images.find_by_property('version', image_config['version'])
if image:
return image
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="config_deploy/myenv.yml",
docker_file="config_deploy/Dockerfile",
enable_gpu=True,
dependencies=[
'generation', 'config.py', 'skipthoughts_vectors',
'generate.py', 'preprocessing/text_moderator.py'
])
image = ContainerImage.create(name=image_params['name'],
models=[],
image_config=image_config,
workspace=self.__ws)
image.wait_for_creation(show_output=True)
return image
def main():
# get workspace
ws = load_workspace()
model = Model.register(ws,
model_name='pytorch_mnist',
model_path='model.pth')
# create dep file
myenv = CondaDependencies()
myenv.add_pip_package('numpy')
myenv.add_pip_package('torch')
with open('pytorchmnist.yml', 'w') as f:
print('Writing out {}'.format('pytorchmnist.yml'))
f.write(myenv.serialize_to_string())
print('Done!')
# create image
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="pytorchmnist.yml",
dependencies=['./models.py'])
image = Image.create(ws, 'pytorchmnist', [model], image_config)
image.wait_for_creation(show_output=True)
# create service
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1, memory_gb=1, description='simple MNIST digit detection')
service = Webservice.deploy_from_image(workspace=ws,
image=image,
name='pytorchmnist-svc',
deployment_config=aciconfig)
service.wait_for_deployment(show_output=True)
def run():
print("entered run")
variables_received = "sub_id: {}, rg: {}, work_name: {}, state: {}, author: {}, model_name: {}" \
.format(resolve_sub_id(),
resolve_rg(),
resolve_workspace_name(),
resolve_state(),
resolve_author(),
resolve_model_name())
print(variables_received)
az_ws = Workspace(resolve_sub_id(), resolve_rg(), resolve_workspace_name())
print("initialized workspace")
#Get & Download model
model = Model(az_ws,
name=resolve_model_name(),
tags={
"state": resolve_state(),
"created_by": resolve_author()
})
print("initialized model")
model.download(target_dir="./assets/")
print("downloaded model assets")
#TODO: remove workaround for ml sdk dropping assets into /assets/dacrook folder when files dropped to consistent location
for dir_p, _, f_n in walk("./assets"):
for f in f_n:
abs_path = os.path.abspath(os.path.join(dir_p, f))
shutil.move(abs_path, "./assets/" + f)
#Configure Image
my_env = CondaDependencies.create(conda_packages=["numpy", "scikit-learn"])
with open("myenv.yml", "w") as f:
f.write(my_env.serialize_to_string())
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="myenv.yml",
dependencies=["assets", "inference_code"],
tags={
"state": resolve_state(),
"created_by": resolve_author()
})
print("configured image")
#TODO: use this once model is dropped to a consistent location
# image = Image.create(workspace = az_ws, name=resolve_image_name(), models=[model], image_config = image_config)
image = Image.create(workspace=az_ws,
name=resolve_image_name(),
models=[model],
image_config=image_config)
image.wait_for_creation()
print("created image")
if (image.creation_state != "Succeeded"):
raise Exception("Failed to create image.")
print("image location: {}".format(image.image_location))
artifacts = {"image_location": image.image_location}
if (not os.path.exists("/artifacts/")):
os.makedirs("/artifacts/")
with open("/artifacts/artifacts.json", "w") as outjson:
json.dump(artifacts, outjson)
def create_image_config(script_name, conda_env):
image_config = ContainerImage.image_configuration(
execution_script=script_name,
runtime="python",
dependencies=["./"],
conda_file=conda_env)
return image_config
def container_img(ws, model, score_script, env_file):
image_config = ContainerImage.image_configuration(
execution_script=score_script, runtime="python", conda_file=env_file)
image = Image.create(name="TeamOmega",
models=[model],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
return image
def main():
ws = Workspace.from_config()
conda = CondaDependencies()
conda.add_conda_package("python==3.5")
conda.add_pip_package("h5py==2.8.0")
conda.add_pip_package("html5lib==1.0.1")
conda.add_pip_package("keras==2.2.0")
conda.add_pip_package("Keras-Applications==1.0.2")
conda.add_pip_package("Keras-Preprocessing==1.0.1")
conda.add_pip_package("matplotlib==2.2.2")
conda.add_pip_package("numpy==1.14.5")
conda.add_pip_package("opencv-python==3.3.0.9")
conda.add_pip_package("pandas==0.23.3")
conda.add_pip_package("Pillow==5.2.0")
conda.add_pip_package("requests==2.19.1")
conda.add_pip_package("scikit-image==0.14.0")
conda.add_pip_package("scikit-learn==0.19.2")
conda.add_pip_package("scipy==1.1.0")
conda.add_pip_package("sklearn==0.0")
conda.add_pip_package("tensorflow==1.9.0")
conda.add_pip_package("urllib3==1.23")
conda.add_pip_package("azureml-sdk")
with open("environment.yml", "w") as f:
f.write(conda.serialize_to_string())
with open("environment.yml", "r") as f:
print(f.read())
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="environment.yml",
docker_file="Dockerfile",
dependencies=DEPENDENCIES)
webservices = ws.webservices(compute_type='ACI')
image = ContainerImage.create(name="ai-bootcamp",
models=[],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
webservices_list = []
for key in webservices:
webservices_list.append(key)
service_name = webservices_list[0]
aciwebservice = AciWebservice(ws, service_name)
aciwebservice.update(image=image)
def deployModelAsWebService(
ws,
model_folder_path="models",
model_name="component_compliance",
scoring_script_filename="scoring_service.py",
conda_packages=['numpy', 'pandas'],
pip_packages=['azureml-sdk', 'onnxruntime'],
conda_file="dependencies.yml",
runtime="python",
cpu_cores=1,
memory_gb=1,
tags={'name': 'scoring'},
description='Compliance classification web service.',
service_name="complianceservice"):
# notice for the model_path, we supply the name of the outputs folder without a trailing slash
# this will ensure both the model and the customestimators get uploaded.
print("Registering and uploading model...")
registered_model = Model.register(model_path=model_folder_path,
model_name=model_name,
workspace=ws)
# create a Conda dependencies environment file
print("Creating conda dependencies file locally...")
from azureml.core.conda_dependencies import CondaDependencies
mycondaenv = CondaDependencies.create(conda_packages=conda_packages,
pip_packages=pip_packages)
with open(conda_file, "w") as f:
f.write(mycondaenv.serialize_to_string())
# create container image configuration
print("Creating container image configuration...")
from azureml.core.image import ContainerImage
image_config = ContainerImage.image_configuration(
execution_script=scoring_script_filename,
runtime=runtime,
conda_file=conda_file)
# create ACI configuration
print("Creating ACI configuration...")
from azureml.core.webservice import AciWebservice, Webservice
aci_config = AciWebservice.deploy_configuration(cpu_cores=cpu_cores,
memory_gb=memory_gb,
tags=tags,
description=description)
# deploy the webservice to ACI
print("Deploying webservice to ACI...")
webservice = Webservice.deploy_from_model(workspace=ws,
name=service_name,
deployment_config=aci_config,
models=[registered_model],
image_config=image_config)
webservice.wait_for_deployment(show_output=True)
return webservice
def run(model_path, model_name):
auth_args = {
'tenant_id': os.environ['TENANT_ID'],
'service_principal_id': os.environ['SERVICE_PRINCIPAL_ID'],
'service_principal_password': os.environ['SERVICE_PRINCIPAL_PASSWORD']
}
ws_args = {
'auth': ServicePrincipalAuthentication(**auth_args),
'subscription_id': os.environ['SUBSCRIPTION_ID'],
'resource_group': os.environ['RESOURCE_GROUP']
}
ws = Workspace.get(os.environ['WORKSPACE_NAME'], **ws_args)
print(ws.get_details())
print('\nSaving model {} to {}'.format(model_path, model_name))
model = Model.register(ws, model_name=model_name, model_path=model_path)
print('Done!')
print('Checking for existing service {}'.format(model_name))
service_name = 'simplemnist-svc'
if model_name in ws.webservices:
print('Found it!\nRemoving Existing service...')
ws.webservices[model_name].delete()
print('Done!')
else:
print('Not found, creating new one!')
# image configuration
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="environment.yml")
# deployement configuration
aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1,
description=model_name)
# deploy
service = Webservice.deploy_from_model(workspace=ws,
name=model_name,
models=[model],
image_config=image_config,
deployment_config=aciconfig)
service.wait_for_deployment(show_output=True)
#print logs
print(service.get_logs())
print('Done!')
def createImage(workspace, scoring_file, model, image_name):
'''
TODO: We should probably allow the conda_pack/requirements to be identified so we can switch
between CPU/GPU
NOTE: This function doesn't check for the existence of an image because new builds
will just create a new version on a container. If the caller doesn't want duplicates,
they need to ensure that one does not exist already.
Creates a new Docker Container image and uploads it to the associated ACR
with the workspace.
PARAMS:
workspace : azureml.core.Workspace : Existing AMLS Workspace
scoring_file : String : Name/path of local .py file that has an init() and run() function defined.
model : azureml.core.Model : Registered AMLS model
image_name : String : Name of the container to be created.
RETURNS:
azureml.core.image.ContainerImage
'''
conda_pack = []
requirements = ["azureml-defaults==1.0.57", "azureml-contrib-services"]
print("Creating image...")
simple_environment = CondaDependencies.create(conda_packages=conda_pack,
pip_packages=requirements)
with open("simple.yml", "w") as f:
f.write(simple_environment.serialize_to_string())
image_config = ContainerImage.image_configuration(
execution_script=scoring_file,
runtime="python",
conda_file="simple.yml",
description="Image with dummy (unused) model",
tags={"type": "noop"},
dependencies=[])
image = ContainerImage.create(
name=image_name,
models=[model],
image_config=image_config,
workspace=workspace,
)
image.wait_for_creation(show_output=True)
print("Image created IMAGE/VERSION: ", image.name, '/', image.version)
return image
def deploy(aciconfig, envfile, name, model):
# configure the image
image_config = ContainerImage.image_configuration(
execution_script="./score.py", runtime="python", conda_file=envfile)
service = Webservice.deploy_from_model(workspace=ws,
name=name,
deployment_config=aciconfig,
models=[model],
image_config=image_config)
service.wait_for_deployment(show_output=True)
print(service.scoring_uri)
def create_lightgbm_image_config(
conda_file="lgbmenv.yml", execution_script="score.py", dependencies=None
) -> ContainerImageConfig:
"""
Image Configuration for running LightGBM in Azure Machine Learning Workspace
:param conda_file: file name of LightGBM Conda Env File. This file is created if it does not exist.
default: lgbmenv.yml
:param execution_script: webservice file. default: score.py
:param dependencies: Files required for image.
:return: new image configuration for Machine Learning Workspace
"""
create_lightgbm_conda_file(conda_file)
dockerfile = "dockerfile"
with open(dockerfile, "w") as file:
file.write(
"RUN apt update -y && apt upgrade -y && apt install -y build-essential"
)
with open("score.py", "w") as file:
file.write(
"""
import json
import logging
def init():
logger = logging.getLogger("scoring_script")
logger.info("init")
def run():
logger = logging.getLogger("scoring_script")
logger.info("run")
return json.dumps({'call': True})
"""
)
description = "Image with lightgbm model"
tags = {"area": "text", "type": "lightgbm"}
return ContainerImage.image_configuration(
execution_script=execution_script,
runtime="python",
conda_file=conda_file,
description=description,
dependencies=dependencies,
docker_file=dockerfile,
tags=tags,
)
def deployWebservice(ws, args, folders):
# this section requries that the processing is done in the directory where the execution script and the conda_file resides
os.chdir(folders.script_folder)
model = Model(ws, args.modelName)
aciconfig = AciWebservice.deploy_configuration(cpu_cores=args.cpuCores,
memory_gb=args.memoryGB)
# configure the image
image_config = ContainerImage.image_configuration(
execution_script=args.scoringScript,
runtime="python",
conda_file=args.environmentFileName)
service = Webservice.deploy_from_model(workspace=ws,
name=args.webserviceName,
deployment_config=aciconfig,
models=[model],
image_config=image_config)
service.wait_for_deployment(show_output=True)
return service.scoring_uri
def deploy_service(execution_script,
conda_file,
aciconfig,
service_name,
model,
workspace,
runtime="python"):
image_config = ContainerImage.image_configuration(
execution_script=execution_script,
runtime=runtime,
conda_file=conda_file)
service = Webservice.deploy_from_model(workspace=workspace,
name=service_name,
deployment_config=aciconfig,
models=[model],
image_config=image_config)
service.wait_for_deployment(show_output=True)
print(service.scoring_uri)
return service
def build_image():
"""Build the docker image to hold the model."""
load_dotenv(find_dotenv())
chdir("deploy")
ws = Workspace(
workspace_name=getenv("AML_WORKSPACE_NAME"),
subscription_id=getenv("AML_SUBSCRIPTION_ID"),
resource_group=getenv("AML_RESOURCE_GROUP"),
)
model = Model(ws, getenv("AML_MODEL_NAME"))
image_config = ContainerImage.image_configuration(
runtime="python",
execution_script="score.py",
conda_file="container_conda_env.yml")
image = Image.create(name=getenv("AML_IMAGE_NAME"),
models=[model],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
def amls_model_to_image(amls_config, workspace, model):
"""
Deploy a published AMLS model as docker image in AMLS' ACR.
:param amls_config:
:param workspace:
:param model:
:return:
"""
script = "score.py"
conda_file = "conda_dependencies.yml"
save_conda_dependencies(amls_config, conda_file)
if amls_config['docker_file']:
docker_file = amls_config['docker_file']
else:
docker_file = None
image_config = ContainerImage.image_configuration(
runtime="python",
execution_script=script,
conda_file=conda_file,
tags=amls_config['tags'],
description=amls_config['description'],
docker_file=docker_file)
logger.info(f"Deploying image.")
image = Image.create(
name='image',
# this is the model object
models=[model],
image_config=image_config,
workspace=workspace)
image.wait_for_creation(show_output=True)
image.update_creation_state()
return image
def build_image(model_uri,
workspace,
image_name=None,
model_name=None,
mlflow_home=None,
description=None,
tags=None,
synchronous=True):
"""
Register an MLflow model with Azure ML and build an Azure ML ContainerImage for deployment.
The resulting image can be deployed as a web service to Azure Container Instances (ACI) or
Azure Kubernetes Service (AKS).
The resulting Azure ML ContainerImage will contain a webserver that processes model queries.
For information about the input data formats accepted by this webserver, see the
:ref:`MLflow deployment tools documentation <azureml_deployment>`.
:param model_uri: The location, in URI format, of the MLflow model for which to build an Azure
ML deployment image, for example:
- ``/Users/me/path/to/local/model``
- ``relative/path/to/local/model``
- ``s3://my_bucket/path/to/model``
- ``runs:/<mlflow_run_id>/run-relative/path/to/model``
For more information about supported URI schemes, see the
`Artifacts Documentation <https://www.mlflow.org/docs/latest/tracking.html#
supported-artifact-stores>`_.
:param image_name: The name to assign the Azure Container Image that will be created. If
unspecified, a unique image name will be generated.
:param model_name: The name to assign the Azure Model will be created. If unspecified,
a unique model name will be generated.
:param workspace: The AzureML workspace in which to build the image. This is a
`azureml.core.Workspace` object.
:param mlflow_home: Path to a local copy of the MLflow GitHub repository. If specified, the
image will install MLflow from this directory. Otherwise, it will install
MLflow from pip.
:param description: A string description to associate with the Azure Container Image and the
Azure Model that will be created. For more information, see
`<https://docs.microsoft.com/en-us/python/api/azureml-core/
azureml.core.image.container.containerimageconfig>`_ and
`<https://docs.microsoft.com/en-us/python/api/azureml-core/
azureml.core.model.model?view=azure-ml-py#register>`_.
:param tags: A collection of tags, represented as a dictionary of string key-value pairs, to
associate with the Azure Container Image and the Azure Model that will be created.
These tags will be added to a set of default tags that include the model path,
the model run id (if specified), and more. For more information, see
`<https://docs.microsoft.com/en-us/python/api/azureml-core/
azureml.core.image.container.containerimageconfig>`_ and
`<https://docs.microsoft.com/en-us/python/api/azureml-core/
azureml.core.model.model?view=azure-ml-py#register>`_.
:param synchronous: If `True`, this method will block until the image creation procedure
terminates before returning. If `False`, the method will return immediately,
but the returned image will not be available until the asynchronous
creation process completes. The `azureml.core.Image.wait_for_creation()`
function can be used to wait for the creation process to complete.
:return: A tuple containing the following elements in order:
- An `azureml.core.image.ContainerImage` object containing metadata for the new image.
- An `azureml.core.model.Model` object containing metadata for the new model.
>>> import mlflow.azureml
>>> from azureml.core import Workspace
>>> from azureml.core.webservice import AciWebservice, Webservice
>>>
>>> # Load or create an Azure ML Workspace
>>> workspace_name = "<Name of your Azure ML workspace>"
>>> subscription_id = "<Your Azure subscription ID>"
>>> resource_group = "<Name of the Azure resource group in which to create Azure ML resources>"
>>> location = "<Name of the Azure location (region) in which to create Azure ML resources>"
>>> azure_workspace = Workspace.create(name=workspace_name,
>>> subscription_id=subscription_id,
>>> resource_group=resource_group,
>>> location=location,
>>> create_resource_group=True,
>>> exist_okay=True)
>>>
>>> # Build an Azure ML Container Image for an MLflow model
>>> azure_image, azure_model = mlflow.azureml.build_image(
>>> model_path="<model_path>",
>>> workspace=azure_workspace,
>>> synchronous=True)
>>> # If your image build failed, you can access build logs at the following URI:
>>> print("Access the following URI for build logs: {}".format(azure_image.image_build_log_uri))
>>>
>>> # Deploy the image to Azure Container Instances (ACI) for real-time serving
>>> webservice_deployment_config = AciWebservice.deploy_configuration()
>>> webservice = Webservice.deploy_from_image(
>>> image=azure_image, workspace=azure_workspace, name="<deployment-name>")
>>> webservice.wait_for_deployment()
"""
# The Azure ML SDK is only compatible with Python 3. However, the `mlflow.azureml` module should
# still be accessible for import from Python 2. Therefore, we will only import from the SDK
# upon method invocation.
# pylint: disable=import-error
from azureml.core.image import ContainerImage
from azureml.core.model import Model as AzureModel
absolute_model_path = _download_artifact_from_uri(model_uri)
model_pyfunc_conf = _load_pyfunc_conf(model_path=absolute_model_path)
model_python_version = model_pyfunc_conf.get(pyfunc.PY_VERSION, None)
if model_python_version is not None and\
StrictVersion(model_python_version) < StrictVersion("3.0.0"):
raise MlflowException(message=(
"Azure ML can only deploy models trained in Python 3 or above! Please see"
" the following MLflow GitHub issue for a thorough explanation of this"
" limitation and a workaround to enable support for deploying models"
" trained in Python 2: https://github.com/mlflow/mlflow/issues/668"
),
error_code=INVALID_PARAMETER_VALUE)
tags = _build_tags(model_uri=model_uri,
model_python_version=model_python_version,
user_tags=tags)
if image_name is None:
image_name = _get_mlflow_azure_resource_name()
if model_name is None:
model_name = _get_mlflow_azure_resource_name()
with TempDir(chdr=True) as tmp:
model_directory_path = tmp.path("model")
tmp_model_path = os.path.join(
model_directory_path,
_copy_file_or_tree(src=absolute_model_path,
dst=model_directory_path))
registered_model = AzureModel.register(workspace=workspace,
model_path=tmp_model_path,
model_name=model_name,
tags=tags,
description=description)
_logger.info(
"Registered an Azure Model with name: `%s` and version: `%s`",
registered_model.name, registered_model.version)
# Create an execution script (entry point) for the image's model server. Azure ML requires
# the container's execution script to be located in the current working directory during
# image creation, so we create the execution script as a temporary file in the current
# working directory.
execution_script_path = tmp.path("execution_script.py")
_create_execution_script(output_path=execution_script_path,
azure_model=registered_model)
# Azure ML copies the execution script into the image's application root directory by
# prepending "/var/azureml-app" to the specified script path. The script is then executed
# by referencing its path relative to the "/var/azureml-app" directory. Unfortunately,
# if the script path is an absolute path, Azure ML attempts to reference it directly,
# resulting in a failure. To circumvent this problem, we provide Azure ML with the relative
# script path. Because the execution script was created in the current working directory,
# this relative path is the script path's base name.
execution_script_path = os.path.basename(execution_script_path)
if mlflow_home is not None:
_logger.info(
"Copying the specified mlflow_home directory: `%s` to a temporary location for"
" container creation", mlflow_home)
mlflow_home = os.path.join(
tmp.path(),
_copy_project(src_path=mlflow_home, dst_path=tmp.path()))
image_file_dependencies = [mlflow_home]
else:
image_file_dependencies = None
dockerfile_path = tmp.path("Dockerfile")
_create_dockerfile(output_path=dockerfile_path,
mlflow_path=mlflow_home)
conda_env_path = None
if pyfunc.ENV in model_pyfunc_conf:
conda_env_path = os.path.join(tmp_model_path,
model_pyfunc_conf[pyfunc.ENV])
image_configuration = ContainerImage.image_configuration(
execution_script=execution_script_path,
runtime="python",
docker_file=dockerfile_path,
dependencies=image_file_dependencies,
conda_file=conda_env_path,
description=description,
tags=tags,
)
image = ContainerImage.create(workspace=workspace,
name=image_name,
image_config=image_configuration,
models=[registered_model])
_logger.info(
"Building an Azure Container Image with name: `%s` and version: `%s`",
image.name, image.version)
if synchronous:
image.wait_for_creation(show_output=True)
return image, registered_model
import os, json, sys
from azureml.core import Workspace
from azureml.core.image import ContainerImage, Image
from azureml.core.model import Model
from azureml.core.authentication import AzureCliAuthentication
#os.chdir("./code")
cli_auth = AzureCliAuthentication()
ws = Workspace.from_config(auth=cli_auth)
model = Model(ws, "Model")
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="conda.yml",
description="Predict regression",
tags={
"regression": "classification",
"classification": "ml"
})
image = ContainerImage.create(name="model-image",
models=[model],
image_config=image_config,
workspace=ws)
model_name = 'prednet_UCSDped1' #config['model_name']
model_version = 2 # config['model_version']
cd = CondaDependencies.create(pip_packages=[
'keras==2.0.8', 'theano', 'tensorflow==1.8.0', 'matplotlib', 'hickle',
'pandas', 'azureml-sdk'
])
cd.save_to_file(base_directory='./', conda_file_path='myenv.yml')
model = Model(ws, name=model_name, version=model_version)
img_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="myenv.yml",
dependencies=['prednet.py', 'keras_utils.py', 'aml_config/model.json'])
image_name = model_name.replace("_", "").lower()
print("Image name:", image_name)
image = Image.create(name=image_name,
models=[model],
image_config=img_config,
workspace=ws)
image.wait_for_creation(show_output=True)
if image.creation_state != 'Succeeded':
sys.exit(0)
model_name = config['model_name']
model_version = config['model_version']
model_list = Model.list(workspace=ws)
model, = (m for m in model_list if m.version==model_version and m.name==model_name)
print('Model picked: {} \nModel Description: {} \nModel Version: {}'.format(model.name, model.description, model.version))
os.chdir('./CICD/code/scoring')
image_name = "predmaintenance-model-score"
image_config = ContainerImage.image_configuration(execution_script = "score.py",
runtime = "python-slim",
conda_file = "conda_dependencies.yml",
description = "Image with predictive maintenance model",
tags = {'area': "diabetes", 'type': "regression"}
)
image = Image.create(name = image_name,
models = [model],
image_config = image_config,
workspace = ws)
image.wait_for_creation(show_output = True)
os.chdir('../../../')
if image.creation_state != 'Succeeded':
raise Exception('Image creation status: {image.creation_state}')
print('{}(v.{} [{}]) stored at {} with build log {}'.format(image.name, image.version, image.creation_state, image.image_location, image.image_build_log_uri))
myaci_config = AciWebservice.deploy_configuration(
cpu_cores=2,
memory_gb=2,
tags={'name': 'Databricks Azure ML ACI'},
description='SMS Spam Classifier')
# COMMAND ----------
service_name = "smsspam"
runtime = "spark-py"
driver_file = "score_sparkml.py"
my_conda_file = "mydeployenv.yml"
# image creation
from azureml.core.image import ContainerImage
myimage_config = ContainerImage.image_configuration(
execution_script=driver_file, runtime=runtime, conda_file=my_conda_file)
# COMMAND ----------
# Webservice creation
myservice = Webservice.deploy_from_model(workspace=ws,
name=service_name,
deployment_config=myaci_config,
models=[mymodel],
image_config=myimage_config)
myservice.wait_for_deployment(show_output=True)
# COMMAND ----------
#for using the Web HTTP API
#Set the image
aciconfig = AciWebservice.deploy_configuration(cpu_cores=CPU_CORES,
memory_gb=MEMORY_GB,
description=SERVICE_DESCRIPTION,
auth_enabled=AUTH_ENABLED)
if CONDA_FILE_URL == '' and DOCKER_FILE_URL == '':
from azureml.core.conda_dependencies import CondaDependencies
myenv = CondaDependencies()
myenv.add_conda_package("scikit-learn")
#myenv.add_pip_package("joblib")
with open("myenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
# configure the image
image_config = ContainerImage.image_configuration(
execution_script=EXECUTION_SCRIPT_PATH,
runtime="python",
conda_file="myenv.yml")
elif CONDA_FILE_URL is not '' and DOCKER_FILE_URL == '':
wget.download(CONDA_FILE_URL, CONDA_FILE_PATH)
image_config = ContainerImage.image_configuration(
execution_script=EXECUTION_SCRIPT_PATH,
runtime="python",
conda_file=CONDA_FILE_PATH)
elif DOCKER_FILE_URL is not '':
wget.download(DOCKER_FILE_URL, DOCKER_FILE_PATH)
image_config = ContainerImage.image_configuration(
execution_script=EXECUTION_SCRIPT_PATH,
runtime="python",
docker_file=DOCKER_FILE_PATH)
#Deploy the service
args = parser.parse_args()
model = Model(ws, name=e.model_name, version=e.model_version)
sources_dir = e.sources_directory_train
if (sources_dir is None):
sources_dir = 'diabetes_regression'
path_to_scoring = os.path.join(".", sources_dir, "scoring")
cwd = os.getcwd()
# Copy conda_dependencies.yml into scoring as this method does not accept relative paths. # NOQA: E501
shutil.copy(os.path.join(".", sources_dir, "conda_dependencies.yml"),
path_to_scoring)
os.chdir(path_to_scoring)
image_config = ContainerImage.image_configuration(
execution_script=e.score_script,
runtime="python",
conda_file="conda_dependencies.yml",
description="Image with ridge regression model",
tags={"area": "diabetes_regression"},
)
image = Image.create(name=e.image_name,
models=[model],
image_config=image_config,
workspace=ws)
os.chdir(cwd)
image.wait_for_creation(show_output=True)
if image.creation_state != "Succeeded":
raise Exception("Image creation status: {image.creation_state}")
# create a Conda dependencies environment file
print("Creating conda dependencies file locally...")
conda_packages = ['numpy']
pip_packages = [
'tensorflow==2.0.0', 'keras==2.3.1', 'azureml-sdk', 'azureml-monitoring'
]
mycondaenv = CondaDependencies.create(conda_packages=conda_packages,
pip_packages=pip_packages)
conda_file = 'scoring_dependencies.yml'
with open(conda_file, 'w') as f:
f.write(mycondaenv.serialize_to_string())
# create container image configuration
print("Creating container image configuration...")
image_config = ContainerImage.image_configuration(
execution_script='score_fixed.py', runtime='python', conda_file=conda_file)
print("Creating image...")
image = Image.create(name=args.image_name,
models=[latest_model],
image_config=image_config,
workspace=ws)
# wait for image creation to finish
image.wait_for_creation(show_output=True)
eval_info["image_id"] = image.id
with open(eval_filepath, "w") as f:
json.dump(eval_info, f)
print('eval_info.json saved')
ta_env = CondaDependencies()
ta_env.add_conda_package("scikit-learn")
ta_env.add_conda_package("dill")
with open("ta_env.yml","w") as f:
f.write(ta_env.serialize_to_string())
with open("ta_env.yml","r") as f:
print(f.read())
%%time
image_config = ContainerImage.image_configuration(execution_script="score.py",
runtime="python",
conda_file="ta_env.yml")
aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1,
tags={"data": "textanalytics", "method" : "textblob"},
description='Predict Sentiment of Sentences')
service = Webservice.deploy_from_model(workspace=ws,
name='ta-textblob',
deployment_config=aciconfig,
models=[model],
image_config=image_config)
service.wait_for_deployment(show_output=True)
else:
# Create the container image if it's not there
if not containerImage:
print("Creating container image")
# Unlike the InferenceConfig from the ACI script, you MUST be in the same directory
# as the files being added here....paths do NOT work.
print("Changing working directory....")
currentDirectory = os.getcwd()
os.chdir(os.path.join(currentDirectory, "model"))
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="myenv.yml",
description="Image with ridge regression model",
tags={
'area': "diabetes",
'type': "regression"
})
containerImage = ContainerImage.create(
name=imageName,
# this is the model object
models=[model],
image_config=image_config,
workspace=ws)
print("Wait for container image....")
containerImage.wait_for_creation(show_output=True)
os.chdir(currentDirectory)
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=1,
tags={
"data": "MNIST",
"method": "sklearn"
},
description='Predict MNIST with sklearn')
# Create Docker Image
from azureml.core.image import ContainerImage
# configure the image
image_config = ContainerImage.image_configuration(
execution_script="score_mnist.py",
runtime="python",
conda_file=os.path.join(project_folder, "myenv.yml"))
image = ContainerImage.create(name="sklearn-mnist-img",
models=[model],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
# Deploy the image in ACI
print("Deploying the service as Azure Container Instance...")
from azureml.core.webservice import Webservice
aci_service = Webservice.deploy_from_image(workspace=ws,
name='sklearn-mnist-aci-svc',
model_version = config["model_version"]
model_list = Model.list(workspace=ws)
model, = (m for m in model_list
if m.version == model_version and m.name == model_name)
print("Model picked: {} \nModel Description: {} \nModel Version: {}".format(
model.name, model.description, model.version))
os.chdir("./scripts/scoring")
image_name = "arima-forecast-score"
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python-slim",
conda_file="conda_dependencies.yml",
description="Image with robberies arima forecasting model",
tags={
"area": "robberies",
"type": "forecasting"
},
)
image = Image.create(name=image_name,
models=[model],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
os.chdir("../..")
if image.creation_state != "Succeeded":
raise Exception("Image creation status: {image.creation_state}")
model_version = config["model_version"]
model_list = Model.list(workspace=ws)
model, = (m for m in model_list
if m.version == model_version and m.name == model_name)
print("Model picked: {} \nModel Description: {} \nModel Version: {}".format(
model.name, model.description, model.version))
os.chdir("./code/scoring")
image_name = "diabetes-model-score"
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python-slim",
conda_file="conda_dependencies.yml",
description="Image with ridge regression model",
tags={
"area": "diabetes",
"type": "regression"
},
)
image = Image.create(name=image_name,
models=[model],
image_config=image_config,
workspace=ws)
image.wait_for_creation(show_output=True)
os.chdir("../..")
if image.creation_state != "Succeeded":
raise Exception("Image creation status: {image.creation_state}")
