cpu_cores=0.1,
memory_gb=0.5,
tags={"method": "sklearn"},
description='Predict MoA activation with sklearn')
# Despliegue local mediante docker
#deployment_config = LocalWebservice.deploy_configuration(port=6789)
ws = Workspace.from_config()
model = Model(ws, args.model_name, version=args.model_version)
print(model.name, model.id, model.version, sep='\t')
# Creciación de azure constainer con ambiente gestionado mediante conda.
myenv = Environment(name="envmoa")
# Se habilita docker
myenv.docker.enabled = True
# Definición de dependencias de docker.
myenv.python.conda_dependencies = CondaDependencies.create(
conda_packages=['scikit-learn'],
pip_packages=[
'azureml-defaults', 'numpy', 'pandas', 'scikit-multilearn'
])
inf_config = InferenceConfig(environment=myenv,
source_directory='./src',
entry_script='entry.py')
service = Model.deploy(ws, "moa-webservice-v7", [model], inf_config,
deployment_config)
service.wait_for_deployment(show_output=True)
print(service.get_logs())
def main():
# Loading input values
print("::debug::Loading input values")
model_name = os.environ.get("INPUT_MODEL_NAME", default=None)
model_version = os.environ.get("INPUT_MODEL_VERSION", default=None)
# Casting input values
print("::debug::Casting input values")
try:
model_version = int(model_version)
except TypeError as exception:
print(f"::debug::Could not cast model version to int: {exception}")
model_version = None
except ValueError as exception:
print(f"::debug::Could not cast model version to int: {exception}")
model_version = None
# Loading azure credentials
print("::debug::Loading azure credentials")
azure_credentials = os.environ.get("INPUT_AZURE_CREDENTIALS", default="{}")
try:
azure_credentials = json.loads(azure_credentials)
except JSONDecodeError:
print(
"::error::Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS"
)
raise AMLConfigurationException(
"Incorrect or poorly formed output from azure credentials saved in AZURE_CREDENTIALS secret. See setup in https://github.com/Azure/aml-compute/blob/master/README.md"
)
# Checking provided parameters
print("::debug::Checking provided parameters")
validate_json(data=azure_credentials,
schema=azure_credentials_schema,
input_name="AZURE_CREDENTIALS")
# Mask values
print("::debug::Masking parameters")
mask_parameter(parameter=azure_credentials.get("tenantId", ""))
mask_parameter(parameter=azure_credentials.get("clientId", ""))
mask_parameter(parameter=azure_credentials.get("clientSecret", ""))
mask_parameter(parameter=azure_credentials.get("subscriptionId", ""))
# Loading parameters file
print("::debug::Loading parameters file")
parameters_file = os.environ.get("INPUT_PARAMETERS_FILE",
default="deploy.json")
parameters_file_path = os.path.join(".cloud", ".azure", parameters_file)
try:
with open(parameters_file_path) as f:
parameters = json.load(f)
except FileNotFoundError:
print(
f"::debug::Could not find parameter file in {parameters_file_path}. Please provide a parameter file in your repository if you do not want to use default settings (e.g. .cloud/.azure/deploy.json)."
)
parameters = {}
# Checking provided parameters
print("::debug::Checking provided parameters")
validate_json(data=parameters,
schema=parameters_schema,
input_name="PARAMETERS_FILE")
# Define target cloud
if azure_credentials.get(
"resourceManagerEndpointUrl",
"").startswith("https://management.usgovcloudapi.net"):
cloud = "AzureUSGovernment"
elif azure_credentials.get(
"resourceManagerEndpointUrl",
"").startswith("https://management.chinacloudapi.cn"):
cloud = "AzureChinaCloud"
else:
cloud = "AzureCloud"
# Loading Workspace
print("::debug::Loading AML Workspace")
sp_auth = ServicePrincipalAuthentication(
tenant_id=azure_credentials.get("tenantId", ""),
service_principal_id=azure_credentials.get("clientId", ""),
service_principal_password=azure_credentials.get("clientSecret", ""),
cloud=cloud)
config_file_path = os.environ.get("GITHUB_WORKSPACE",
default=".cloud/.azure")
config_file_name = "aml_arm_config.json"
try:
ws = Workspace.from_config(path=config_file_path,
_file_name=config_file_name,
auth=sp_auth)
except AuthenticationException as exception:
print(
f"::error::Could not retrieve user token. Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS: {exception}"
)
raise AuthenticationException
except AuthenticationError as exception:
print(f"::error::Microsoft REST Authentication Error: {exception}")
raise AuthenticationError
except AdalError as exception:
print(
f"::error::Active Directory Authentication Library Error: {exception}"
)
raise AdalError
except ProjectSystemException as exception:
print(f"::error::Workspace authorizationfailed: {exception}")
raise ProjectSystemException
# Loading model
print("::debug::Loading model")
try:
model = Model(workspace=ws, name=model_name, version=model_version)
except WebserviceException as exception:
print(
f"::error::Could not load model with provided details: {exception}"
)
raise AMLConfigurationException(
f"Could not load model with provided details: {exception}")
# Creating inference config
print("::debug::Creating inference config")
if os.environ.get("CONTAINER_REGISTRY_ADRESS", None) is not None:
container_registry = ContainerRegistry()
container_registry.address = os.environ.get(
"CONTAINER_REGISTRY_ADRESS", None)
container_registry.username = os.environ.get(
"CONTAINER_REGISTRY_USERNAME", None)
container_registry.password = os.environ.get(
"CONTAINER_REGISTRY_PASSWORD", None)
else:
container_registry = None
try:
inference_config = InferenceConfig(
entry_script=parameters.get("inference_entry_script", "score.py"),
runtime=parameters.get("runtime", "python"),
conda_file=parameters.get("conda_file", "environment.yml"),
extra_docker_file_steps=parameters.get("extra_docker_file_steps",
None),
source_directory=parameters.get("inference_source_directory",
"code/deploy/"),
enable_gpu=parameters.get("enable_gpu", None),
description=parameters.get("description", None),
base_image=parameters.get("custom_base_image", None),
base_image_registry=container_registry,
cuda_version=parameters.get("cuda_version", None))
except WebserviceException as exception:
print(
f"::debug::Failed to create InferenceConfig. Trying to create no code deployment: {exception}"
)
inference_config = None
except TypeError as exception:
print(
f"::debug::Failed to create InferenceConfig. Trying to create no code deployment: {exception}"
)
inference_config = None
# Skip deployment if only Docker image should be created
if not parameters.get("skip_deployment", False):
# Default service name
repository_name = os.environ.get("GITHUB_REPOSITORY").split("/")[-1]
branch_name = os.environ.get("GITHUB_REF").split("/")[-1]
default_service_name = f"{repository_name}-{branch_name}".lower(
).replace("_", "-")
service_name = parameters.get("name", default_service_name)[:32]
# Loading run config
print("::debug::Loading run config")
model_resource_config = model.resource_configuration
cpu_cores = get_resource_config(config=parameters.get(
"cpu_cores", None),
resource_config=model_resource_config,
config_name="cpu")
memory_gb = get_resource_config(config=parameters.get(
"memory_gb", None),
resource_config=model_resource_config,
config_name="memory_in_gb")
gpu_cores = get_resource_config(config=parameters.get(
"gpu_cores", None),
resource_config=model_resource_config,
config_name="gpu")
# Profiling model
print("::debug::Profiling model")
if parameters.get("profiling_enabled", False):
# Getting profiling dataset
profiling_dataset = get_dataset(workspace=ws,
name=parameters.get(
"profiling_dataset", None))
if profiling_dataset is None:
profiling_dataset = model.sample_input_dataset
# Profiling model
try:
model_profile = Model.profile(
workspace=ws,
profile_name=f"{service_name}-profile"[:32],
models=[model],
inference_config=inference_config,
input_dataset=profiling_dataset)
model_profile.wait_for_completion(show_output=True)
# Overwriting resource configuration
cpu_cores = model_profile.recommended_cpu
memory_gb = model_profile.recommended_memory
# Setting output
profiling_details = model_profile.get_details()
print(
f"::set-output name=profiling_details::{profiling_details}"
)
except Exception as exception:
print(
f"::warning::Failed to profile model. Skipping profiling and moving on to deployment: {exception}"
)
# Loading deployment target
print("::debug::Loading deployment target")
try:
deployment_target = ComputeTarget(workspace=ws,
name=parameters.get(
"deployment_compute_target",
""))
except ComputeTargetException:
deployment_target = None
except TypeError:
deployment_target = None
# Creating deployment config
print("::debug::Creating deployment config")
if type(deployment_target) is AksCompute:
deployment_config = AksWebservice.deploy_configuration(
autoscale_enabled=parameters.get("autoscale_enabled", None),
autoscale_min_replicas=parameters.get("autoscale_min_replicas",
None),
autoscale_max_replicas=parameters.get("autoscale_max_replicas",
None),
autoscale_refresh_seconds=parameters.get(
"autoscale_refresh_seconds", None),
autoscale_target_utilization=parameters.get(
"autoscale_target_utilization", None),
collect_model_data=parameters.get(
"model_data_collection_enabled", None),
auth_enabled=parameters.get("authentication_enabled", None),
cpu_cores=cpu_cores,
memory_gb=memory_gb,
enable_app_insights=parameters.get("app_insights_enabled",
None),
scoring_timeout_ms=parameters.get("scoring_timeout_ms", None),
replica_max_concurrent_requests=parameters.get(
"replica_max_concurrent_requests", None),
max_request_wait_time=parameters.get("max_request_wait_time",
None),
num_replicas=parameters.get("num_replicas", None),
primary_key=os.environ.get("PRIMARY_KEY", None),
secondary_key=os.environ.get("SECONDARY_KEY", None),
tags=parameters.get("tags", None),
properties=parameters.get("properties", None),
description=parameters.get("description", None),
gpu_cores=gpu_cores,
period_seconds=parameters.get("period_seconds", None),
initial_delay_seconds=parameters.get("initial_delay_seconds",
None),
timeout_seconds=parameters.get("timeout_seconds", None),
success_threshold=parameters.get("success_threshold", None),
failure_threshold=parameters.get("failure_threshold", None),
namespace=parameters.get("namespace", None),
token_auth_enabled=parameters.get("token_auth_enabled", None))
else:
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=cpu_cores,
memory_gb=memory_gb,
tags=parameters.get("tags", None),
properties=parameters.get("properties", None),
description=parameters.get("description", None),
location=parameters.get("location", None),
auth_enabled=parameters.get("authentication_enabled", None),
ssl_enabled=parameters.get("ssl_enabled", None),
enable_app_insights=parameters.get("app_insights_enabled",
None),
ssl_cert_pem_file=parameters.get("ssl_cert_pem_file", None),
ssl_key_pem_file=parameters.get("ssl_key_pem_file", None),
ssl_cname=parameters.get("ssl_cname", None),
dns_name_label=parameters.get("dns_name_label", None),
primary_key=os.environ.get("PRIMARY_KEY", None),
secondary_key=os.environ.get("SECONDARY_KEY", None),
collect_model_data=parameters.get(
"model_data_collection_enabled", None),
cmk_vault_base_url=os.environ.get("CMK_VAULT_BASE_URL", None),
cmk_key_name=os.environ.get("CMK_KEY_NAME", None),
cmk_key_version=os.environ.get("CMK_KEY_VERSION", None))
# Deploying model
print("::debug::Deploying model")
try:
service = Model.deploy(workspace=ws,
name=service_name,
models=[model],
inference_config=inference_config,
deployment_config=deployment_config,
deployment_target=deployment_target,
overwrite=True)
service.wait_for_deployment(show_output=True)
except WebserviceException as exception:
print(
f"::error::Model deployment failed with exception: {exception}"
)
service_logs = service.get_logs()
raise AMLDeploymentException(
f"Model deployment failed logs: {service_logs} \nexception: {exception}"
)
# Checking status of service
print("::debug::Checking status of service")
if service.state != "Healthy":
service_logs = service.get_logs()
print(
f"::error::Model deployment failed with state '{service.state}': {service_logs}"
)
raise AMLDeploymentException(
f"Model deployment failed with state '{service.state}': {service_logs}"
)
if parameters.get("test_enabled", False):
# Testing service
print("::debug::Testing service")
root = os.environ.get("GITHUB_WORKSPACE", default=None)
test_file_path = parameters.get("test_file_path",
"code/test/test.py")
test_file_function_name = parameters.get("test_file_function_name",
"main")
print("::debug::Adding root to system path")
sys.path.insert(1, f"{root}")
print("::debug::Importing module")
test_file_path = f"{test_file_path}.py" if not test_file_path.endswith(
".py") else test_file_path
try:
test_spec = importlib.util.spec_from_file_location(
name="testmodule", location=test_file_path)
test_module = importlib.util.module_from_spec(spec=test_spec)
test_spec.loader.exec_module(test_module)
test_function = getattr(test_module, test_file_function_name,
None)
except ModuleNotFoundError as exception:
print(
f"::error::Could not load python script in your repository which defines theweb service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
raise AMLConfigurationException(
f"Could not load python script in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
except FileNotFoundError as exception:
print(
f"::error::Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
raise AMLConfigurationException(
f"Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
except AttributeError as exception:
print(
f"::error::Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
raise AMLConfigurationException(
f"Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
# Load experiment config
print("::debug::Loading experiment config")
try:
test_function(service)
except TypeError as exception:
print(
f"::error::Could not load experiment config from your module (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
raise AMLConfigurationException(
f"Could not load experiment config from your module (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}"
)
except Exception as exception:
print(
f"::error::The webservice tests did not complete successfully: {exception}"
)
raise AMLDeploymentException(
f"The webservice tests did not complete successfully: {exception}"
)
# Deleting service if desired
if parameters.get("delete_service_after_deployment", False):
service.delete()
else:
# Creating outputs
print("::debug::Creating outputs")
print(
f"::set-output name=service_scoring_uri::{service.scoring_uri}"
)
print(
f"::set-output name=service_swagger_uri::{service.swagger_uri}"
)
# Creating Docker image
if parameters.get("create_image", None) is not None:
try:
# Packaging model
if parameters.get("create_image", None) == "docker":
package = Model.package(workspace=ws,
models=[model],
inference_config=inference_config,
generate_dockerfile=False)
if parameters.get("create_image", None) == "function_blob":
package = package_blob(
workspace=ws,
models=[model],
inference_config=inference_config,
generate_dockerfile=False,
input_path=os.environ.get("FUNCTION_BLOB_INPUT"),
output_path=os.environ.get("FUNCTION_BLOB_OUTPUT"))
if parameters.get("create_image", None) == "function_http":
package = package_http(
workspace=ws,
models=[model],
inference_config=inference_config,
generate_dockerfile=False,
auth_level=os.environ.get("FUNCTION_HTTP_AUTH_LEVEL"))
if parameters.get("create_image",
None) == "function_service_bus_queue":
package = package_service_bus_queue(
workspace=ws,
models=[model],
inference_config=inference_config,
generate_dockerfile=False,
input_queue_name=os.environ.get(
"FUNCTION_SERVICE_BUS_QUEUE_INPUT"),
output_queue_name=os.environ.get(
"FUNCTION_SERVICE_BUS_QUEUE_OUTPUT"))
# Getting container registry details
acr = package.get_container_registry()
mask_parameter(parameter=acr.address)
mask_parameter(parameter=acr.username)
mask_parameter(parameter=acr.password)
# Wait for completion and pull image
package.wait_for_creation(show_output=True)
# Creating additional outputs
print("::debug::Creating outputs")
print(f"::set-output name=acr_address::{acr.address}")
print(f"::set-output name=acr_username::{acr.username}")
print(f"::set-output name=acr_password::{acr.password}")
print(f"::set-output name=package_location::{package.location}")
except WebserviceException as exception:
print(
f"::error::Image creation failed with exception: {exception}")
package_logs = package.get_logs()
raise AMLDeploymentException(
f"Image creation failed with logs: {package_logs}")
print(
"::debug::Successfully finished Azure Machine Learning Deploy Action")
from azureml.core import Workspace, Model, Environment
from azureml.core.model import InferenceConfig
from azureml.core.webservice import AciWebservice
model_name = "churn_model_GR"
service_name = 'full-model-test'
score_filename = "score.py"
ws = Workspace.from_config()
env = Environment.from_conda_specification(name="simple_env",
file_path="conda_env.yaml")
inference_config = InferenceConfig(entry_script=score_filename,
environment=env)
aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)
model = Model(workspace=ws, name=model_name)
service = Model.deploy(workspace=ws,
name=service_name,
models=[model],
inference_config=inference_config,
deployment_config=aci_config,
overwrite=True)
service.wait_for_deployment(show_output=True)
'--model_version',
type=int,
default=1,
help='Versión del modelo en AzureML'
)
args = parser.parse_args()
deployment_config = AciWebservice.deploy_configuration(cpu_cores=0.1,
memory_gb=0.5,
tags={"data": "Hearth", "method" : "sklearn"},
description='Predict MoA activation with sklearn')
# Despliegue local mediante docker
#deployment_config = LocalWebservice.deploy_configuration(port=6789)
ws = Workspace.from_config()
model = Model(ws, args.model_name, version=args.model_version)
print(model.name, model.id, model.version, sep='\t')
# Creciación de azure constainer con ambiente gestionado mediante conda.
myenv = Environment(name="myenv")
# Se habilita docker
myenv.docker.enabled = True
# Definición de dependencias de docker.
myenv.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],
pip_packages=['azureml-defaults', 'numpy', 'pandas'])
inf_config = InferenceConfig(environment=myenv, source_directory='./src', entry_script='entry.py')
service = Model.deploy(ws, "MoA-webservice", [model], inf_config, deployment_config)
service.wait_for_deployment(show_output=True)
print(service.get_logs())
ws = run.experiment.workspace
service_name = "trump-tweets-scoring-aml"
model_name = "trump-tweet-classification"
# getting last model
model = next(
iter(Model.list(workspace=ws, name=model_name, latest=True)),
None,
)
environment = Environment("trump-tweet-inferencing")
conda_dep = CondaDependencies()
conda_dep.add_conda_package("scikit-learn")
conda_dep.add_pip_package("azureml-sdk")
environment.python.conda_dependencies = conda_dep
aks_target = AksCompute(ws, "trump-tweets-inf")
deployment_config = AksWebservice.deploy_configuration(cpu_cores=2,
memory_gb=8)
inference_config = InferenceConfig(entry_script="score.py",
environment=environment)
service = Model.deploy(ws,
service_name, [model],
inference_config,
deployment_config,
aks_target,
overwrite=True)
service.wait_for_deployment(show_output=True)
with open(script_file_name, 'r') as cefr1:
content1 = cefr1.read()
print(content1)
model_list = json.loads(args.model_names)
print(model_list)
run = Run.get_context()
ws = run.experiment.workspace
deployment_config = AciWebservice.deploy_configuration(
cpu_cores=1,
memory_gb=2,
tags={"method": "grouping"},
description='grouping demo aci deployment')
inference_config = InferenceConfig(entry_script=script_file_name,
runtime='python',
conda_file=conda_env_file_name)
models = []
for model_name in model_list:
models.append(Model(ws, name=model_name))
service = Model.deploy(ws,
name=args.service_name,
models=models,
inference_config=inference_config,
deployment_config=deployment_config)
service.wait_for_deployment(True)
environment = Environment('env')
conda_packages = ['pytorch', 'torchvision']
pip_packages = ['azureml-defaults'] + pip_packages
environment.python.conda_dependencies = CondaDependencies.create(
pip_packages=pip_packages, conda_packages=conda_packages)
inference_config = InferenceConfig(entry_script='src/infer.py',
source_directory='.',
environment=environment)
# Create or update service
service_name = f'{args.project_name}-{env}'.replace('_', '-')
## Create web service
service = Model.deploy(workspace=ws,
name=service_name,
models=models,
inference_config=inference_config,
deployment_config=compute_config,
overwrite=True)
logging.warning('[INFO] Creating web service')
service.wait_for_deployment(show_output=args.show_output)
# Get service details
logging.warning(service.get_keys)
# Test service
try:
service.run(
json.dumps([{
"body":
"Mein Windows Vista rechner will nicht mehr - ich kriege dauernd fehler meldungen. Ich wollte mir eh einen neuen kaufen, aber ich hab kein Geld. Kann Bill Gates mir helfen?"
}]))
env_file = folder_name + "/diabetes_env.yml"
with open(env_file,"w") as f:
f.write(myenv.serialize_to_string())
print("Saved dependency info in", env_file)
# Print the .yml file
with open(env_file,"r") as f:
print(f.read())
#Deploy web service
from azureml.core.webservice import AciWebservice
from azureml.core.model import InferenceConfig
# Configure the scoring environment
inference_config = InferenceConfig(runtime= "python",
source_directory = folder_name,
entry_script="score_diabetes.py",
conda_file="diabetes_env.yml")
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
service_name = "diabetes-service"
service = Model.deploy(ws, service_name, [model], inference_config, deployment_config)
service.wait_for_deployment(True)
print(service.state)
