Condividi tramite

Creare e configurare tutte le risorse per l'inferenza del modello di intelligenza artificiale di Azure

  • Articolo

Importante

Gli elementi contrassegnati (anteprima) in questo articolo sono attualmente disponibili in anteprima pubblica. Questa anteprima viene fornita senza un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Questo articolo illustra come creare le risorse necessarie per usare l'inferenza del modello di intelligenza artificiale di Azure e usare modelli di punta dal catalogo dei modelli di intelligenza artificiale di Azure.

Prerequisiti

Per completare questo articolo, devi avere quanto segue:

Importante

Il portale di Azure AI Foundry usa progetti e hub per creare account di Servizi di intelligenza artificiale di Azure e configurare l'inferenza del modello di intelligenza artificiale di Azure. Se non si vogliono usare hub e progetti, è possibile creare le risorse usando l'interfaccia della riga di comando di Azure, Bicep o creare la risorsa dei servizi di intelligenza artificiale di Azure usando il portale di Azure.

Creare le risorse

Per creare un progetto con un account di Servizi di intelligenza artificiale di Azure, seguire questa procedura:

  1. Passare al portale di Azure AI Foundry.

  2. Nella pagina di destinazione selezionare Crea progetto.

  3. Assegnare un nome al progetto, ad esempio "my-project".

  4. In questa esercitazione viene creato un nuovo progetto in un nuovo hub di intelligenza artificiale, quindi selezionare Crea nuovo hub.

  5. Assegnare all'hub un nome, ad esempio "my-hub" e selezionare Avanti.

  6. La procedura guidata viene aggiornata con informazioni dettagliate sulle risorse che verranno create. Selezionare Risorse di Azure da creare per visualizzare i dettagli.

    Screenshot che mostra i dettagli del progetto e dell'hub da creare.

  7. È possibile notare che vengono create le risorse seguenti:

    Proprietà Descrizione
    Gruppo di risorse Contenitore principale per tutte le risorse in Azure. In questo modo è possibile ottenere risorse che interagiscono tra loro. Consente inoltre di avere un ambito per i costi associati all'intero progetto.
    Ufficio Area delle risorse create.
    Hub Contenitore principale per i progetti di intelligenza artificiale in Azure AI Foundry. Hub promuove la collaborazione e consente di archiviare le informazioni per i progetti.
    Servizi di intelligenza artificiale La risorsa che consente l'accesso ai modelli di punta nel catalogo dei modelli di intelligenza artificiale di Azure. In questa esercitazione viene creato un nuovo account, ma le risorse dei servizi di intelligenza artificiale di Azure possono essere condivise tra più hub e progetti. Gli hub usano una connessione alla risorsa per avere accesso alle distribuzioni del modello disponibili in questa posizione. Per informazioni su come, è possibile creare connessioni tra progetti e Servizi di intelligenza artificiale di Azure per usare l'inferenza del modello di intelligenza artificiale di Azure, è possibile leggere Connettere il progetto di intelligenza artificiale.

  8. Selezionare Crea. Viene avviato il processo di creazione delle risorse.

  9. Al termine, il progetto è pronto per la configurazione.

  10. L'inferenza del modello di intelligenza artificiale di Azure è una funzionalità di anteprima che deve essere attivata in Azure AI Foundry. Nella barra di spostamento superiore selezionare l'icona Anteprima funzionalità nell'angolo destro. Un pannello contestuale viene visualizzato a destra dello schermo.

  11. Abilitare la funzionalità Distribuire modelli nel servizio di inferenza del modello di intelligenza artificiale di Azure.

    Animazione che illustra come attivare la funzionalità di inferenza del servizio di inferenza del modello di intelligenza artificiale di Azure nel portale di Azure AI Foundry.

  12. Chiudere il pannello.

  13. Per usare l'inferenza del modello di intelligenza artificiale di Azure, è necessario aggiungere distribuzioni di modelli all'account dei servizi di intelligenza artificiale di Azure.

    Aggiungere e configurare modelli

