def main():
"""
Deploy model to your service
"""
work_space = Workspace.from_config()
environment = Environment("keras-service-environment")
environment.python.conda_dependencies = CondaDependencies.create(
python_version="3.7.7",
pip_packages=["azureml-defaults", "numpy", "tensorflow==2.3.1"],
)
model = Model(work_space, "keras_mnist")
model_list = model.list(work_space)
validation_accuracy = []
version = []
for i in model_list:
validation_accuracy.append(float(i.properties["val_accuracy"]))
version.append(i.version)
model = Model(work_space,
"keras_mnist",
version=version[np.argmax(validation_accuracy)])
service_name = "keras-mnist-service"
inference_config = InferenceConfig(entry_script="score_keras.py",
environment=environment)
aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)
service = Model.deploy(
workspace=work_space,
name=service_name,
models=[model],
inference_config=inference_config,
deployment_config=aci_config,
overwrite=True,
)
service.wait_for_deployment(show_output=True)
print(service.get_logs())
def get_inference_config(aml_interface):
aml_env = Environment.get(workspace=aml_interface.workspace,
name=AML_ENVIRONMENT_NAME)
scoring_script_path = os.path.join(__here__, 'score.py')
inference_config = InferenceConfig(entry_script=scoring_script_path,
environment=aml_env)
return inference_config
def main(args):
# Define workspace object
try:
ws = Workspace.from_config(path='deploy/.azureml/config.json')
# Need to create the workspace and download config.json from Azure Portal
except Exception as err:
print('No workspace. Check for deploy/.azureml/config.json file.')
assert False
model = Model(ws, name=args.model_workspace)
inference_config = InferenceConfig(runtime="python",
entry_script="score.py",
conda_file="keras_env.yml",
source_directory="./deploy")
package = Model.package(ws, [model],
inference_config,
generate_dockerfile=True)
package.wait_for_creation(show_output=True)
# Download the package.
package.save("./" + args.out_dir)
# Get the Azure container registry that the model/Dockerfile uses.
acr = package.get_container_registry()
print("Address:", acr.address)
print("Username:"******"Password:", acr.password)
def main():
print('Cargando configuracion workspace...')
ws = Workspace.from_config()
print('Obteniendo modelo...')
model = Model(ws, 'yolov3-tf')
print("Configurando Objects...")
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=2,
memory_gb=2,
tags={"data": "solo yolov3 tensorflow"},
description='yolov3 y tensorflow',
dns_name_label='ceibatest')
inference_config = InferenceConfig(entry_script="score.py",
source_directory="../azure",
conda_file='conda-cpu.yml',
runtime='python')
print("Desplegando...")
service = Model.deploy(workspace=ws,
name='yolov3-tf-deploy',
models=[model],
inference_config=inference_config,
deployment_config=aciconfig,
overwrite=True)
service.wait_for_deployment(show_output=True)
url = service.scoring_uri
print(url)
def __deploy_model(self):
service_name = self.__args.service_name
model = Model(self.__ws, self.__args.model_name)
explainer_model = Model(self.__ws, self.__args.explainer_model_name)
myenv = Environment.from_conda_specification(
name=self.__config.get('DEPLOY', 'ENV_NAME'),
file_path=self.__config.get('DEPLOY', 'ENV_FILE_PATH'))
inference_config = InferenceConfig(
entry_script=self.__config.get('DEPLOY', 'SCORE_PATH'),
environment=myenv,
source_directory=self.__config.get('DEPLOY',
'DEPENDENCIES_DIRECTORY'))
if not self.__args.update_deployment:
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=self.__config.getint('DEPLOY', 'ACI_CPU'),
memory_gb=self.__config.getint('DEPLOY', 'ACI_MEM'),
collect_model_data=True,
enable_app_insights=True)
service = Model.deploy(self.__ws, service_name,
[model, explainer_model], inference_config,
deployment_config)
else:
service = AciWebservice(self.__ws, service_name)
service.update(models=[model, explainer_model],
inference_config=inference_config)
service.wait_for_deployment(show_output=True)
print(service.state)
print(service.get_logs())
def main(args):
# Define workspace object
try:
ws = Workspace.from_config(path='deploy/.azureml/config.json')
# Need to create the workspace
except Exception as err:
print('No workspace. Check for deploy/.azureml/config.json file.')
assert False
inference_config = InferenceConfig(runtime="python",
entry_script="score.py",
conda_file="keras_env.yml",
source_directory="./deploy")
deployment_config = LocalWebservice.deploy_configuration()
model = Model(ws, name=args.model_workspace)
# This deploys AND registers model (if not registered)
service = Model.deploy(workspace=ws,
name=args.service_name,
models=[model],
inference_config=inference_config,
deployment_config=deployment_config)
service.wait_for_deployment(True)
print(service.state)
def create_inference_config(ws):
inference_env_file = os.path.join(CODE_PATH, 'inference_env.yml')
inference_env = amlutils.create_azureml_env(
ws, consts.inference_environment_name, inference_env_file)
inference_config = InferenceConfig(
source_directory=CODE_PATH,
entry_script='score.py',
environment=inference_env)
return inference_config
def deploy(self, model_id, locally):
if locally:
self.ctx.log('Local deployment step is not required for Azure..')
return {'model_id': model_id}
ws = AzureProject(self.ctx)._get_ws()
experiment_name = self.ctx.config.get('experiment/name', None)
if experiment_name is None:
raise AzureException('Please specify Experiment name...')
iteration, run_id = self._get_iteration(model_id)
experiment = Experiment(ws, experiment_name)
experiment_run = AutoMLRun(experiment=experiment, run_id=run_id)
model_run = AutoMLRun(experiment=experiment, run_id=model_id)
model_name = model_run.properties['model_name']
self.ctx.log('Regestiring model: %s' % model_name)
description = '%s-%s' % (model_name, iteration)
model = experiment_run.register_model(model_name=model_name,
iteration=iteration,
description=description,
tags=None)
script_file_name = '.azureml/score_script.py'
model_run.download_file('outputs/scoring_file_v_1_0_0.py',
script_file_name)
# Deploying ACI Service
aci_service_name = self._aci_service_name(model_name)
self.ctx.log('Deploying AciWebservice %s ...' % aci_service_name)
inference_config = InferenceConfig(
environment=model_run.get_environment(),
entry_script=script_file_name)
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=2,
tags={'type': "inference-%s" % aci_service_name},
description="inference-%s" % aci_service_name)
# Remove any existing service under the same name.
try:
Webservice(ws, aci_service_name).delete()
self.ctx.log('Remove any existing service under the same name...')
except WebserviceException:
pass
aci_service = Model.deploy(ws, aci_service_name, [model],
inference_config, aciconfig)
aci_service.wait_for_deployment(True)
self.ctx.log('%s state %s' %
(aci_service_name, str(aci_service.state)))
return {'model_id': model_id, 'aci_service_name': aci_service_name}
def _deploy_remotly(self, model_id, model_run, ws, experiment):
from azureml.core.model import Model
from azureml.core.model import InferenceConfig
from azureml.core.webservice import Webservice
from azureml.core.webservice import AciWebservice
from azureml.exceptions import WebserviceException
from azureml.train.automl.run import AutoMLRun
# ws, experiment = self._get_experiment()
iteration, run_id = self._get_iteration(model_id)
experiment_run = AutoMLRun(experiment = experiment, run_id = run_id)
model_name = model_run.properties['model_name']
self.ctx.log('Registering model: %s' % model_id)
description = '%s-%s' % (model_name, iteration)
model = experiment_run.register_model(
model_name = model_name, iteration=iteration,
description = description, tags = None)
script_file_name = '.azureml/score_script.py'
model_run.download_file(
'outputs/scoring_file_v_1_0_0.py', script_file_name)
self._edit_score_script(script_file_name)
# Deploying ACI Service
aci_service_name = self._aci_service_name(model_name)
self.ctx.log('Deploying AciWebservice %s ...' % aci_service_name)
inference_config = InferenceConfig(
environment = model_run.get_environment(),
entry_script = script_file_name)
aciconfig = AciWebservice.deploy_configuration(
cpu_cores = 1,
memory_gb = 2,
tags = {'type': "inference-%s" % aci_service_name},
description = "inference-%s" % aci_service_name)
# Remove any existing service under the same name.
try:
Webservice(ws, aci_service_name).delete()
self.ctx.log('Remove any existing service under the same name...')
except WebserviceException:
pass
aci_service = Model.deploy(
ws, aci_service_name, [model], inference_config, aciconfig)
aci_service.wait_for_deployment(True)
self.ctx.log('%s state %s' % (aci_service_name, str(aci_service.state)))
return {'model_id': model_id, 'aci_service_name': aci_service_name}
def update_deployed_model(ws, aci_service_name, model_name, mlapp_env,
entry_script):
inference_config = InferenceConfig(source_directory=os.getcwd(),
entry_script=entry_script,
environment=mlapp_env)
model = Model(ws, name=model_name)
service = Webservice(name=aci_service_name, workspace=ws)
service.update(models=[model], inference_config=inference_config)
print(service.state)
print(service.get_logs())
def deploy(local, aks, aci, num_cores, mem_gb, compute_name):
# Get the workspace
ws = Workspace.from_config()
# Create inference configuration based on the environment definition and the entry script
# yolo = Environment.from_conda_specification(name="env", file_path="yolo.yml")
yolo = Environment.from_pip_requirements(
name="yolo", file_path="./deployed_requirements.txt")
# yolo.save_to_directory('')
yolo.register(workspace=ws)
inference_config = InferenceConfig(entry_script="azure.py",
environment=yolo,
source_directory="yolov5")
# Retrieve registered model
model = Model(ws, id="lpr:1")
deploy_target = None
if local:
# Create a local deployment, using port 8890 for the web service endpoint
deployment_config = LocalWebservice.deploy_configuration(port=8890)
elif aks:
# Create a AKS deployment
deployment_config = AksWebservice.deploy_configuration(
cpu_cores=num_cores,
memory_gb=mem_gb,
compute_target_name=compute_name)
deploy_target = ComputeTarget(workspace=ws, name=compute_name)
# if deploy_target.get_status() != "Succeeded":
# print(f"Deploy Target: {deploy_target.get_status()}")
# deploy_target.wait_for_completion(show_output=True)
elif aks:
# Create a AKS deployment
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=num_cores,
memory_gb=mem_gb,
compute_target_name=compute_name)
else:
raise NotImplementedError("Choose deploy target please")
# Deploy the service
print("Deploying:")
service = Model.deploy(workspace=ws,
name="lpr",
models=[model],
inference_config=inference_config,
deployment_config=deployment_config,
overwrite=True,
deployment_target=deploy_target)
# Wait for the deployment to complete
print("Deploying:")
service.wait_for_deployment(True)
# Display the port that the web service is available on
if local:
print(service.port)
def main():
# get access to workspace
try:
ws = Workspace.from_config()
print(ws.name, ws.location, ws.resource_group, ws.location, sep='\t')
print('Library configuration succeeded')
except:
print('Workspace not found')
return
# get model
model = Model(ws, 'absa')
# deploy model
pip = [
"azureml-defaults", "azureml-monitoring",
"git+https://github.com/NervanaSystems/nlp-architect.git@absa",
"spacy==2.1.4"
]
myenv = CondaDependencies.create(pip_packages=pip)
with open("absaenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
deploy_env = Environment.from_conda_specification('absa_env',
"absaenv.yml")
deploy_env.environment_variables = {'NLP_ARCHITECT_BE': 'CPU'}
inference_config = InferenceConfig(environment=deploy_env,
entry_script="score.py")
deploy_config = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=1,
description='Aspect-Based Sentiment Analysis - Intel')
print('Initiating deployment')
deployment = Model.deploy(ws,
'absa-svc',
models=[model],
inference_config=inference_config,
deployment_config=deploy_config,
overwrite=True)
deployment.wait_for_deployment(show_output=True)
print('Getting Logs')
deployment.get_logs()
print('Done!')
def main():
try:
ws = connectToWorkspace(TENANT_ID, APP_ID, SP_PASSWORD,
SUBSCRIPTION_ID, RESOURCE_GROUP,
WORKSPACE_NAME)
except ProjectSystemException as err:
print('Authentication did not work.')
return json.dumps('ProjectSystemException')
except Exception as err:
print(err)
sys.exit()
print("connect")
model = Model.register(model_path=os.path.join(
os.getcwd(), "retailai_recommendation_model.zip"),
model_name="retailai_recommendation_model",
description="Retail.AI Item-Based Recommender",
workspace=ws)
print("model registered")
myenv = Environment.get(ws, name='AzureML-PySpark-MmlSpark-0.15')
myenv.name = "myenv"
conda_dep = CondaDependencies()
conda_dep.add_pip_package("azureml-defaults")
conda_dep.add_pip_package("azure-storage")
conda_dep.add_pip_package("azure-storage-file-datalake")
myenv.python.conda_dependencies = conda_dep
print("Environment Configured")
inference_config = InferenceConfig(entry_script='score.py',
environment=myenv)
aks_target_name = "raiaks"
try:
aks_target = AksCompute(ws, aks_target_name)
print(aks_target)
except ComputeTargetException as err:
aks_target = attachAksComputeToWorkspace(ws, RESOURCE_GROUP,
AKS_CLUSTER_NAME,
aks_target_name, True)
print(aks_target)
except Exception as err:
print(err)
sys.exit()
try:
deployToAks(ws, aks_target, "retail-ai-item-recommender", model,
inference_config, True)
except Exception as err:
print(err)
sys.exit()
def _create_inference_config(inference_env_name):
try:
ws=_establish_connection_to_aml_workspace()
except Exception as e:
print("failed to connect to workspce")
raise e
try:
environment=Environment.get(workspace=ws,name=inference_env_name)
inference_config=InferenceConfig(entry_script="score.py",
environment=environment,
source_directory=r'deployment')
return inference_config
except Exception as e:
print("failed to create inference config")
raise e
def deploy(self):
myenv = CondaDependencies()
myenv.add_pip_package("azureml-sdk")
myenv.add_pip_package("joblib")
myenv.add_pip_package("tensorflow")
myenv.add_pip_package("Pillow")
myenv.add_pip_package("azureml-dataprep[pandas,fuse]>=1.1.14")
with open("diagnoz_env.yml", "w") as f:
f.write(myenv.serialize_to_string())
huml_env = Environment.from_conda_specification(
name="diagnoz_env", file_path="diagnoz_env.yml")
inference_config = InferenceConfig(entry_script="score.py",
source_directory='.',
environment=huml_env)
print("file deployement : ")
for root, dir_, files in os.walk(os.getcwd()):
print("dir_", dir_)
for filename in files:
print("filename :", filename)
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=1,
tags={
"data": "cancer-data",
"method": "tensorflow"
},
description='Predicting cancer with tensorflow')
try:
AciWebservice(self.ws, self.config.DEPLOY_SERVICE_NAME).delete()
print("webservice deleted")
except WebserviceException:
pass
model = self.ws.models[self.config.MODEL_NAME]
service = Model.deploy(workspace=self.ws,
name=self.config.DEPLOY_SERVICE_NAME,
models=[model],
inference_config=inference_config,
deployment_config=aciconfig)
service.wait_for_deployment(show_output=True)
print("success deployement")
def get_inference_config(environment_name, conda_file, entry_script):
# Create the environment
env = Environment(name=environment_name)
conda_dep = CondaDependencies(conda_file)
# Define the packages needed by the model and scripts
conda_dep.add_pip_package("azureml-defaults")
conda_dep.add_pip_package("xgboost")
# Adds dependencies to PythonSection of myenv
env.python.conda_dependencies = conda_dep
inference_config = InferenceConfig(entry_script=entry_script,
environment=env)
return inference_config
def deploy(self):
try:
AciWebservice(self.ws, self.DEPLOY_SERVICE_NAME).delete()
print("webservice deleted")
except WebserviceException:
pass
conda_dep = CondaDependencies()
conda_dep.add_pip_package("joblib")
conda_dep.add_pip_package("torch")
conda_dep.add_pip_package("torchvision")
conda_dep.add_pip_package("azureml-sdk")
conda_dep.add_pip_package("azure-storage-blob")
conda_dep.add_pip_package("PyYAML")
conda_dep.add_pip_package("scikit-learn")
conda_dep.add_pip_package("matplotlib")
conda_dep.add_pip_package("opencensus-ext-azure")
shoes_designer_env_file = "shoes_designer_env.yml"
with open(shoes_designer_env_file,"w") as f:
f.write(conda_dep.serialize_to_string())
shoes_designer_env = Environment.from_conda_specification(name="shoes_designer_env", file_path=shoes_designer_env_file)
inference_config = InferenceConfig(entry_script="score.py", environment=shoes_designer_env)
aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=2,
tags={"method" : "torch"},
description='Generate shoes with torch')
model = self.ws.models[self.MODEL_NAME]
service = Model.deploy(workspace=self.ws,
name=self.DEPLOY_SERVICE_NAME,
models=[model],
inference_config=inference_config,
deployment_config=aciconfig,
overwrite=True)
service.wait_for_deployment(show_output=True)
print("success deployement")
return service
def main():
load_dotenv()
workspace_name = os.environ.get("WS_NAME")
resource_group = os.environ.get("RG_NAME")
subscription_id = os.environ.get("SUBSCRIPTION_ID")
tenant_id = os.environ.get("TENANT_ID")
app_id = os.environ.get("SP_APP_ID")
app_secret = os.environ.get("SP_APP_SECRET")
model_name = os.environ.get("MODEL_NAME")
inference_config_file = os.environ.get("INFERENCE_CONFIG")
deployment_aci_config = os.environ.get("DEPLOYMENT_ACI_CONFIG")
conda_dep_yml = os.environ.get("CONDA_DEPENDENCIES")
score_path = os.environ.get("SCORE_PATH")
score_source_dir = os.environ.get("SCORE_SOURCE_DIR")
aci_service_name = os.environ.get("SERVICE_NAME")
# Get Azure machine learning workspace
aml_workspace = get_workspace(workspace_name, resource_group,
subscription_id, tenant_id, app_id,
app_secret)
inference_config = InferenceConfig(source_directory=score_source_dir,
runtime="python",
entry_script=score_path,
conda_file=conda_dep_yml)
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=2,
memory_gb=4,
tags={
"model": "BERT",
"method": "tensorflow"
},
description='Predict StackoverFlow tags with BERT')
model = aml_workspace.models[model_name]
aci_service = Model.deploy(aml_workspace,
aci_service_name, [model],
inference_config,
aciconfig,
overwrite=True)
aci_service.wait_for_deployment(True)
print(aci_service.state)
def deploy(workspace,
name,
model,
script,
source_directory,
environment=None,
target='local',
cpu_cores=1,
memory_gb=1,
compute_target_name=None):
inference_config = InferenceConfig(entry_script=script,
source_directory=source_directory,
environment=environment)
if target == 'local':
deployment_config = LocalWebservice.deploy_configuration(port=8890)
elif target == 'aci':
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=cpu_cores, memory_gb=memory_gb)
elif target == 'aks':
if compute_target_name is None:
print("compute_target_name required when target='aks'")
return None
deployment_config = AksWebservice.deploy_configuration(
cpu_cores=cpu_cores,
memory_gb=memory_gb,
compute_target_name=compute_target_name,
auth_enabled=False)
try:
service = Webservice(workspace, name)
except WebserviceException:
service = None
if service is None:
service = Model.deploy(workspace, name, [model], inference_config,
deployment_config)
else:
print(
"Existing service with that name found, updating InferenceConfig\n"
"If you meant to redeploy or change the deployment option, first "
"delete the existing service.")
service.update(models=[model], inference_config=inference_config)
return service
def main():
# Define workspace object
try:
ws = Workspace.from_config(path='deploy/.azureml/config.json')
# Need to create the workspace
except Exception as err:
print('No workspace. Check for deploy/.azureml/config.json file.')
assert False
inference_config = InferenceConfig(runtime="python",
entry_script="score.py",
conda_file="keras_env.yml",
source_directory="./deploy")
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1,
auth_enabled=True, # this flag generates API keys to secure access
memory_gb=6,
location="westus",
tags={
'name': 'yolov3_full',
'framework': 'Keras'
},
description='Keras YOLOv3 full size for object detection')
model = Model(ws, name='mixdata_trained_weights.h5')
# This deploys AND registers model (if not registered)
service = Model.deploy(workspace=ws,
name='keras-yolov3-service',
models=[model],
inference_config=inference_config,
deployment_config=aciconfig)
# This just deploys and does not register
# service = Webservice.deploy_from_model(ws,
# name='keras-yolov3-service',
# models=[model],
# deployment_config=aciconfig)
service.wait_for_deployment(True)
print(service.state)
def main(name, model):
workspace = Workspace.from_config()
model = Model(workspace, name=model)
root_folder = Path(__file__).parent.parent
deployment_config = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1)
inference_config = InferenceConfig(entry_script='customer_churn/score.py',
source_directory=root_folder)
webservice = Model.deploy(workspace=workspace,
name=name,
models=[model],
deployment_config=deployment_config,
inference_config=inference_config)
webservice.wait_for_deployment(show_output=True)
def main(model_name="deploy", model_version=None, deployment_name="deploy"):
"""
Return a AciWebservice deploy config
"""
environment = get_environment(
name=deployment_name,
file_path="nd00333/model/deploy/environment.yml",
)
logger.info(msg="main", extra={"environment": environment})
inference_config = InferenceConfig(
source_directory="nd00333",
entry_script="model/deploy/score.py",
environment=environment,
)
logger.info(msg="main", extra={"inference_config": inference_config})
workspace = package_utils.get_workspace()
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=1.0,
memory_gb=8.0,
auth_enabled=True,
enable_app_insights=True,
collect_model_data=False,
)
logger.info(msg="main", extra={"deployment_config": deployment_config})
model = Model(workspace, name=model_name, version=model_version)
logger.info(msg="main", extra={"model": model})
service = Model.deploy(
workspace,
deployment_name,
[model],
inference_config,
deployment_config,
overwrite=True,
)
logger.info(msg="main", extra={"service": service})
return service
def main():
ws = Workspace.get(name=WORKSPACE_NAME,
subscription_id=SUBSCRIPTION_ID,
resource_group=RESOURCE_GROUP)
print("connect")
model = Model.register(model_path=os.path.join(
os.getcwd(), "retailai_recommendation_model.zip"),
model_name="retailai_recommendation_model",
description="Retail.AI Item-Based Recommender",
workspace=ws)
print("model registered")
myenv = Environment.from_conda_specification(name='myenv',
file_path="environment.yml")
myenv.docker.base_image = "mcr.microsoft.com/mmlspark/release"
myenv.inferencing_stack_version = 'latest'
print("Environment Configured")
inference_config = InferenceConfig(entry_script='score.py',
environment=myenv)
aks_target_name = AKS_CLUSTER_NAME
try:
aks_target = AksCompute(ws, aks_target_name)
print(aks_target)
except ComputeTargetException as err:
aks_target = attachAksComputeToWorkspace(ws, RESOURCE_GROUP,
AKS_CLUSTER_NAME,
aks_target_name, True)
print(aks_target)
except Exception as err:
print(err)
sys.exit()
try:
deployToAks(ws, aks_target, "retail-ai-item-recommender", model,
inference_config, True)
except Exception as err:
print(err)
sys.exit()
def main():
workspace_name = os.environ['AML_WORKSPACE_NAME']
resource_group = os.environ['RESOURCE_GROUP']
subscription_id = os.environ['SUBSCRIPTION_ID']
spn_credentials = {
'tenant_id': os.environ['TENANT_ID'],
'service_principal_id': os.environ['SPN_ID'],
'service_principal_password': os.environ['SPN_PASSWORD'],
}
aml_interface = AMLInterface(spn_credentials, subscription_id,
workspace_name, resource_group)
scoring_script_path = os.path.join(__here__, 'score.py')
aml_env = Environment.get(workspace=aml_interface.workspace,
name=AML_ENV_NAME)
service_name = 'aml-pipeline-deploy-3'
inference_config = InferenceConfig(entry_script=scoring_script_path,
environment=aml_env)
deploy(aml_interface, inference_config, service_name)
def get_config(entry_script):
# Create the environment
env = Environment(name="tensorflow_env")
conda_dep = CondaDependencies()
# Define the packages needed by the model and scripts
conda_dep.add_conda_package("tensorflow")
# You must list azureml-defaults as a pip dependency
conda_dep.add_pip_package("azureml-defaults")
conda_dep.add_pip_package("keras")
conda_dep.add_pip_package("pandas")
# Adds dependencies to PythonSection of myenv
env.python.conda_dependencies = conda_dep
inference_config = InferenceConfig(entry_script=entry_script,
environment=env)
print('Configuração do Endpoint retornada')
return inference_config
def main(args, ws):
dir = os.path.dirname(os.path.abspath(__file__))
ic = InferenceConfig(runtime='python',
source_directory=dir,
entry_script='score.py',
conda_file='environment.yml')
dc = AciWebservice.deploy_configuration(cpu_cores=args.cores,
memory_gb=args.memory)
m = ws.models[args.model_name]
# Remove any existing service under the same name.
try:
Webservice(ws, args.service_name).delete()
print(f'Deleted webservice with name {args.service_name}.')
except WebserviceException:
pass
service = Model.deploy(ws, args.service_name, [m], ic, dc)
service.wait_for_deployment(True)
print(service.state)
print(service.get_logs())
def deploy_models():
aciconfig = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=1,
tags={
"data": "Earthquake",
"method": "sklearn"
},
description='Predict aftershock situation '
'using linear models in sklearn')
# env = Environment('aftershock-env')
# cd = CondaDependencies.create(pip_packages=['azureml-dataset-runtime[pandas,fuse]',
# 'azureml-defaults'],
# conda_packages=['scikit-learn==0.24.2'])
# env.python.conda_dependencies = cd
env = Environment.get(workspace=ws, name='aftershock-env')
inference_config = InferenceConfig(entry_script="predict.py",
environment=env)
model = Model(ws, "aftershock_model")
# service_name = 'sklearn-aftershock-svc-' + str(uuid.uuid4())[:4]
service_name = "sklearn-aftershock-svc-f41b"
service = Model.deploy(workspace=ws,
name=service_name,
models=[model],
overwrite=True,
inference_config=inference_config,
deployment_config=aciconfig)
service.wait_for_deployment(show_output=True)
print(service.get_logs())
print(service.scoring_uri)
print("service keys")
print(service.get_keys())
print("service token")
print(service.get_token())
def file_to_inference_config(workspace, inference_config_file, description):
with open(inference_config_file) as inference_file_stream:
inference_config_obj = file_stream_to_object(inference_file_stream)
# Retrieve Environment object from the name in the InferenceConfig file
if 'environment' not in inference_config_obj:
raise OMLException("need to specify environment in --deploy-config-file")
environment_name = inference_config_obj.get('environment')["name"]
environment = Environment.get(workspace, name=environment_name)
inference_config = InferenceConfig(
entry_script=inference_config_obj.get('entryScript'),
runtime=inference_config_obj.get('runtime'),
conda_file=inference_config_obj.get('condaFile'),
extra_docker_file_steps=inference_config_obj.get('extraDockerfileSteps'),
source_directory=inference_config_obj.get('sourceDirectory'),
enable_gpu=inference_config_obj.get('enableGpu'),
base_image=inference_config_obj.get('baseImage'),
base_image_registry=inference_config_obj.get('baseImageRegistry'),
cuda_version=inference_config_obj.get('cudaVersion'),
environment=environment,
description=description)
return inference_config
def deploy_local(self):
try:
LocalWebservice(self.ws, "test").delete()
print("webservice deleted")
except WebserviceException:
pass
shoes_designer_env = Environment('shoes_designer_env')
shoes_designer_env.python.conda_dependencies.add_pip_package("joblib")
shoes_designer_env.python.conda_dependencies.add_pip_package("torch")
shoes_designer_env.python.conda_dependencies.add_pip_package("torchvision")
shoes_designer_env.python.conda_dependencies.add_pip_package("azure-storage-blob")
shoes_designer_env.python.conda_dependencies.add_pip_package("azureml-sdk")
shoes_designer_env.python.conda_dependencies.add_pip_package("PyYAML")
shoes_designer_env.python.conda_dependencies.add_pip_package("scikit-learn")
shoes_designer_env.python.conda_dependencies.add_pip_package("matplotlib")
conda_dep.add_pip_package("opencensus-ext-azure")
# explicitly set base_image to None when setting base_dockerfile
shoes_designer_env.docker.base_image = None
shoes_designer_env.docker.base_dockerfile = "FROM mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04\nRUN echo \"this is test\""
shoes_designer_env.inferencing_stack_version = "latest"
inference_config = InferenceConfig(entry_script="score.py",environment=shoes_designer_env)
model = self.ws.models[self.MODEL_NAME]
# This is optional, if not provided Docker will choose a random unused port.
deployment_config = LocalWebservice.deploy_configuration(port=6789)
local_service = Model.deploy(self.ws, "test", [model], inference_config, deployment_config)
local_service.wait_for_deployment()
print("success deployement")
return local_service
def deploy():
parser = argparse.ArgumentParser()
parser.add_argument("--model_name", required=True)
parser.add_argument("--model_path", required=True)
args = parser.parse_args()
print(f"model_name : {args.model_name}")
print(f"model_path: {args.model_path}")
run = Run.get_context()
ws = run.experiment.workspace
model = Model.register(workspace=ws,
model_path=args.model_path,
model_name=args.model_name)
print("Registered version {0} of model {1}".format(model.version,
model.name))
inference_config = InferenceConfig(
entry_script='score.py',
runtime='python',
conda_file='conda.yml',
extra_docker_file_steps='extra_docker_steps',
source_directory='server_files/')
deployment_config = AciWebservice.deploy_configuration(cpu_cores=0.1,
memory_gb=0.5,
auth_enabled=True)
try:
service = AciWebservice(ws, "testscorescriptauto")
service.update(models=[model])
print("EXISTING ENDPOINT FOUND: MODEL UPDATED")
except Exception:
Model.deploy(ws, "testscorescriptauto", [model], inference_config,
deployment_config)
print("NO EXISTING ENDPOINT FOUND: DEPLOYED MODEL TO NEW ENDPOINT")
