Esempio: Creare e distribuire una skill personalizzata con Azure Machine Learning Designer (archiviato)

Questo esempio è archiviato e non supportato. È stato illustrato come usare finestra di progettazione di Azure Machine Learning è un canvas interattivo facile da usare per creare modelli di Machine Learning per attività come regressione e classificazione. Per richiamare il modello creato dal progettista in una pipeline di arricchimento di ricerca cognitiva, sono necessari alcuni passaggi aggiuntivi. In questo esempio si creerà un modello di regressione semplice per stimare il prezzo di un'automobile e richiamare l'endpoint di inferenza come competenza AML.

Seguire il tutorial Regression - Automobile Price Prediction (Advanced) nella pagina di documentazione degli esempi di pipeline e set di dati per creare un modello che stima il prezzo di un'automobile in base alle diverse caratteristiche.

Importante

La distribuzione del modello che segue il processo di inferenza in tempo reale comporterà un endpoint valido, ma non uno che è possibile usare con la competenza AML in Ricerca cognitiva.

Registrare il modello e scaricare gli asset

Dopo aver addestrato un modello, registrare il modello addestrato e seguire la procedura per scaricare tutti i file nella cartella trained_model_outputs o scaricare solo i file score.py e conda_env.yml dalla pagina degli artefatti del modello. Lo script di assegnazione dei punteggi verrà modificato prima che il modello venga distribuito come endpoint di inferenza in tempo reale.

Le pipeline di arricchimento di Ricerca cognitiva funzionano su un singolo documento e generano una richiesta che contiene gli input per una singola stima. Il score.py scaricato accetta un elenco di record e restituisce un elenco di stime come stringa JSON serializzata. Verranno apportate due modifiche al score.py

  • Modificare lo script in modo che funzioni con un singolo record di input, non con un elenco
  • Modificare lo script per restituire un oggetto JSON con una singola proprietà, il prezzo stimato.

Aprire il score.py scaricato e modificare la funzione di run(data). La funzione è attualmente configurata per prevedere l'input seguente, come descritto nel file di _samples.json del modello.

[
  {
    "symboling": 2,
    "make": "mitsubishi",
    "fuel-type": "gas",
    "aspiration": "std",
    "num-of-doors": "two",
    "body-style": "hatchback",
    "drive-wheels": "fwd",
    "engine-location": "front",
    "wheel-base": 93.7,
    "length": 157.3,
    "width": 64.4,
    "height": 50.8,
    "curb-weight": 1944,
    "engine-type": "ohc",
    "num-of-cylinders": "four",
    "engine-size": 92,
    "fuel-system": "2bbl",
    "bore": 2.97,
    "stroke": 3.23,
    "compression-ratio": 9.4,
    "horsepower": 68.0,
    "peak-rpm": 5500.0,
    "city-mpg": 31,
    "highway-mpg": 38,
    "price": 6189.0
  },
  {
    "symboling": 0,
    "make": "toyota",
    "fuel-type": "gas",
    "aspiration": "std",
    "num-of-doors": "four",
    "body-style": "wagon",
    "drive-wheels": "fwd",
    "engine-location": "front",
    "wheel-base": 95.7,
    "length": 169.7,
    "width": 63.6,
    "height": 59.1,
    "curb-weight": 2280,
    "engine-type": "ohc",
    "num-of-cylinders": "four",
    "engine-size": 92,
    "fuel-system": "2bbl",
    "bore": 3.05,
    "stroke": 3.03,
    "compression-ratio": 9.0,
    "horsepower": 62.0,
    "peak-rpm": 4800.0,
    "city-mpg": 31,
    "highway-mpg": 37,
    "price": 6918.0
  },
  {
    "symboling": 1,
    "make": "honda",
    "fuel-type": "gas",
    "aspiration": "std",
    "num-of-doors": "two",
    "body-style": "sedan",
    "drive-wheels": "fwd",
    "engine-location": "front",
    "wheel-base": 96.5,
    "length": 169.1,
    "width": 66.0,
    "height": 51.0,
    "curb-weight": 2293,
    "engine-type": "ohc",
    "num-of-cylinders": "four",
    "engine-size": 110,
    "fuel-system": "2bbl",
    "bore": 3.15,
    "stroke": 3.58,
    "compression-ratio": 9.1,
    "horsepower": 100.0,
    "peak-rpm": 5500.0,
    "city-mpg": 25,
    "highway-mpg": 31,
    "price": 10345.0
  }
]