Importante

Gli elementi contrassegnati (anteprima) in questo articolo sono attualmente disponibili in anteprima pubblica. Questa anteprima viene fornita senza un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

È possibile decidere e configurare i modelli disponibili per l'inferenza nell'endpoint di inferenza. Quando un determinato modello è configurato, è quindi possibile generare stime da esso indicando il nome del modello o il nome della distribuzione nelle richieste. Non sono necessarie altre modifiche nel codice per usarle.

Questo articolo descrive come aggiungere un nuovo modello all'inferenza del modello di intelligenza artificiale di Azure in Azure AI Foundry.

Prerequisiti

Per completare questo articolo, devi avere quanto segue:

  • Una sottoscrizione di Azure. Se si usano i modelli GitHub, è possibile aggiornare l'esperienza e creare una sottoscrizione di Azure nel processo. Leggere Eseguire l'aggiornamento dai modelli GitHub all'inferenza del modello di intelligenza artificiale di Azure, se questo è il caso.

  • Una risorsa dei servizi di intelligenza artificiale di Azure.

  • Installare l'interfaccia della riga di comando di Azure e l'estensione cognitiveservices per i servizi di intelligenza artificiale di Azure:

    az extension add -n cognitiveservices

  • Alcuni dei comandi di questa esercitazione usano lo jq strumento , che potrebbe non essere installato nel sistema. Per istruzioni sull'installazione, vedere Scaricare jq.

  • Identificare le informazioni seguenti:

    • L'ID sottoscrizione di Azure.

    • Nome della risorsa di Servizi di intelligenza artificiale di Azure.

    • Gruppo di risorse in cui viene distribuita la risorsa di Servizi di intelligenza artificiale di Azure.

Aggiungi modelli

Per aggiungere un modello, è prima necessario identificare il modello da distribuire. È possibile eseguire query sui modelli disponibili nel modo seguente:

  1. Accedere alla sottoscrizione di Azure:

    az login

  2. Se sono presenti più di 1 sottoscrizione, selezionare la sottoscrizione in cui si trova la risorsa:

    az account set --subscription $subscriptionId>

  3. Impostare le variabili di ambiente seguenti con il nome della risorsa di Servizi di intelligenza artificiale di Azure che si intende usare e il gruppo di risorse.

    accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"

  4. Se non si ha ancora un account di Servizi di intelligenza artificiale di Azure, è possibile crearne uno come indicato di seguito:

    az cognitiveservices account create -n $accountName -g $resourceGroupName

  5. Vediamo prima quali modelli sono disponibili e in quale SKU. Il comando seguente elenca tutte le definizioni di modello disponibili:

    az cognitiveservices account list-models \
    -n $accountName \
    -g $resourceGroupName \
| jq '.[] | { name: .name, format: .format, version: .version, sku: .skus[0].name, capacity: .skus[0].capacity.default }'

  6. Gli output sono simili ai seguenti:

    {
  "name": "Phi-3.5-vision-instruct",
  "format": "Microsoft",
  "version": "2",
  "sku": "GlobalStandard",
  "capacity": 1
}

  7. Identificare il modello da distribuire. Sono necessarie le proprietà name, format, versione sku. La capacità potrebbe essere necessaria anche a seconda del tipo di distribuzione.

    Suggerimento

    Si noti che non tutti i modelli sono disponibili in tutti gli SKU.

  8. Aggiungere la distribuzione del modello alla risorsa. Nell'esempio seguente viene aggiunto Phi-3.5-vision-instruct:

    az cognitiveservices account deployment create \
    -n $accountName \
    -g $resourceGroupName \
    --deployment-name Phi-3.5-vision-instruct \
    --model-name Phi-3.5-vision-instruct \
    --model-version 2 \
    --model-format Microsoft \
    --sku-capacity 1 \
    --sku-name GlobalStandard

  9. Il modello è pronto per essere utilizzato.

