Update code and text

JKirsch1 · JKirsch1 · commit dc36b68c0464 · 2025-01-29T17:00:08.000-05:00
diff --git a/articles/machine-learning/v1/how-to-deploy-advanced-entry-script.md b/articles/machine-learning/v1/how-to-deploy-advanced-entry-script.md
@@ -17,44 +17,46 @@ ms.custom: UpdateFrequency5, deploy, sdkv1
 
 [!INCLUDE [sdk v1](../includes/machine-learning-sdk-v1.md)]
 
-This article explains how to write entry scripts for specialized use cases.
+This article explains how to write entry scripts for specialized use cases in Azure Machine Learning.
 
 ## Prerequisites
 
-This article assumes you already have a trained machine learning model that you intend to deploy with Azure Machine Learning. To learn more about model deployment, see [Deploy machine learning models to Azure](how-to-deploy-and-where.md).
+- A trained machine learning model that you intend to deploy with Azure Machine Learning. To learn more about model deployment, see [Deploy machine learning models to Azure](how-to-deploy-and-where.md).
 
 ## Automatically generate a Swagger schema
 
-To automatically generate a schema for your web service, provide a sample of the input and/or output in the constructor for one of the defined type objects. The type and sample are used to automatically create the schema. Azure Machine Learning then creates an [OpenAPI specification](https://swagger.io/docs/specification/about/) (formerly, Swagger specification) for the web service during deployment.
+To automatically generate a schema for your web service, provide a sample of the input or output in the constructor for one of the defined type objects. The type and sample are used to automatically create the schema. Azure Machine Learning then creates an [OpenAPI specification](https://swagger.io/docs/specification/about/) (formerly, a Swagger specification) for the web service during deployment.
 
 > [!WARNING]
-> You must not use sensitive or private data for sample input or output. The Swagger page for AML-hosted inferencing exposes the sample data.
+> Don't use sensitive or private data for the sample input or output. The Swagger page for AML-hosted inferencing exposes the sample data.
 
-These types are currently supported:
+The following types are currently supported:
 
 * `pandas`
 * `numpy`
 * `pyspark`
 * Standard Python object
 
-To use schema generation, include the open-source `inference-schema` package version 1.1.0 or above in your dependencies file. For more information on this package, see [InferenceSchema on GitHub](https://github.com/Azure/InferenceSchema). In order to generate conforming Swagger for automated web service consumption, scoring script run() function must have API shape of:
-* A first parameter of type `StandardPythonParameterType`, named *Inputs* and nested
-* An optional second parameter of type `StandardPythonParameterType`, named *GlobalParameters*
-* Return a dictionary of type `StandardPythonParameterType`, named *Results* and nested
+To use schema generation, include the open-source `inference-schema` package version 1.1.0 or later in your dependencies file. For more information about this package, see [InferenceSchema on GitHub](https://github.com/Azure/InferenceSchema). In order to generate conforming Swagger for automated web service consumption, the `run` function in your scoring script must meet the following conditions:
 
-Define the input and output sample formats in the `input_sample` and `output_sample` variables, which represent the request and response formats for the web service. Use these samples in the input and output function decorators on the `run()` function. The following scikit-learn example uses schema generation.
+* The first parameter must have the type `StandardPythonParameterType`, be named `Inputs`, and be nested.
+* There must be an optional second parameter of type `StandardPythonParameterType` that's named `GlobalParameters`.
+* The function must return a dictionary of type `StandardPythonParameterType` that's named `Results` and is nested.
 
-## Power BI compatible endpoint
+Define the input and output sample formats in the `sample_input` and `sample_output` variables, which represent the request and response formats for the web service. Use these samples in the input and output function decorators on the `run` function. The `scikit-learn` example in the following section uses schema generation.
 
-The following example demonstrates how to define API shape according to preceding instruction. This method is supported for consuming the deployed web service from Power BI.
+## Power BI-compatible endpoint
+
+The following example demonstrates how to define the `run` function according to the instructions in the preceding section. You can use this script when you consume your deployed web service from Power BI.
 
 ```python
+import os
 import json
 import pickle
 import numpy as np
 import pandas as pd
 import azureml.train.automl
-from sklearn.externals import joblib
+import joblib
 from sklearn.linear_model import Ridge
 
 from inference_schema.schema_decorators import input_schema, output_schema
@@ -108,7 +110,7 @@ def run(Inputs, GlobalParameters):
 ```
 
 > [!TIP]
-> The return value from the script can be any Python object that is serializable to JSON. For example, if your model returns a Pandas dataframe that contains multiple columns, you might use an output decorator similar to the following code:
+> The return value from the script can be any Python object that's serializable to JSON. For example, if your model returns a Pandas dataframe that contains multiple columns, you might use an output decorator similar to the following code:
 > 
 > ```python
 > output_sample = pd.DataFrame(data=[{"a1": 5, "a2": 6}])
@@ -118,11 +120,11 @@ def run(Inputs, GlobalParameters):
 > return result
 > ```
 
-## <a id="binary-data"></a> Binary (that is, image) data
+## <a id="binary-data"></a> Binary (image) data
 
-If your model accepts binary data, like an image, you must modify the *score.py* file used for your deployment to accept raw HTTP requests. To accept raw data, use the `AMLRequest` class in your entry script and add the `@rawhttp` decorator to the `run()` function.
+If your model accepts binary data, like an image, you must modify the score.py file that your deployment uses so that it accepts raw HTTP requests. To accept raw data, use the `AMLRequest` class in your entry script and add the `@rawhttp` decorator to the `run` function.
 
-Here's an example of a `score.py` that accepts binary data:
+The following score.py script accepts binary data:
 
 ```python
 from azureml.contrib.services.aml_request import AMLRequest, rawhttp
@@ -156,21 +158,21 @@ def run(request):
 ```
 
 > [!IMPORTANT]
-> The `AMLRequest` class is in the `azureml.contrib` namespace. Entities in this namespace change frequently as we work to improve the service. Anything in this namespace should be considered a preview that's not fully supported by Microsoft.
+> The `AMLRequest` class is in the `azureml.contrib` namespace. Entities in this namespace are in preview. They change frequently as the service undergoes improvements. These entities aren't fully supported by Microsoft.
 >
-> If you need to test this in your local development environment, you can install the components by using the following command:
+> If you need to test this code in your local development environment, you can install the components by using the following command:
 >
 > ```shell
 > pip install azureml-contrib-services
 > ```
 
 > [!NOTE]
-> *500* is not recommended as a customed status code, as at azureml-fe side, the status code will be rewritten to *502*.
->   * The status code is passed through the azureml-fe, then sent to client.
->   * The azureml-fe only rewrites the 500 returned from the model side to be 502, the client receives 502.
->   * But if the azureml-fe itself returns 500, client side still receives 500.
+> We don't recommend using `500` as a custom status code. On the `azureml-fe` side, the status code is rewritten to `502`.
+>   * The status code is passed through `azureml-fe` and then sent to the client.
+>   * The `azureml-fe` code rewrites the `500` that's returned from the model side as `502`. The client receives a code of `502`.
+>   * If the `azureml-fe` code itself returns `500`, the client side still receives a code of `500`.
 
-The `AMLRequest` class only allows you to access the raw posted data in the *score.py* file, there's no client-side component. From a client, you post data as normal. For example, the following Python code reads an image file and posts the data:
+When you use the `AMLRequest` class, you can access only the raw posted data in the score.py file. There's no client-side component. From a client, you can post data as usual. For example, the following Python code reads an image file and posts the data:
 
 ```python
 import requests
@@ -185,11 +187,11 @@ print(response.json)
 
 <a id="cors"></a>
 
-## Cross-origin resource sharing (CORS)
+## Cross-origin resource sharing
 
-Cross-origin resource sharing is a way to allow resources on a webpage to be requested from another domain. CORS works via HTTP headers sent with the client request and returned with the service response. For more information on CORS and valid headers, see [Cross-origin resource sharing](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing) in Wikipedia.
+Cross-origin resource sharing (CORS) provides a way for resources on a webpage to be requested from another domain. CORS works via HTTP headers that are sent with the client request and returned with the service response. For more information about CORS and valid headers, see [Cross-origin resource sharing](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing).
 
-To configure your model deployment to support CORS, use the `AMLResponse` class in your entry script. This class allows you to set the headers on the response object.
+To configure your model deployment to support CORS, use the `AMLResponse` class in your entry script. When you use this class, you can set the headers on the response object.
 
 The following example sets the `Access-Control-Allow-Origin` header for the response from the entry script:
 
@@ -238,66 +240,77 @@ def run(request):
 ```
 
 > [!IMPORTANT]
-> The `AMLResponse` class is in the `azureml.contrib` namespace. Entities in this namespace change frequently as we work to improve the service. Anything in this namespace should be considered a preview that's not fully supported by Microsoft.
+> The `AMLRequest` class is in the `azureml.contrib` namespace. Entities in this namespace are in preview. They change frequently as the service undergoes improvements. These entities aren't fully supported by Microsoft.
 >
-> If you need to test this in your local development environment, you can install the components by using the following command:
+> If you need to test code this in your local development environment, you can install the components by using the following command:
 >
 > ```shell
 > pip install azureml-contrib-services
 > ```
 
 > [!WARNING]
-> Azure Machine Learning only routes POST and GET requests to the containers running the scoring service. This can cause errors due to browsers using OPTIONS requests to pre-flight CORS requests.
+> Azure Machine Learning only routes POST and GET requests to the containers that run the scoring service. Errors can result if browsers use OPTIONS requests to issue preflight requests.
 >
 
 ## Load registered models
 
 There are two ways to locate models in your entry script:
-* `AZUREML_MODEL_DIR`: An environment variable containing the path to the model location
-* `Model.get_model_path`: An API that returns the path to model file using the registered model name
+
+* `AZUREML_MODEL_DIR`: An environment variable that contains the path to the model location
+* `Model.get_model_path`: An API that returns the path to the model file by using the registered model name
 
 #### AZUREML_MODEL_DIR
 
-`AZUREML_MODEL_DIR` is an environment variable created during service deployment. You can use this environment variable to find the location of the deployed model(s).
+`AZUREML_MODEL_DIR` is an environment variable that's created during service deployment. You can use this environment variable to find the location of deployed models.
 
-The following table describes the value of `AZUREML_MODEL_DIR` depending on the number of models deployed:
+The following table describes the value of `AZUREML_MODEL_DIR` when a varying number of models are deployed:
 
 | Deployment | Environment variable value |
 | ----- | ----- |
-| Single model | The path to the folder containing the model. |
-| Multiple models | The path to the folder containing all models. Models are located by name and version in this folder (`$MODEL_NAME/$VERSION`) |
+| Single model | The path to the folder that contains the model. |
+| Multiple models | The path to the folder that contains all models. Models are located by name and version in this folder in the format `<model-name>/<version>`. |
 
-During model registration and deployment, Models are placed in the AZUREML_MODEL_DIR path, and their original filenames are preserved.
+During model registration and deployment, models are placed in the `AZUREML_MODEL_DIR` path, and their original filenames are preserved.
 
 To get the path to a model file in your entry script, combine the environment variable with the file path you're looking for.
 
-**Single model example**
+##### Single model
+
+The following example shows you how to find the path when you have a single model:
+
 ```python
+import os
+
 # Example when the model is a file
 model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_regression_model.pkl')
 
 # Example when the model is a folder containing a file
 file_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'my_model_folder', 'sklearn_regression_model.pkl')
 ```
 
-**Multiple model example**
+##### Multiple models
 
-In this scenario, two models are registered with the workspace:
+The following example shows you how to find the path when you have multiple models. In this scenario, two models are registered with the workspace:
 
-* `my_first_model`: Contains one file (`my_first_model.pkl`) and there's only one version, `1`
-* `my_second_model`: Contains one file (`my_second_model.pkl`) and there are two versions, `1` and `2`
+* `my_first_model`: This model contains one file, my_first_model.pkl, and has one version, `1`.
+* `my_second_model`: This model contains one file, my_second_model.pkl, and has two versions, `1` and `2`.
 
-When the service was deployed, both models are provided in the deploy operation:
+When you deploy the service, you provide both models in the deploy operation:
 
 ```python
+from azureml.core import Workspace, Model
+
+# Get a handle to the workspace.
+ws = Workspace.from_config()
+
 first_model = Model(ws, name="my_first_model", version=1)
 second_model = Model(ws, name="my_second_model", version=2)
 service = Model.deploy(ws, "myservice", [first_model, second_model], inference_config, deployment_config)
 ```
 
-In the Docker image that hosts the service, the `AZUREML_MODEL_DIR` environment variable contains the directory where the models are located. In this directory, each of the models is located in a directory path of `MODEL_NAME/VERSION`. Where `MODEL_NAME` is the name of the registered model, and `VERSION` is the version of the model. The files that make up the registered model are stored in these directories.
+In the Docker image that hosts the service, the `AZUREML_MODEL_DIR` environment variable contains the directory where the models are located. In this directory, each model is located in a directory path of `<model-name>/<version>`. In this path, `<model-name>` is the name of the registered model, and `<version>` is the version of the model. The files that make up the registered model are stored in these directories.
 
-In this example, the paths would be `$AZUREML_MODEL_DIR/my_first_model/1/my_first_model.pkl` and `$AZUREML_MODEL_DIR/my_second_model/2/my_second_model.pkl`.
+In this example, the path of the first model is `$AZUREML_MODEL_DIR/my_first_model/1/my_first_model.pkl`. The path of the second model is `$AZUREML_MODEL_DIR/my_second_model/2/my_second_model.pkl`.
 
 ```python
 # Example when the model is a file, and the deployment contains multiple models
@@ -311,13 +324,13 @@ second_model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), second_model_na
 
 ### get_model_path
 
-When you register a model, you provide a model name that's used for managing the model in the registry. You use this name with the [Model.get_model_path()](/python/api/azureml-core/azureml.core.model.model#azureml-core-model-model-get-model-path) method to retrieve the path of the model file or files on the local file system. If you register a folder or a collection of files, this API returns the path of the directory that contains those files.
+When you register a model, you provide a model name that's used for managing the model in the registry. You use this name with the [`Model.get_model_path`](/python/api/azureml-core/azureml.core.model.model#azureml-core-model-model-get-model-path) method to retrieve the path of the model file or files on the local file system. If you register a folder or a collection of files, this API returns the path of the directory that contains those files.
 
 When you register a model, you give it a name. The name corresponds to where the model is placed, either locally or during service deployment.
 
 ## Framework-specific examples
 
-See the following articles for more entry script examples for specific machine learning use cases:
+For more entry script examples for specific machine learning use cases, see the following articles:
 
 * [PyTorch](https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/ml-frameworks/pytorch)
 * [TensorFlow](https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/ml-frameworks/tensorflow)
