Microsoft Azure ML Service-Frameworks

Erforderliches Format der JSON-Anforderungen für Web-Services

• Der Hauptteil der REST-API-Anforderung muss ein JSON-Dokument sein, das ein JSON-Array mit JSON-Objekten enthält.
• Das JSON-Array muss "input"heißen.
• Jedes JSON-Objekt kann nur einfache Schlüssel/Wert-Paare enthalten, wobei die Werte eine Zeichenfolge, eine Zahl, true, false oder null sein können.
• Die Werte dürfen kein JSON-Objekt oder -Array enthalten.
• Für jedes JSON-Objekt im Array müssen dieselben Schlüssel (und damit auch die Anzahl der Schlüssel) angegeben werden, unabhängig davon, ob ein Nicht-null-Wert verfügbar ist.

Die folgende JSON-Beispieldatei erfüllt die genannten Voraussetzungen und kann als Vorlage zum Erstellen eigener JSON-Anforderungsdateien verwendet werden:

{
  "input": [
    {
      "field1": "value1",
      "field2": 31,
      "field3": true,
      "field4": 2.3
    },
    {
      "field1": "value2",
      "field2": 15,
      "field3": false,
      "field4": 0.1
    },
    {
      "field1": null,
      "field2": 5,
      "field3": true,
      "field4": 6.1
    }
  ]
}

Erforderliches Format für JSON-Antworten für Web-Services

Beachten Sie beim Erstellen einer JSON-Antwortdatei die folgenden Punkte:

• Der Hauptteil der REST-API-Antwort muss ein JSON-Dokument sein, das ein JSON-Array mit JSON-Objekten enthält.

• Das JSON-Array muss "output"heißen.

• Jedes JSON-Objekt kann nur Schlüssel/Wert-Paare enthalten, wobei die Werte eine Zeichenfolge, eine Zahl, true, false, null oder ein Array sein können, das keine anderen JSON-Objekte oder Arrays enthält.

• Die Werte dürfen kein JSON-Objekt sein.

• Für jedes JSON-Objekt im Array müssen dieselben Schlüssel (und dieselbe Anzahl von Schlüsseln) angegeben werden, unabhängig davon, ob ein Nicht-null-Wert verfügbar ist.