È possibile distribuire lo stesso modello più volte, se necessario, purché si trovi con un nome di distribuzione diverso. Questa funzionalità può essere utile nel caso in cui si voglia testare configurazioni diverse per un determinato modello, inclusa la sicurezza del contenuto.

Gestire le distribuzioni

È possibile visualizzare tutte le distribuzioni disponibili usando l'interfaccia della riga di comando:

  1. Eseguire il comando seguente per visualizzare tutte le distribuzioni attive:

    az cognitiveservices account deployment list -n $accountName -g $resourceGroupName

  2. È possibile visualizzare i dettagli di una determinata distribuzione:

    az cognitiveservices account deployment show \
    --deployment-name "Phi-3.5-vision-instruct" \
    -n $accountName \
    -g $resourceGroupName

  3. È possibile eliminare una determinata distribuzione come indicato di seguito:

        az cognitiveservices account deployment delete \
    --deployment-name "Phi-3.5-vision-instruct" \
    -n $accountName \
    -g $resourceGroupName

Usare il modello

I modelli distribuiti nell'inferenza del modello di intelligenza artificiale di Azure possono essere usati usando l'endpoint di inferenza del modello di intelligenza artificiale di Azure per la risorsa. Quando si costruisce la richiesta, indicare il parametro model e inserire il nome di distribuzione del modello creato. È possibile ottenere l'URI per l'endpoint di inferenza a livello di codice usando il codice seguente:

Endpoint di inferenza

az cognitiveservices account show  -n $accountName -g $resourceGroupName | jq '.properties.endpoints["Azure AI Model Inference API"]'

Per effettuare richieste all'endpoint di inferenza del modello di intelligenza artificiale di Azure, aggiungere la route models, ad esempio https://<resource>.services.ai.azure.com/models. È possibile visualizzare le informazioni di riferimento sulle API per l'endpoint nella pagina di riferimento dell'API di inferenza del modello di intelligenza artificiale di Azure.

Chiavi di inferenza

az cognitiveservices account keys list  -n $accountName -g $resourceGroupName

Importante

Gli elementi contrassegnati (anteprima) in questo articolo sono attualmente disponibili in anteprima pubblica. Questa anteprima viene fornita senza un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Questo articolo illustra come creare le risorse necessarie per usare l'inferenza del modello di intelligenza artificiale di Azure e usare modelli di punta dal catalogo dei modelli di intelligenza artificiale di Azure.

Prerequisiti

Per completare questo articolo, devi avere quanto segue:

Informazioni sull'esercitazione

L'esempio in questo articolo è basato su esempi di codice contenuti nel repository Azure-Samples/azureai-model-inference-bicep . Per eseguire i comandi in locale senza dover copiare o incollare il contenuto del file, usare i comandi seguenti per clonare il repository e passare alla cartella per il linguaggio di codifica:

git clone https://github.com/Azure-Samples/azureai-model-inference-bicep

I file per questo esempio si trovano in:

cd azureai-model-inference-bicep/infra

Informazioni sulle risorse

L'esercitazione consente di creare:

  • Una risorsa di Servizi di Azure AI.
  • Distribuzione di modelli nello SKU Standard globale per ognuno dei modelli che supportano il pagamento in base al consumo.
  • (Facoltativamente) Un progetto e un hub di Intelligenza artificiale di Azure.
  • (Facoltativamente) Una connessione tra l'hub e i modelli in Servizi di intelligenza artificiale di Azure.

Per creare tali risorse si usano gli asset seguenti:

  1. Usare il modello modules/ai-services-template.bicep per descrivere la risorsa di Servizi di intelligenza artificiale di Azure:

    modules/ai-services-template.bicep

    @description('Location of the resource.')
param location string = resourceGroup().location

@description('Name of the Azure AI Services account.')
param accountName string

@description('The resource model definition representing SKU')
param sku string = 'S0'

