def Azure_ML_experiment():
# create experiment
experiment_name = 'aftershock-model-train'
exp = Experiment(workspace=ws, name=experiment_name)
# creation of compute task
compute_target = create_compute_resource(ws)
# to install required packages
env = Environment('aftershock-env-01')
cd = CondaDependencies.create(pip_packages=[
'azureml-dataset-runtime[pandas,fuse]', 'azureml-defaults'
],
conda_packages=['scikit-learn==0.24.2'])
env.python.conda_dependencies = cd
src = ScriptRunConfig(source_directory=os.getcwd(),
script='train.py',
arguments=[],
compute_target=compute_target,
environment=env)
# submit the train script to the experiment
run = exp.submit(config=src)
print(run.get_file_names())
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_run_config(self,
compute_target,
channels=None,
conda_packages=None,
pip_packages=None):
# Load the "cpu-dsvm.runconfig" file (created by the above attach operation) in memory
run_config = RunConfiguration(framework="python")
# Set compute target to the Linux DSVM
run_config.target = compute_target.name
# Use Docker in the remote VM
run_config.environment.docker.enabled = False
# Ask system to provision a new one based on the conda_dependencies.yml file
run_config.environment.python.user_managed_dependencies = False
# Prepare the Docker and conda environment automatically when used the first time.
run_config.auto_prepare_environment = True
# specify dependencies obj
conda_dependencies = CondaDependencies.create(
conda_packages=conda_packages, pip_packages=pip_packages)
if (channels):
for channel in channels:
conda_dependencies.add_channel(channel)
run_config.environment.python.conda_dependencies = conda_dependencies
return run_config
def main(workspace,inputs):
print("Loading compute target")
compute_target = ComputeTarget(
workspace=workspace,
name=inputs["compute"]
)
# create a new runconfig object
run_config = RunConfiguration()
# enable Docker
run_config.environment.docker.enabled = True
# set Docker base image to the default CPU-based image
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE
# use conda_dependencies.yml to create a conda environment in the Docker image for execution
run_config.environment.python.user_managed_dependencies = False
# specify CondaDependencies obj
run_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'])
# For this step, we use yet another source_directory
step = PythonScriptStep(name=inputs["step_name"],
script_name=inputs["train_script"],
compute_target=compute_target,
source_directory=inputs["source_directory"],
runconfig=run_config,
allow_reuse=True)
return step
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 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 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 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 _get_conda_deps(self, step):
"""
converts requirements.txt from user into conda dependencies for AzML
:param dict step: step defined by user that we are currently building
:returns: conda_dependencies
:rtype: CondaDependencies
"""
with open(step["requirements"], "r") as f:
packages = [line.strip() for line in f]
return CondaDependencies.create(pip_packages=packages)
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 get_automl_environment():
from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_CPU_IMAGE
train_env = Environment(name="many_models_environment_automl")
train_conda_deps = CondaDependencies.create(
pip_packages=['azureml-sdk[automl]', 'joblib', 'pyarrow==0.14'])
train_conda_deps.add_conda_package('pandas==0.23.4')
train_conda_deps.add_conda_package('numpy==1.16.2')
train_conda_deps.add_conda_package('fbprophet==0.5')
train_conda_deps.add_conda_package('py-xgboost==0.90')
train_env.python.conda_dependencies = train_conda_deps
train_env.docker.enabled = True
train_env.docker.base_image = DEFAULT_CPU_IMAGE
return train_env
def executeAction(self, experiment, project_folder, training_Script,
cpu_cluster, github_SHA):
#TODO: take environment as input from user for reusing it, may be useful when resubmitting the experiment.
myenv = Environment("myenv")
myenv.docker.enabled = True
myenv.python.conda_dependencies = CondaDependencies.create(
conda_packages=['scikit-learn'])
src = ScriptRunConfig(source_directory=project_folder,
script=training_Script)
# Set compute target to the one created in previous step
src.run_config.target = cpu_cluster.name
# Set environment
src.run_config.environment = myenv
tags = {"github_SHA": github_SHA}
run = experiment.submit(config=src, tags=tags)
def create_lightgbm_conda_file(conda_file: str = "lgbmenv.yml"):
"""
Create new Conda File with LightGBM requirements.
:param conda_file: filename of LightGBM conda file, which is created during call.
"""
conda_pack = ["scikit-learn==0.19.1", "pandas==0.23.3"]
requirements = [
"lightgbm==2.1.2",
"azureml-defaults==1.0.57",
"azureml-contrib-services",
"Microsoft-AI-Azure-Utility-Samples",
]
lgbmenv = CondaDependencies.create(
conda_packages=conda_pack, pip_packages=requirements
)
with open(conda_file, "w") as file:
file.write(lgbmenv.serialize_to_string())
def data_preprocess_step(raw_data_dir, compute_target):
run_config = RunConfiguration()
run_config.environment.python.conda_dependencies = CondaDependencies.create(
pip_packages=['pandas'])
run_config.environment.docker.enabled = True
train_dir = PipelineData(name='train_dir',
pipeline_output_name='train_dir',
datastore=raw_data_dir.datastore,
output_mode='mount',
is_directory=True)
test_dir = PipelineData(name='test_dir',
pipeline_output_name='test_dir',
datastore=raw_data_dir.datastore,
output_mode='mount',
is_directory=True)
outputs = [train_dir, test_dir]
outputs_map = {
'train_dir': train_dir,
'test_dir': test_dir,
}
step = PythonScriptStep(script_name='data_preprocess.py',
arguments=[
'--raw_data_dir',
raw_data_dir,
'--train_dir',
train_dir,
'--test_dir',
test_dir,
],
inputs=[raw_data_dir],
outputs=outputs,
compute_target=compute_target,
runconfig=run_config,
source_directory=os.path.dirname(
os.path.abspath(__file__)),
allow_reuse=True)
return step, outputs_map
def create_conda_environment(workspace, name, conda_dependencies,
pip_dependencies):
"""
Create an environment or retrieve it by its name from workspace
Pip installs Python packages whereas conda installs packages which may contain software written in any language.
e.g. TensorFlow, Scikit-Learn -> Conda, Matplotlib -> pip
"""
if name in Environment.list(workspace):
env = Environment.get(workspace=workspace, name=name)
print("The environment '{}' already existed for the workspace".format(
name))
else:
env = Environment(name=name)
env.docker.enabled = True
env.python.conda_dependencies = CondaDependencies.create(
conda_packages=conda_dependencies,
pip_packages=pip_dependencies,
)
env.register(workspace=workspace)
return env
def get_automl_environment():
from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_CPU_IMAGE
train_env = Environment(name="many_models_environment_automl")
train_conda_deps = CondaDependencies.create(
pip_packages=['azureml-sdk[automl]', 'pyarrow==0.14'])
train_conda_deps.add_pip_package('py-cpuinfo==5.0.0')
train_conda_deps.add_conda_package('psutil')
train_conda_deps.add_conda_package('pandas==0.23.4')
train_conda_deps.add_conda_package('numpy==1.16.2')
train_conda_deps.add_conda_package('fbprophet==0.5')
train_conda_deps.add_conda_package('py-xgboost==0.90')
train_env.python.conda_dependencies = train_conda_deps
train_env.docker.enabled = True
train_env.docker.base_image = DEFAULT_CPU_IMAGE
env = {}
env['AZUREML_FLUSH_INGEST_WAIT'] = ''
train_env.environment_variables = env
return train_env
def mi_run_config(ws, compute):
whl_url = Environment.add_private_pip_wheel(workspace=ws,
file_path=d.WHL_VINX_AZURE_ML,
exist_ok=True)
run_config = RunConfiguration()
run_config.target = compute
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = None
run_config.environment.docker.base_dockerfile = 'FROM mcr.microsoft.com/azureml/base:latest\nRUN apt-get update && apt-get -y install freetds-dev freetds-bin vim gcc'
run_config.environment.python.user_managed_dependencies = False
run_config.environment.python.conda_dependencies = CondaDependencies.create(
conda_packages=[
'tqdm', 'cython', 'matplotlib', 'scikit-learn', 'fbprophet'
],
pip_packages=[
'azureml-sdk', 'pandas', 'lightgbm', 'scipy==1.4.1', 'statsmodels',
'mlxtend', 'optuna', 'xgboost', 'CatBoost', 'tensorflow', 'keras',
'jpholiday', 'joblib', 'pymssql==2.1.1'
],
pin_sdk_version=False)
run_config.environment.python.conda_dependencies.add_pip_package(whl_url)
return run_config
from azureml.core import RunConfiguration, ScriptRunConfig, Dataset, Workspace, Environment
from azureml.core.runconfig import Data, DataLocation, Dataset as RunDataset
from azureml.core.script_run_config import get_run_config_from_script_run
from azureml.core.conda_dependencies import CondaDependencies
# Connect to the workspace
ws = Workspace.from_config()
# Create a new environment and set Conda dependencies
conda_env = Environment('conda-env')
conda_env.python.conda_dependencies = CondaDependencies.create(
pin_sdk_version=False,
pip_packages=[
'scikit-learn',
'azureml-sdk',
'azureml-dataprep[pandas,fuse]'
])
# Get the dataset that will be used
dataset = Dataset.get_by_name(ws, 'mnist-dataset')
# Define the environment variable/where data will be mounted
input_name = 'mnist'
# Define the name of the compute target for training
compute_name = 'cpu-cluster'
# Define the script run config
src = ScriptRunConfig(
source_directory='scripts',
script='train.py',
arguments=[
'--data-folder',
compute_target.wait_for_completion(show_output=True,
min_node_count=None,
timeout_in_minutes=20)
# In[41]:
#prepare the runtime
from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
run_config = RunConfiguration(framework="python")
run_config.target = compute_target
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = azureml.core.runconfig.DEFAULT_CPU_IMAGE
dependencies = CondaDependencies.create(
pip_packages=["scikit-learn", "scipy", "numpy"])
run_config.environment.python.conda_dependencies = dependencies
# NOT xplainabe
# automl_config = AutoMLConfig(task='classification',
# debug_log='automl_errors.log',
# path=project_folder,
# compute_target=compute_target,
# run_configuration=run_config,
# X = X, ##use the remote uploaded data
# y = y,
# **automl_settings,
# )
#
# #explainability
# automl_config = AutoMLConfig(task='classification',
result = str(e)
return result
""".format(model_name=model_name)
exec(score_sparkml)
with open("score_sparkml.py", "w") as file:
file.write(score_sparkml)
# COMMAND ----------
from azureml.core.conda_dependencies import CondaDependencies
myacienv = CondaDependencies.create(
conda_packages=[]
) #showing how to add libs as an eg. - not needed for this model.
with open("mydeployenv.yml", "w") as f:
f.write(myacienv.serialize_to_string())
# COMMAND ----------
#deploy to ACI
from azureml.core.webservice import AciWebservice, Webservice
myaci_config = AciWebservice.deploy_configuration(
cpu_cores=2,
memory_gb=2,
tags={'name': 'Databricks Azure ML ACI'},
description='SMS Spam Classifier')
# Usually, the cluster already exists, so we just fetch
compute_target = next(
(m for m in ComputeTarget.list(ws) if m.name == compute["name"]), None
)
# Specify the compute environment and register it for use in scoring
env = Environment("component-condition")
env.docker.enabled = True
cd = CondaDependencies.create(
conda_packages=[
"tensorflow=2.0.0",
"pandas",
"numpy",
"matplotlib"
],
pip_packages=[
"azureml-mlflow==1.5.0",
"azureml-defaults==1.5.0"
]
)
env.python.conda_dependencies = cd
env.register(workspace=ws)
print("Registered environment component-condition")
# Specify the run configuration
run_config = RunConfiguration()
run_config.environment.docker.enabled = True
run_config.environment.python.conda_dependencies = cd
# Pipeline definition
cpu_cores=1,
memory_gb=1,
tags={
"data": "Random Recommender",
"Gestore": "Alessandro Artoni",
"Owner": "Alessandro Artoni",
"Environment": "dev",
"Progetto": "Random recommender example"
},
description='Example on how to deploy a random recommender',
)
logger.info("ACI Deployed")
env = Environment('custom')
env.python.conda_dependencies = CondaDependencies.create(
pip_packages=['azureml-defaults', 'joblib', 'numpy'])
inference_config = InferenceConfig(entry_script="score.py",
source_directory="recommender",
environment=env)
logger.info("Inference config setted")
if (WHERE_TO_DEPLOY == "LOCAL"):
deployment_config = LocalWebservice.deploy_configuration(port=8890)
# Deploy the service
service = Model.deploy(ws, "localmodel", [model], inference_config,
deployment_config)
# Wait for the deployment to complete
service.wait_for_deployment(True)
# Display the port that the web service is available on
experiment = Experiment(ws, experiment_name)
automl_runs = list(experiment.get_runs(type='automl'))
assert (len(automl_runs) == 1)
compute_name = 'mydsvmb'
dsvm_compute = ws.compute_targets[compute_name]
# create a new RunConfig object
conda_run_config = RunConfiguration(framework="python")
# Set compute target to the Linux DSVM
conda_run_config.target = dsvm_compute
cd = CondaDependencies.create(pip_packages=['azureml-sdk[automl]'],
conda_packages=['numpy'])
conda_run_config.environment.python.conda_dependencies = cd
automl_settings = {
"iteration_timeout_minutes": 60,
"iterations": 100,
"n_cross_validations": 5,
"primary_metric": 'AUC_weighted',
"preprocess": True,
"max_cores_per_iteration": 2
}
automl_config = AutoMLConfig(task='classification',
path=project_folder,
run_configuration=conda_run_config,
data_script=project_folder + "/get_data.py",
container_registry = ContainerRegistry()
container_registry.address = deployment_settings["image"]["docker"][
"custom_image_registry_details"]["address"]
container_registry.username = deployment_settings["image"]["docker"][
"custom_image_registry_details"]["username"]
container_registry.password = deployment_settings["image"]["docker"][
"custom_image_registry_details"]["password"]
else:
container_registry = None
# Creating dependencies
print("Creating dependencies and registering environment")
conda_dep = CondaDependencies.create(
conda_packages=deployment_settings["image"]["dependencies"]
["conda_packages"],
pip_packages=deployment_settings["image"]["dependencies"]["pip_packages"],
python_version=deployment_settings["image"]["dependencies"]
["python_version"],
pin_sdk_version=deployment_settings["image"]["dependencies"]
["pin_sdk_version"])
dep_path = os.path.join("code", "scoring", "myenv.yml")
conda_dep.save(path=dep_path)
# Creating InferenceConfig
print("Creating InferenceConfig")
if deployment_settings["image"]["use_custom_environment"]:
env = utils.get_environment(name_suffix="_deployment")
inferenceConfig = InferenceConfig(
entry_script=deployment_settings["image"]["entry_script"],
source_directory=deployment_settings["image"]["source_directory"],
runtime=deployment_settings["image"]["runtime"],
environment=env)
# Create a new runconfig object
run_amlcompute = RunConfiguration()
# Use the cpu_cluster you created above.
run_amlcompute.target = cpu_cluster
# Enable Docker
run_amlcompute.environment.docker.enabled = True
# Set Docker base image to the default CPU-based image
run_amlcompute.environment.docker.base_image = DEFAULT_CPU_IMAGE
# Use conda_dependencies.yml to create a conda environment in the Docker image for execution
run_amlcompute.environment.python.user_managed_dependencies = False
# Specify CondaDependencies obj, add necessary packages
run_amlcompute.environment.python.conda_dependencies = CondaDependencies.create(
conda_packages=['scikit-learn'])
#</run_amlcompute>
# Submit the experiment using the run configuration
#<amlcompute_submit>
from azureml.core import ScriptRunConfig
src = ScriptRunConfig(source_directory=script_folder,
script='train.py',
run_config=run_amlcompute)
run = exp.submit(src)
run.wait_for_completion(show_output=True)
#</amlcompute_submit>
try:
start = time.time() # start timer
input_data = preprocess(input_data_json)
input_name = session.get_inputs()[0].name # get the id of the first input of the model
result = session.run([], {input_name: input_data})
end = time.time() # stop timer
return {"result": postprocess(result),
"time": end - start}
except Exception as e:
result = str(e)
return {"error": result}
# %%
from azureml.core.conda_dependencies import CondaDependencies
myenv = CondaDependencies.create(pip_packages=["numpy","onnxruntime","azureml-core", "azureml-defaults"])
with open("myenv.yml","w") as f:
f.write(myenv.serialize_to_string())
# %%
#
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
myenv = Environment.from_conda_specification(name="myenv", file_path="myenv.yml")
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)
# %%
from azureml.core.webservice import AciWebservice
blob_datastore = DataStoreConfig.config(ws, config.BLOB_DATASTORE_NAME,
config.ACCOUNT_NAME,
config.CONTAINER_NAME,
config.ACCOUNT_KEY)
print("get datasets from datastore")
input_data_paths = [(blob_datastore, 'mldata')]
input_dataset = Dataset.File.from_files(path=input_data_paths)
# ----PYTHON ENV------
#-------------------------
packages = CondaDependencies.create(
conda_packages=["cudatoolkit=10.0"],
pip_packages=[
'azureml-sdk', 'PyYAML', 'azure-storage-blob', 'matplotlib',
'seaborn', 'tensorflow', 'Keras', 'tensorflow-hub', 'joblib',
'tqdm', 'Pillow', 'azureml-dataprep[pandas,fuse]>=1.1.14'
])
diagnoz_env = Environment("diagnoz-pipeline-env")
diagnoz_env.python.user_managed_dependencies = False # Let Azure ML manage dependencies
diagnoz_env.docker.enabled = True # Use a docker container
diagnoz_env.docker.base_image = DEFAULT_GPU_IMAGE
diagnoz_env.python.conda_dependencies = packages
diagnoz_env.register(workspace=ws)
# Runconfigs
pipeline_run_config = RunConfiguration()
pipeline_run_config.target = compute_target
pipeline_run_config.environment = diagnoz_env
print('Updating scoring file with the correct model name')
with open('score.py') as f:
data = f.read()
with open('score_fixed.py', "w") as f:
f.write(data.replace('MODEL-NAME',
args.model_name)) #replace the placeholder MODEL-NAME
print('score_fixed.py saved')
# 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)
def build_vocab_step(train_dir, compute_target):
'''
This step will take the raw data downloaded from the previous step,
preprocess it, and split into train, valid, and test directories.
:param train_dir: The reference to the directory containing the training data
:type train_src: DataReference
:param compute_target: The compute target to run the step on
:type compute_target: ComputeTarget
:return: The preprocess step, step outputs dictionary (keys: vocab_dir)
:rtype: PythonScriptStep, dict
'''
run_config = RunConfiguration()
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE
run_config.environment.python.user_managed_dependencies = False
conda_packages = ['pytorch']
run_config.environment.python.conda_dependencies = CondaDependencies.create(
conda_packages=conda_packages)
input_col = PipelineParameter(name='input_col', default_value='Title')
output_col = PipelineParameter(name='output_col', default_value='Abstract')
size = PipelineParameter(name='size', default_value=50000)
freq_cutoff = PipelineParameter(name='freq_cutoff', default_value=2)
vocab_dir = PipelineData(name='vocab_dir',
pipeline_output_name='vocab_dir',
datastore=train_dir.datastore,
output_mode='mount',
is_directory=True)
outputs = [vocab_dir]
outputs_map = {
'vocab_dir': vocab_dir,
}
step = PythonScriptStep(name="Build Vocab",
script_name='build_vocab.py',
arguments=[
'--train_dir',
train_dir,
'--vocab_dir',
vocab_dir,
'--input_col',
input_col,
'--output_col',
output_col,
'--size',
size,
'--freq_cutoff',
freq_cutoff,
],
inputs=[train_dir],
outputs=outputs,
compute_target=compute_target,
runconfig=run_config,
source_directory=os.path.dirname(
os.path.abspath(__file__)),
allow_reuse=True)
return step, outputs_map
ws = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=False,
location=workspace_region)
print('Workspace configuration completed')
# In[2]: Web service and container deployment configuration
from azureml.core.conda_dependencies import CondaDependencies
import os
os.chdir(working_directory)
myacienv = CondaDependencies.create(
pip_packages=['gensim', 'nltk', 'numpy', 'inference_schema'])
with open("mydeployenv.yml", "w") as f:
f.write(myacienv.serialize_to_string())
# ## Deployment
from azureml.core.webservice import AciWebservice, Webservice
# Deployment configuration for the container web service
aci_config = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1,
tags={"name": "Summarization"},
description="Summarizes text")
# Container image configuration
service_name = "summarization1"