Le modifiche garantiranno che il modello possa accettare l'input generato da Ricerca cognitiva durante l'indicizzazione, ovvero un singolo record.

{
    "symboling": 2,
    "make": "mitsubishi",
    "fuel-type": "gas",
    "aspiration": "std",
    "num-of-doors": "two",
    "body-style": "hatchback",
    "drive-wheels": "fwd",
    "engine-location": "front",
    "wheel-base": 93.7,
    "length": 157.3,
    "width": 64.4,
    "height": 50.8,
    "curb-weight": 1944,
    "engine-type": "ohc",
    "num-of-cylinders": "four",
    "engine-size": 92,
    "fuel-system": "2bbl",
    "bore": 2.97,
    "stroke": 3.23,
    "compression-ratio": 9.4,
    "horsepower": 68.0,
    "peak-rpm": 5500.0,
    "city-mpg": 31,
    "highway-mpg": 38,
    "price": 6189.0
}

Sostituire le righe da 27 a 30 con


    for key, val in data.items():
        input_entry[key].append(decode_nan(val))

Sarà anche necessario modificare l'output generato dallo script da una stringa a un oggetto JSON. Modifica l'istruzione return (riga 37) nel file originale a:

    output = result.data_frame.values.tolist()
    return {
        "predicted_price": output[0][-1]
    }

Ecco la funzione di run aggiornata con le modifiche nel formato di input e l'output stimato che accetterà un singolo record come input e restituirà un oggetto JSON con il prezzo stimato.

def run(data):
    data = json.loads(data)
    input_entry = defaultdict(list)
    # data is now a JSON object not a list of JSON objects
    for key, val in data.items():
        input_entry[key].append(decode_nan(val))

    data_frame_directory = create_dfd_from_dict(input_entry, schema_data)
    score_module = ScoreModelModule()
    result, = score_module.run(
        learner=model,
        test_data=DataTable.from_dfd(data_frame_directory),
        append_or_result_only=True)
    #return json.dumps({"result": result.data_frame.values.tolist()})
    output = result.data_frame.values.tolist()
    # return the last column of the the first row of the dataframe
    return  {
        "predicted_price": output[0][-1]
    }

Registrare e distribuire il modello

Dopo aver salvato le modifiche, è ora possibile registrare il modello nel portale. Selezionare il modello di registro e assegnargli un nome valido. Scegliere Other per Framework di modelli, Custom per Nome framework e 1.0 per Versione framework. Selezionare l'opzione Upload folder e selezionare la cartella con il score.py aggiornato e conda_env.yaml.

Selezionare il modello e selezionare l'azione Deploy. Il passaggio di distribuzione presuppone che sia stato effettuato il provisioning di un cluster AKS per inferenza. Le istanze di contenitori non sono attualmente supportate in Ricerca Cognitiva.

  1. Specificare un nome di endpoint valido
  2. Selezionare il tipo di elaborazione di Azure Kubernetes Service
  3. Selezionare il nome di calcolo per il cluster di inferenza
  4. Imposta enable authentication su attivo
  5. Selezionare Key-based authentication per il tipo
  6. Seleziona la score.py aggiornata per entry script file
  7. Selezionare il conda_env.yaml per conda dependencies file
  8. Selezionare il pulsante Distribuisci per distribuire il nuovo endpoint.

Per integrare l'endpoint appena creato con Ricerca cognitiva

  1. Aggiungere un file JSON contenente un singolo record dell'automobile a un contenitore Blob
  2. Configurare una pipeline di arricchimento tramite intelligenza artificiale usando la procedura guidata Importa dati. Assicurarsi di selezionare JSON come parsing mode
  3. Nella scheda Add Enrichments selezionare una singola competenza Extract people names come segnaposto.
  4. Aggiungere un nuovo campo all'indice denominato predicted_price di tipo Edm.Double, impostare la proprietà Recuperabile su true.
  5. Completare il processo di importazione dei dati

Aggiungere la competenza AML al set di competenze