• Für Klassifikationsmodelle gilt Folgendes: Der Web-Service muss ein Array mit Wahrscheinlichkeiten für jede Klasse zurückgeben und die Reihenfolge der Wahrscheinlichkeiten muss in jedem JSON-Objekt des Arrays gleich sein.

  • Beispiel: Angenommen, Sie verfügen über ein binäres Klassifikationsmodell für die Vorhersage von Kreditrisiken mit den Klassen Risk (Risiko) und No Risk (kein Risiko).
  • Bei jedem zurückgegebenen Ergebnis im Array "output" müssen die Objekte ein Schlüssel/Wert-Paar enthalten, bei dem die Wahrscheinlichkeiten die folgende festgelegte Reihenfolge aufweisen:

  {
  "output": [
    {
      "Scored Probabilities": ["Risk" probability,"No Risk" probability
      ]
      },
      {
        "Scored Probabilities": ["Risk" probability,"No Risk" probability
          ]
         }
      ]
  

Zur Wahrung der Konsistenz mit den visuellen Tools in Azure ML, die sowohl in Azure ML Studio als auch in Azure ML Service zum Einsatz kommen, werden die folgenden Schlüsselnamen verwendet:

• Schlüsselname "Scored Labels" für den Ausgabeschlüssel, der den vorhergesagten Wert des Modells angibt
• Der Schlüsselname "Scored Probabilities" für den Ausgabeschlüssel, der ein Array von Wahrscheinlichkeiten für jede Klasse angibt

Die folgende JSON-Datei erfüllt die genannten Voraussetzungen und kann als Vorlage zum Erstellen eigener JSON-Antwortdateien verwendet werden:

{
  "output": [
    {
      "Scored Labels": "No Risk",
      "Scored Probabilities": [
        0.8922524675865824,
        0.10774753241341757
      ]
    },
    {
      "Scored Labels": "No Risk",
      "Scored Probabilities": [
        0.8335192848546905,
        0.1664807151453095
      ]
    }
  ]
}

Microsoft Azure ML Service-Engine hinzufügen

Eine IBM watsonx.ai Runtime Engine ist als Custom gebunden und besteht aus Metadaten. Es gibt keine direkte Integration mit dem IBM watsonx.ai Runtime Service.

service_type = "azure_machine_learning_service"
added_service_provider_result = wos_client.service_providers.add(
        name=SERVICE_PROVIDER_NAME,
        description=SERVICE_PROVIDER_DESCRIPTION,
        service_type = service_type,
        credentials=AzureCredentials(
            subscription_id= AZURE_ENGINE_CREDENTIALS['subscription_id'],
            client_id = AZURE_ENGINE_CREDENTIALS['client_id'],
            client_secret= AZURE_ENGINE_CREDENTIALS['client_secret'],
            tenant = AZURE_ENGINE_CREDENTIALS['tenant']
        ),
        background_mode=False
    ).result

Mit dem folgenden Befehl können Sie Ihre Servicebindung anzeigen:

client.service_providers.list()

Beispielausgabe:

uid	                                   name	                      service_type	                   created
410e730f-8462-45fe-8b41-a029d6d6043a	My Azure ML Service engine azure_machine_learning_service2019-06-10T22:10:29.398Z

Microsoft Azure ML Service-Subskription hinzufügen

Subskription hinzufügen

asset_deployment_details = wos_client.service_providers.list_assets(data_mart_id=data_mart_id, service_provider_id=service_provider_id).result
asset_deployment_details
 
deployment_id=''
for model_asset_details in asset_deployment_details['resources']:
    if model_asset_details['metadata']['guid']==deployment_id:
        break
 
azure_asset = Asset(
            asset_id=model_asset_details["entity"]["asset"]["asset_id"],
            name=model_asset_details["entity"]["asset"]["name"],
            url=model_asset_details["entity"]["asset"]["url"],
            asset_type=model_asset_details['entity']['asset']['asset_type'] if 'asset_type' in model_asset_details['entity']['asset'] else 'model',
            input_data_type=InputDataType.STRUCTURED,
            problem_type=ProblemType.BINARY_CLASSIFICATION
        )
 
deployment_scoring_endpoint = model_asset_details['entity']['scoring_endpoint']
scoring_endpoint = ScoringEndpointRequest(url = model_asset_details['entity']['scoring_endpoint']['url'],request_headers = model_asset_details['entity']['scoring_endpoint']['request_headers'],
                                                 credentials = None)  
 
deployment = AssetDeploymentRequest(
    deployment_id=model_asset_details['metadata']['guid'],
    url=model_asset_details['metadata']['url'],
    name=model_asset_details['entity']['name'],
    description=model_asset_details['entity']['description'],
    deployment_type=model_asset_details['entity']['type'],
    scoring_endpoint = scoring_endpoint
)
 
asset_properties = AssetPropertiesRequest(
        label_column="Risk ",
        prediction_field='Scored Labels',
        probability_fields=['Scored Probabilities'],
        training_data_reference=training_data_reference,
        training_data_schema=None,
        input_data_schema=None,
        output_data_schema=None,
    )
 
subscription_details = wos_client.subscriptions.add(
        data_mart_id=data_mart_id,
        service_provider_id=service_provider_id,
        asset=azure_asset,
        deployment=deployment,
        asset_properties=asset_properties,
        background_mode=False
).result

Subskriptionsliste abrufen

subscription_id = subscription_details.metadata.id
subscription_id
 
details: wos_client.subscriptions.get(subscription_id).result.to_dict()

Nutzdatenprotokollierung aktivieren

Nutzdatenprotokollierung in der Subskription aktivieren

payload_data_set_id = None
payload_data_set_id = wos_client.data_sets.list(type=DataSetTypes.PAYLOAD_LOGGING, 
                                                target_target_id=subscription_id, 
                                                target_target_type=TargetTypes.SUBSCRIPTION).result.data_sets[0].metadata.id

Protokollierungsdetails abrufen

subscription.payload_logging.get_details()

Scoring und Nutzdatenprotokollierung

Führen Sie einen Scoring-Vorgang für Ihr Modell durch. Ein vollständiges Beispiel finden Sie im Notebook 'Working with Azure Machine Learning Service Engine'.

Speichern Sie die Anforderung und die Antwort in der Tabelle für Nutzdatenprotokollierung:

wos_client.data_sets.store_records(data_set_id=payload_data_set_id, request_body=[PayloadRecord(
           scoring_id=str(uuid.uuid4()),
           request=request_data,
           response=response_data,
           response_time=460
)])

Für andere Sprachen als Python können Sie die Nutzdaten auch mithilfe der REST-API protokollieren.

Übergeordnetes Thema: Unterstützte Engines, Frameworks und Modelle für maschinelles Lernen