@description('Whether or not to allow keys for this account.')
param allowKeys bool = true

@allowed([
  'Enabled'
  'Disabled'
])
@description('Whether or not public endpoint access is allowed for this account.')
param publicNetworkAccess string = 'Enabled'

@allowed([
  'Allow'
  'Deny'
])
@description('The default action for network ACLs.')
param networkAclsDefaultAction string = 'Allow'

resource account 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: accountName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  sku: {
    name: sku
  }
  kind: 'AIServices'
  properties: {
    publicNetworkAccess: publicNetworkAccess
    networkAcls: {
      defaultAction: networkAclsDefaultAction
    }
    disableLocalAuth: allowKeys
  }
}

output endpointUri string = account.properties.endpoints['Azure AI Model Inference API']
output id string = account.id

  2. Usare il modello modules/ai-services-deployment-template.bicep per descrivere le distribuzioni di modelli:

    modules/ai-services-deployment-template.bicep

    @description('Name of the Azure AI services account')
param accountName string

@description('Name of the model to deploy')
param modelName string

@description('Version of the model to deploy')
param modelVersion string

@allowed([
  'AI21 Labs'
  'Cohere'
  'Core42'
  'Meta'
  'Microsoft'
  'Mistral AI'
  'OpenAI'
])
@description('Model provider')
param modelPublisherFormat string

@allowed([
    'GlobalStandard'
    'Standard'
    'GlobalProvisioned'
    'Provisioned'
])
@description('Model deployment SKU name')
param skuName string = 'GlobalStandard'

@description('Content filter policy name')
param contentFilterPolicyName string = 'Microsoft.DefaultV2'

@description('Model deployment capacity')
param capacity int = 1

resource modelDeployment 'Microsoft.CognitiveServices/accounts/deployments@2024-04-01-preview' = {
  name: '${accountName}/${modelName}'
  sku: {
    name: skuName
    capacity: capacity
  }
  properties: {
    model: {
      format: modelPublisherFormat
      name: modelName
      version: modelVersion
    }
    raiPolicyName: contentFilterPolicyName == null ? 'Microsoft.Nill' : contentFilterPolicyName
  }
}

  3. Per praticità, si definisce il modello che si vuole avere nel servizio usando un file JSON. Il file infra/models.json contiene un elenco di oggetti JSON con chiavi name,versionprovider , e sku, che definisce i modelli di cui verrà effettuato il provisioning. Poiché i modelli supportano il pagamento in base al consumo, l'aggiunta di distribuzioni di modelli non comporta costi aggiuntivi. Modificare il file rimuovendo o aggiungendo le voci del modello che si desidera avere. L'esempio seguente mostra solo le prime 7 righe del file JSON:

    models.json

    [
  {
    "name": "AI21-Jamba-1.5-Large",
    "version": "1",
    "provider": "AI21 Labs",
    "sku": "GlobalStandard"
  },

  4. Se si prevede di usare progetti (scelta consigliata), sono necessari i modelli per creare un progetto, un hub e una connessione alla risorsa di Servizi di intelligenza artificiale di Azure:

    modules/project-hub-template.bicep

    param location string = resourceGroup().location

@description('Name of the Azure AI hub')
param hubName string = 'hub-dev'

@description('Name of the Azure AI project')
param projectName string = 'intelligent-apps'

@description('Name of the storage account used for the workspace.')
param storageAccountName string = replace(hubName, '-', '')
param keyVaultName string = replace(hubName, 'hub', 'kv')
param applicationInsightsName string = replace(hubName, 'hub', 'log')

@description('The container registry resource id if you want to create a link to the workspace.')
param containerRegistryName string = replace(hubName, '-', '')

@description('The tags for the resources')
param tagValues object = {
  owner: 'santiagxf'
  project: 'intelligent-apps'
  environment: 'dev'
}

var tenantId = subscription().tenantId
var resourceGroupName = resourceGroup().name
var storageAccountId = resourceId(resourceGroupName, 'Microsoft.Storage/storageAccounts', storageAccountName)
var keyVaultId = resourceId(resourceGroupName, 'Microsoft.KeyVault/vaults', keyVaultName)
var applicationInsightsId = resourceId(resourceGroupName, 'Microsoft.Insights/components', applicationInsightsName)
var containerRegistryId = resourceId(
  resourceGroupName,
  'Microsoft.ContainerRegistry/registries',
  containerRegistryName
)

resource storageAccount 'Microsoft.Storage/storageAccounts@2019-04-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  properties: {
    encryption: {
      services: {
        blob: {
          enabled: true
        }
        file: {
          enabled: true
        }
      }
      keySource: 'Microsoft.Storage'
    }
    supportsHttpsTrafficOnly: true
  }
  tags: tagValues
}

