def create_aml_environment(aml_interface):
aml_env = Environment(name=AML_ENVIRONMENT_NAME)
conda_dep = CondaDependencies()
conda_dep.add_pip_package("numpy==1.18.2")
conda_dep.add_pip_package("pandas==1.0.3")
conda_dep.add_pip_package("scikit-learn==0.22.2.post1")
conda_dep.add_pip_package("joblib==0.14.1")
conda_dep.add_pip_package("azure-storage-blob==12.3.0")
aml_env.environment_variables[AZURE_STORAGE_ACCOUNT_NAME] = os.getenv(
AZURE_STORAGE_ACCOUNT_NAME)
aml_env.environment_variables[AZURE_STORAGE_ACCOUNT_KEY] = os.getenv(
AZURE_STORAGE_ACCOUNT_KEY)
aml_env.environment_variables[MODEL_NAME_VARIABLE] = MODEL_NAME
logger.info(
f"set environment variables on compute environment: {aml_env.environment_variables}"
)
whl_filepath = retrieve_whl_filepath()
whl_url = Environment.add_private_pip_wheel(
workspace=aml_interface.workspace,
file_path=whl_filepath,
exist_ok=True)
conda_dep.add_pip_package(whl_url)
aml_env.python.conda_dependencies = conda_dep
aml_env.docker.enabled = True
return aml_env
def get_run_cfg(ws, pip_packages, conda_packages, ext_wheels, gpu=True):
'''
get_run_cfg - Retrieves the AMLS run configuration.
:returns: AMLS run configuration
:rtype: RunConfiguration object
'''
conda_dep = CondaDependencies()
for pip_package in pip_packages:
conda_dep.add_pip_package(pip_package)
for conda_package in conda_packages:
conda_dep.add_conda_package(conda_package)
for whl_path in ext_wheels:
whl_url = Environment.add_private_pip_wheel(workspace=ws,
file_path=whl_path,
exist_ok=True)
conda_dep.add_pip_package(whl_url)
run_cfg = RunConfiguration(conda_dependencies=conda_dep)
run_cfg.environment.docker.enabled = True
run_cfg.environment.docker.gpu_support = gpu
if gpu:
run_cfg.environment.docker.base_image = DEFAULT_GPU_IMAGE
else:
run_cfg.environment.docker.base_image = DEFAULT_CPU_IMAGE
run_cfg.environment.spark.precache_packages = False
return run_cfg
def save_conda_dependencies(amls_config, filename):
conda_dependencies = CondaDependencies()
for dependency in amls_config['conda_dependencies']:
conda_dependencies.add_pip_package(dependency)
with open(filename, "w") as f:
f.write(conda_dependencies.serialize_to_string())
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 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-file-datalake")
myenv.python.conda_dependencies = conda_dep
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 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 conda_dependencies(self):
"""
Get module conda dependencies
:return: CondaDependencies instance
"""
cd = CondaDependencies()
for c in self._get_value('CondaDependencies/CondaChannels'):
cd.add_channel(c)
for c in self._get_value('CondaDependencies/CondaPackages'):
cd.add_conda_package(c)
for p in self._get_value('CondaDependencies/PipPackages'):
cd.add_pip_package(p)
for p in self._get_value('CondaDependencies/PipOptions'):
cd.set_pip_option(p)
return cd
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 create_aml_environment(aml_interface):
aml_env = Environment(name=AML_ENV_NAME)
conda_dep = CondaDependencies()
conda_dep.add_pip_package("numpy==1.18.2")
conda_dep.add_pip_package("pandas==1.0.3")
conda_dep.add_pip_package("scikit-learn==0.22.2.post1")
conda_dep.add_pip_package("joblib==0.14.1")
whl_filepath = retrieve_whl_filepath()
whl_url = Environment.add_private_pip_wheel(
workspace=aml_interface.workspace,
file_path=whl_filepath,
exist_ok=True)
conda_dep.add_pip_package(whl_url)
aml_env.python.conda_dependencies = conda_dep
aml_env.docker.enabled = True
return aml_env
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
# Unpack the generator and look through the list to find your desired model
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))
dependencies = CondaDependencies()
dependencies.add_conda_package("numpy")
dependencies.add_conda_package("matplotlib")
dependencies.add_conda_package("scikit-learn")
dependencies.add_conda_package("tensorflow")
dependencies.add_conda_package("keras")
dependencies.add_conda_package("scikit-image")
dependencies.add_pip_package("pynacl==1.2.1")
os.makedirs("./score/", exist_ok=True)
with open("./score/dependencies.yml", "w") as f:
f.write(dependencies.serialize_to_string())
original_dir = os.getcwd()
# Change directory since the docker container is expecting thing at the TLD
os.chdir("./score")
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="dependencies.yml",
description="Image with Uploaded Model")
# Image Name can only include alphanumeric or '.' and '-'
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
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
# Create the environment
myenv = Environment(name="myenv")
conda_dep = CondaDependencies()
# Define the packages needed by the model and scripts
conda_dep.add_conda_package("tensorflow")
conda_dep.add_conda_package("numpy")
conda_dep.add_conda_package("scikit-learn")
# 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("gensim")
# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies = conda_dep
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)
parser.add_argument('--workspace_name', help='the workspace name of aml')
parser.add_argument('--compute_target',
help='the compute cluster name of aml')
parser.add_argument('--docker_image', help='the docker image of job')
parser.add_argument('--experiment_name', help='the experiment name')
parser.add_argument('--script_dir', help='script directory')
parser.add_argument('--script_name', help='script name')
args = parser.parse_args()
ws = Workspace(args.subscription_id, args.resource_group,
args.workspace_name)
compute_target = ComputeTarget(workspace=ws, name=args.compute_target)
experiment = Experiment(ws, args.experiment_name)
run_config = RunConfiguration()
dependencies = CondaDependencies()
dependencies.add_pip_package("azureml-sdk")
dependencies.add_pip_package("azureml")
run_config.environment.python.conda_dependencies = dependencies
run_config.environment.docker.enabled = True
run_config.environment.docker.base_image = args.docker_image
run_config.target = compute_target
run_config.node_count = 1
config = ScriptRunConfig(source_directory=args.script_dir,
script=args.script_name,
run_config=run_config)
run = experiment.submit(config)
print(run.get_details()["runId"])
while True:
line = sys.stdin.readline().rstrip()
if line == 'update_status':
print('status:' + run.get_status())
from azureml.core.conda_dependencies import CondaDependencies
myenv = CondaDependencies()
myenv.add_pip_package("numpy")
myenv.add_pip_package("azureml-core")
myenv.add_pip_package("keras")
with open("myenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
# Inference Configuration
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
# Create the environment
myenv = Environment(name="myenv")
conda_dep = CondaDependencies()
# Define the packages needed by the model and scripts
conda_dep.add_conda_package("python=3.6.2")
conda_dep.add_conda_package("numpy=1.18.5")
conda_dep.add_conda_package("scikit-learn")
conda_dep.add_conda_package("pip")
# You must list azureml-defaults as a pip dependency
conda_dep.add_pip_package("azureml-defaults")
conda_dep.add_pip_package("tensorflow==2.3.0")
conda_dep.add_pip_package("keras==2.4.3")
# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies = conda_dep
inference_config = InferenceConfig(entry_script="./source_dir/score.py",
environment=myenv)
# Deployment config
deployment_config = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1)
# deployment_config = LocalWebservice.deploy_configuration(port=7000)
# deploy model
#get the latest model
model = ws.models['diabetes']
print(model.name, 'version', model.version)
#Create service folder
folder_name = 'diabetes_service'
# Create a folder for the web service files
experiment_folder = './' + folder_name
os.makedirs(folder_name, exist_ok=True)
print(folder_name, 'folder created.')
#Create a container config yml file
# Add the dependencies for our model (AzureML defaults is already included)
myenv = CondaDependencies()
myenv.add_pip_package("scikit-learn")
# myenv.add_pip_package("azureml-sdk[automl]") # Required for AutoML models
# Save the environment config as a .yml file
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
# Configure the scoring environment
print(f'Workspace: {ws.name}')
experiment_name = 'train-bert-ner-on-amlcompute'
experiment = Experiment(workspace=ws, name=experiment_name)
supported_vms = AmlCompute.supported_vmsizes(workspace=ws)
# print(supported_vms)
project_folder = './ner'
bert_env = Environment("bert_aml_env")
conda_dep = CondaDependencies()
conda_dep.set_python_version('3.7.3')
conda_dep.add_pip_package("torch")
conda_dep.add_pip_package("adal")
conda_dep.add_pip_package("cloudpickle")
conda_dep.add_pip_package("docker")
conda_dep.add_pip_package("numpy")
conda_dep.add_pip_package("scipy")
conda_dep.add_pip_package("tokenizers")
conda_dep.add_pip_package("transformers")
conda_dep.add_pip_package("matplotlib")
conda_dep.add_pip_package("apex==0.9.10dev")
conda_dep.add_pip_package("pandas")
conda_dep.add_pip_package("pillow")
conda_dep.add_pip_package("requests")
conda_dep.add_pip_package("scikit-learn")
conda_dep.add_pip_package("tqdm")
bert_env.docker.enabled = True
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
if not 'temp' in os.listdir():
os.mkdir('temp')
df_test.to_json("temp/test_sample.json") # save data for external tests
# Create the environment
myenv = Environment(name="mortgage_score_env_hd")
conda_dep = CondaDependencies()
# Define the packages needed by the model and scripts
conda_dep.add_conda_package("numpy")
conda_dep.add_conda_package("pip")
conda_dep.add_conda_package("scikit-learn=0.20.3")
# You must list azureml-defaults as a pip dependency
conda_dep.add_pip_package("azureml-defaults==1.11.0")
conda_dep.add_pip_package("azureml-core")
conda_dep.add_pip_package("azureml-automl-runtime")
conda_dep.add_pip_package("packaging")
conda_dep.add_pip_package("azureml-explain-model==1.11.0")
conda_dep.add_pip_package("inference-schema")
conda_dep.add_conda_package("numpy")
# scikit-learn>=0.19.0,<=0.20.3
conda_dep.add_conda_package("pandas")
conda_dep.add_conda_package("py-xgboost")
# Save environment also locally to disk so we can test the score script directly by creating a local environment
conda_dep.save('temp/mortgage_score_env.yml')
myenv.python.conda_dependencies = conda_dep
# -
webservice_config = AciWebservice.deploy_configuration(cpu_cores=1,
# Create workspace from config file
ws = Workspace.from_config()
# Create experiment to submit training
experiment_name = 'road-segmentation-train'
experiment = Experiment(ws, EXPERIMENT_NAME)
# Create the environment
tf_env = Environment(ENV_NAME)
tf_env.docker.enabled = True
tf_env.docker.base_image = BASE_IMAGE
# Define additional packages to be installed
conda_dep = CondaDependencies()
conda_dep.add_pip_package('tensorflow-gpu==2.3.0')
conda_dep.add_pip_package('pillow')
# Add packages to the environment
tf_env.python.conda_dependencies = conda_dep
# Create the configuration of an experiment
aml_run_config = RunConfiguration()
aml_run_config.environment = tf_env
# The name of the custome environment must not start by 'AzureML'
# https://github.com/MicrosoftDocs/azure-docs/issues/65770#issuecomment-724536550
aml_run_config.environment.name = 'road-segmentation-GPU'
# Create the compute target
compute_target = createAmlCompute(ws, CLUSTER_NAME, VM_SIZE)
print('create Batch AI run config')
rc = RunConfiguration(project, "dask_run_config")
rc.environment.docker.enabled = True
rc.prepare_environment = True
rc.target = batchai_cluster_name
rc.environment.python.user_managed_dependencies = False
rc.batchai.node_count = 2
# create a new CondaDependencies obj
cd = CondaDependencies()
# add scikit-learn as a conda dependency
cd.add_conda_package('dask')
cd.add_conda_package('joblib')
cd.add_pip_package('azureml-contrib-daskonbatch')
# overwrite the default conda_dependencies.yml file
cd.save_to_file(project_dir=project_folder, file_name='conda_dependencies.yml')
print()
print('##################################################')
print('submitting {} for a batch ai run...'.format(train_script))
print('##################################################')
print()
print("prepare run...")
prep = Run.prepare_compute_target(project_object=project, run_config=rc)
print(helpers.get_run_history_url(prep))
from azureml.pipeline.core.graph import PipelineParameter
data_path = DataPath(datastore=mydatastore, path_on_datastore='rawdata')
datapath1_pipeline_param = PipelineParameter(name="input_datapath",
default_value=data_path)
datapath_input = (datapath1_pipeline_param,
DataPathComputeBinding(mode='mount'))
string_pipeline_param = PipelineParameter(name="input_string",
default_value='sample_string1')
compute_config = RunConfiguration()
compute_config.target = "cpu-cluster"
dependencies = CondaDependencies()
dependencies.add_pip_package("adal==0.4.7")
compute_config.environment.python.conda_dependencies = dependencies
StepToWriteDateFile = PythonScriptStep(
name='StepToWriteDateFile',
script_name="./DataIngest/StepToWriteDateFile.py",
arguments=["--arg1", string_pipeline_param, "--arg2", datapath_input],
inputs=[datapath_input],
runconfig=compute_config,
#compute_target='manishautomlstuff',
source_directory='.')
print("StepToWriteDateFile created")
mydatastore = Datastore.get(workspace, 'billingdatablobstorage')
run = Run.get_context()
runId = run.id
from azureml.core import Workspace
from azureml.core.model import Model
from azureml.core.webservice import AciWebservice
from azureml.core.webservice import Webservice
from azureml.core.image import ContainerImage
from azureml.core.conda_dependencies import CondaDependencies
ws = Workspace.from_config()
myenv = CondaDependencies()
myenv.add_pip_package("tensorflow==1.12.0")
myenv.add_pip_package("keras==2.2.4")
myenv.add_pip_package("numpy")
with open("dlenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
model = Model.register(model_path = "tf_mnist_model.h5",
model_name = "tf_mnist_model",
tags = {"key": "1"},
description = "MNIST Prediction",
workspace = ws)
aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1,
tags={"data": "MNIST", "method": "tf"},
description='Predict MNIST with tf')
# configure the image
image_config = ContainerImage.image_configuration(execution_script="score.py",
runtime="python",
conda_file="dlenv.yml")
ws = Workspace.create(name='fashiondeeplearning',
subscription_id='02e39ba6-b26e-47cd-a81e-90c4c236aabb',
resource_group='myresourcegroup',
create_resource_group=True,
location='westeurope'
)
model = Model.register(model_path = "fashion.onnx",
model_name = "FashionDLModel",
description = "Fashion Keras Model",
workspace = ws)
myenv = CondaDependencies()
myenv.add_pip_package("numpy")
myenv.add_pip_package("azureml-core")
myenv.add_pip_package("onnxruntime")
with open("myenv.yml","w") as f:
f.write(myenv.serialize_to_string())
image_config = ContainerImage.image_configuration(execution_script = "score.py",
runtime = "python",
conda_file = "myenv.yml",
description = "test"
)
image = ContainerImage.create(name = "myonnxmodelimage",
models = [model],
image_config = image_config,
workspace = ws)
def build_pipeline_steps(automlconfig: AutoMLConfig,
data: Dataset,
target_column: str,
compute_target: ComputeTarget,
group_column_names: list,
time_column_name: str,
deploy: bool,
service_name: str = 'grouping-demo') -> StepSequence:
steps = []
metrics_output_name = 'metrics_{}'
best_model_output_name = 'best_model_{}'
count = 0
model_names = []
# get all automl configs by group
configs = _get_configs(automlconfig, data, target_column, compute_target, group_column_names)
# build a runconfig for register model
register_config = RunConfiguration()
cd = CondaDependencies()
cd.add_pip_package('azureml-pipeline')
register_config.environment.python.conda_dependencies = cd
# create each automl step end-to-end (train, register)
for group_name, conf in configs.items():
# create automl metrics output
metrics_data = PipelineData(
name='metrics_data_{}'.format(group_name),
pipeline_output_name=metrics_output_name.format(group_name),
training_output=TrainingOutput(type='Metrics'))
# create automl model output
model_data = PipelineData(
name='model_data_{}'.format(group_name),
pipeline_output_name=best_model_output_name.format(group_name),
training_output=TrainingOutput(type='Model', metric=conf.user_settings['primary_metric']))
automl_step = AutoMLStep(
name='automl_{}'.format(group_name),
automl_config=conf,
outputs=[metrics_data, model_data],
allow_reuse=True)
steps.append(automl_step)
# pass the group name as a parameter to the register step ->
# this will become the name of the model for this group.
group_name_param = PipelineParameter("group_name_{}".format(count), default_value=group_name)
count += 1
reg_model_step = PythonScriptStep(
'register.py',
name='register_{}'.format(group_name),
arguments=["--model_name", group_name_param, "--model_path", model_data],
inputs=[model_data],
compute_target=compute_target,
runconfig=register_config,
source_directory="register",
allow_reuse=True
)
steps.append(reg_model_step)
model_names.append(group_name)
final_steps = steps
if deploy:
# modify the conda dependencies to ensure we pick up correct
# versions of azureml-defaults and azureml-train-automl
cd = CondaDependencies.create(pip_packages=['azureml-defaults', 'azureml-train-automl'])
automl_deps = CondaDependencies(conda_dependencies_file_path='deploy/myenv.yml')
cd._merge_dependencies(automl_deps)
cd.save('deploy/myenv.yml')
# add deployment step
pp_group_column_names = PipelineParameter(
"group_column_names",
default_value="#####".join(list(reversed(group_column_names))))
pp_model_names = PipelineParameter(
"model_names",
default_value=json.dumps(model_names))
pp_service_name = PipelineParameter(
"service_name",
default_value=service_name)
deployment_step = PythonScriptStep(
'deploy.py',
name='service_deploy',
arguments=["--group_column_names", pp_group_column_names,
"--model_names", pp_model_names,
"--service_name", pp_service_name,
"--time_column_name", time_column_name],
compute_target=compute_target,
runconfig=RunConfiguration(),
source_directory="deploy"
)
final_steps = StepSequence(steps=[steps, deployment_step])
return final_steps
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)
# # Describe your environment
# Each modelling process may require a unique set of packages. Therefore we need to create a dependency file providing instructions to AML on how to contstruct a docker image that can support the models and any other objects required for inferencing. In the following cell, we create a environment dependency file, myenv.yml that specifies which libraries are needed by the scoring script. You can create this file manually, or use the CondaDependencies class to create it for you.
#
# Next we use this environment file to describe the docker container that we need to create in order to deploy our model. This container is created using our environment description and includes our scoring script.
#
# In[28]:
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.environment import Environment
env = Environment(name="env")
myenv = CondaDependencies()
myenv.add_pip_package("numpy")
myenv.add_pip_package("azureml-core")
myenv.add_pip_package("sklearn")
# Adds dependencies to PythonSection of myenv
env.python.conda_dependencies = myenv
print(myenv.serialize_to_string())
with open("myenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
# # Create an image configuration
# # Deploy your webservice
# The final step to deploying your webservice is to call WebService.deploy_from_model(). This function uses the deployment and image configurations created above to perform the following:
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from azureml.core.conda_dependencies import CondaDependencies
myenv = CondaDependencies()
myenv.add_conda_package("pytorch")
myenv.add_conda_package("torchvision")
myenv.add_channel("pytorch")
myenv.add_pip_package("transformers")
myenv.add_pip_package("tokenizers")
env_file = "env_pytorch.yml"
with open(env_file, "w") as f:
f.write(myenv.serialize_to_string())
print("Saved dependency info in", env_file)
with open(env_file, "r") as f:
print(f.read())
# In[ ]:
# In[2]:
from azureml.core.environment import Environment
# In[3]:
environment_variables = {
'POSTGRES_PASSWORD':
os.environ['POSTGRES_PASSWORD'],
'POSTGRES_HOSTNAME':
'ackbar-postgres.postgres.database.azure.com',
'AZURE_STORAGE_CONNECTION_STRING':
os.environ['AZURE_STORAGE_CONNECTION_STRING']
}
env = Environment(name='env', environment_variables=environment_variables)
conda = CondaDependencies()
conda.add_conda_package('psycopg2')
conda.add_conda_package('numpy')
conda.add_conda_package('Pillow')
# have to use pip to install azure packages...
conda.add_pip_package('azure-storage-blob')
env.python.conda_dependencies = conda
run_config = RunConfiguration()
run_config.environment = env
PROJECT = 'caltech'
prepare_step = PythonScriptStep(
script_name='prepare.py',
arguments=['--output', batch_input, '--project', PROJECT],
inputs=[],
outputs=[batch_input],
compute_target=compute_target,
source_directory='pipeline',
runconfig=run_config,
params=environment_variables,
from azureml.core.conda_dependencies import CondaDependencies
myenv = CondaDependencies()
myenv.add_pip_package("numpy")
myenv.add_pip_package("sklearn")
# myenv.add_conda_package("nltk")
with open("aml_config/myenv.yml", "w") as f:
f.write(myenv.serialize_to_string())