Nell'elenco dei set di competenze selezionare il set di competenze creato. Ora si modificherà il set di competenze per sostituire la competenza di identificazione delle persone con la competenza AML per stimare i prezzi. Nella scheda Definizione delle competenze (JSON), selezionare Azure Machine Learning (AML) dall'elenco a discesa delle competenze. Selezionare l'area di lavoro. Per fare in modo che la funzione AML individui l'endpoint, l'area di lavoro e il servizio di ricerca devono trovarsi nella stessa sottoscrizione di Azure. Selezionare l'endpoint creato in precedenza nell'esercitazione. Verificare che la funzione sia popolata con l'URI e le informazioni di autenticazione configurate durante l'implementazione dell'endpoint. Copiare il modello di competenza e sostituire la competenza nel set di competenze. Modifica la competenza in:

  1. Impostare il nome su un nome valido
  2. Aggiungere una descrizione
  3. Impostare degreesOfParallelism su 1
  4. Impostare il contesto su /document
  5. Configurare tutti gli input necessari, vedere l'esempio di definizione di skill qui sotto.
  6. Impostare i risultati per registrare il prezzo previsto restituito.
{
      "@odata.type": "#Microsoft.Skills.Custom.AmlSkill",
      "name": "AMLdemo",
      "description": "AML Designer demo",
      "context": "/document",
      "uri": "Your AML endpoint",
      "key": "Your AML endpoint key",
      "resourceId": null,
      "region": null,
      "timeout": "PT30S",
      "degreeOfParallelism": 1,
      "inputs": [
        {
          "name": "symboling",
          "source": "/document/symboling"
        },
        {
          "name": "make",
          "source": "/document/make"
        },
        {
          "name": "fuel-type",
          "source": "/document/fuel-type"
        },
        {
          "name": "aspiration",
          "source": "/document/aspiration"
        },
        {
          "name": "num-of-doors",
          "source": "/document/num-of-doors"
        },
        {
          "name": "body-style",
          "source": "/document/body-style"
        },
        {
          "name": "drive-wheels",
          "source": "/document/drive-wheels"
        },
        {
          "name": "engine-location",
          "source": "/document/engine-location"
        },
        {
          "name": "wheel-base",
          "source": "/document/wheel-base"
        },
        {
          "name": "length",
          "source": "/document/length"
        },
        {
          "name": "width",
          "source": "/document/width"
        },
        {
          "name": "height",
          "source": "/document/height"
        },
        {
          "name": "curb-weight",
          "source": "/document/curb-weight"
        },
        {
          "name": "engine-type",
          "source": "/document/engine-type"
        },
        {
          "name": "num-of-cylinders",
          "source": "/document/num-of-cylinders"
        },
        {
          "name": "engine-size",
          "source": "/document/engine-size"
        },
        {
          "name": "fuel-system",
          "source": "/document/fuel-system"
        },
        {
          "name": "bore",
          "source": "/document/bore"
        },
        {
          "name": "stroke",
          "source": "/document/stroke"
        },
        {
          "name": "compression-ratio",
          "source": "/document/compression-ratio"
        },
        {
          "name": "horsepower",
          "source": "/document/horsepower"
        },
        {
          "name": "peak-rpm",
          "source": "/document/peak-rpm"
        },
        {
          "name": "city-mpg",
          "source": "/document/city-mpg"
        },
        {
          "name": "highway-mpg",
          "source": "/document/highway-mpg"
        },
        {
          "name": "price",
          "source": "/document/price"
        }
      ],
      "outputs": [
        {
          "name": "predicted_price",
          "targetName": "predicted_price"
        }
      ]
    }

Aggiornare i mapping dei campi di output dell'indicizzatore

Le mappature dei campi di output dell'indicizzatore determinano quali arricchimenti vengono salvati nell'indice. Sostituire la sezione mapping dei campi di output dell'indicizzatore con il frammento di codice seguente:

"outputFieldMappings": [
    {
      "sourceFieldName": "/document/predicted_price",
      "targetFieldName": "predicted_price"
    }
  ]

È ora possibile avviare l'indicizzatore e verificare che la proprietà predicted_price sia popolata nell'indice con il risultato dell'output del modello AML.

  • Last updated on