resource keyVault 'Microsoft.KeyVault/vaults@2019-09-01' = {
  name: keyVaultName
  location: location
  properties: {
    tenantId: tenantId
    sku: {
      name: 'standard'
      family: 'A'
    }
    enableRbacAuthorization: true
    accessPolicies: []
  }
  tags: tagValues
}

resource applicationInsights 'Microsoft.Insights/components@2018-05-01-preview' = {
  name: applicationInsightsName
  location: location
  kind: 'web'
  properties: {
    Application_Type: 'web'
  }
  tags: tagValues
}

resource containerRegistry 'Microsoft.ContainerRegistry/registries@2019-05-01' = {
  name: containerRegistryName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    adminUserEnabled: true
  }
  tags: tagValues
}

resource hub 'Microsoft.MachineLearningServices/workspaces@2024-07-01-preview' = {
  name: hubName
  kind: 'Hub'
  location: location
  identity: {
    type: 'systemAssigned'
  }
  sku: {
    tier: 'Standard'
    name: 'standard'
  }
  properties: {
    description: 'Azure AI hub'
    friendlyName: hubName
    storageAccount: storageAccountId
    keyVault: keyVaultId
    applicationInsights: applicationInsightsId
    containerRegistry: (empty(containerRegistryName) ? null : containerRegistryId)
    encryption: {
      status: 'Disabled'
      keyVaultProperties: {
        keyVaultArmId: keyVaultId
        keyIdentifier: ''
      }
    }
    hbiWorkspace: false
  }
  tags: tagValues
}

resource project 'Microsoft.MachineLearningServices/workspaces@2024-07-01-preview' = {
  name: projectName
  kind: 'Project'
  location: location
  identity: {
    type: 'systemAssigned'
  }
  sku: {
    tier: 'Standard'
    name: 'standard'
  }
  properties: {
    description: 'Azure AI project'
    friendlyName: projectName
    hbiWorkspace: false
    hubResourceId: hub.id
  }
  tags: tagValues
}

    modules/ai-services-connection-template.bicep

    @description('Name of the hub where the connection will be created')
param hubName string

@description('Name of the connection')
param name string

@description('Category of the connection')
param category string = 'AIServices'

@allowed(['AAD', 'ApiKey', 'ManagedIdentity', 'None'])
param authType string = 'AAD'

@description('The endpoint URI of the connected service')
param endpointUri string

@description('The resource ID of the connected service')
param resourceId string = ''

@secure()
param key string = ''


resource connection 'Microsoft.MachineLearningServices/workspaces/connections@2024-04-01-preview' = {
  name: '${hubName}/${name}'
  properties: {
    category: category
    target: endpointUri
    authType: authType
    isSharedToAll: true
    credentials: authType == 'ApiKey' ? {
      key: key
    } : null
    metadata: {
      ApiType: 'Azure'
      ResourceId: resourceId
    }
  }
}

Creare le risorse

Nella console seguire questa procedura:

  1. Definire la distribuzione principale:

    deploy-with-project.bicep

    @description('Location to create the resources in')
param location string = resourceGroup().location

@description('Name of the resource group to create the resources in')
param resourceGroupName string = resourceGroup().name

@description('Name of the AI Services account to create')
param accountName string = 'azurei-models-dev'

@description('Name of the project hub to create')
param hubName string = 'hub-azurei-dev'

@description('Name of the project to create in the project hub')
param projectName string = 'intelligent-apps'

@description('Path to a JSON file with the list of models to deploy. Each model is a JSON object with the following properties: name, version, provider')
var models = json(loadTextContent('models.json'))

module aiServicesAccount 'modules/ai-services-template.bicep' = {
  name: 'aiServicesAccount'
  scope: resourceGroup(resourceGroupName)
  params: {
    accountName: accountName
    location: location
  }
}

module projectHub 'modules/project-hub-template.bicep' = {
  name: 'projectHub'
  scope: resourceGroup(resourceGroupName)
  params: {
    hubName: hubName
    projectName: projectName
  }
}

module aiServicesConnection 'modules/ai-services-connection-template.bicep' = {
  name: 'aiServicesConnection'
  scope: resourceGroup(resourceGroupName)
  params: {
    name: accountName
    authType: 'AAD'
    endpointUri: aiServicesAccount.outputs.endpointUri
    resourceId: aiServicesAccount.outputs.id
    hubName: hubName
  }
  dependsOn: [
    projectHub
  ]
}

@batchSize(1)
module modelDeployments 'modules/ai-services-deployment-template.bicep' = [
  for (item, i) in models: {
    name: 'deployment-${item.name}'
    scope: resourceGroup(resourceGroupName)
    params: {
      accountName: accountName
      modelName: item.name
      modelVersion: item.version
      modelPublisherFormat: item.provider
      skuName: item.sku
    }
    dependsOn: [
      aiServicesAccount
    ]
  }
]

output endpoint string = aiServicesAccount.outputs.endpointUri

  2. Accedere ad Azure:

    az login

  3. Assicurarsi di essere nella sottoscrizione corretta:

    az account set --subscription "<subscription-id>"

  4. Eseguire la distribuzione:

    RESOURCE_GROUP="<resource-group-name>"

az deployment group create \
  --resource-group $RESOURCE_GROUP \
  --template-file deploy-with-project.bicep

  5. Se si vuole distribuire solo la risorsa di Servizi di intelligenza artificiale di Azure e le distribuzioni del modello, usare il file di distribuzione seguente:

    deploy.bicep

    @description('Location to create the resources in')
param location string = resourceGroup().location

@description('Name of the resource group to create the resources in')
param resourceGroupName string = resourceGroup().name

@description('Name of the AI Services account to create')
param accountName string = 'azurei-models-dev'

@description('Path to a JSON file with the list of models to deploy. Each model is a JSON object with the following properties: name, version, provider')
var models = json(loadTextContent('models.json'))

module aiServicesAccount 'modules/ai-services-template.bicep' = {
  name: 'aiServicesAccount'
  scope: resourceGroup(resourceGroupName)
  params: {
    accountName: accountName
    location: location
  }
}

@batchSize(1)
module modelDeployments 'modules/ai-services-deployment-template.bicep' = [
  for (item, i) in models: {
    name: 'deployment-${item.name}'
    scope: resourceGroup(resourceGroupName)
    params: {
      accountName: accountName
      modelName: item.name
      modelVersion: item.version
      modelPublisherFormat: item.provider
      skuName: item.sku
    }
    dependsOn: [
      aiServicesAccount
    ]
  }
]

output endpoint string = aiServicesAccount.outputs.endpointUri

  6. Eseguire la distribuzione:

    RESOURCE_GROUP="<resource-group-name>"

az deployment group create \
  --resource-group $RESOURCE_GROUP \
  --template-file deploy.bicep

  7. Il modello restituisce l'endpoint di inferenza del modello di intelligenza artificiale di Azure che è possibile usare per usare qualsiasi distribuzione del modello creata.

Passaggi successivi