Gestire la quota del servizio OpenAI di Azure

La quota offre la flessibilità necessaria per gestire attivamente l'allocazione dei limiti di frequenza tra le distribuzioni all'interno della propria sottoscrizione. Questo articolo illustra il processo di gestione della quota OpenAI di Azure.

Prerequisiti

Introduzione alla quota

La funzionalità di quota di Azure OpenAI consente l'assegnazione di limiti di frequenza alle distribuzioni, fino a un limite globale denominato "quota". La quota viene assegnata alla sottoscrizione in base all'area e in base al modello in unità di token al minuto (TPM). Quando si esegue l'onboarding di una sottoscrizione in Azure OpenAI, si riceverà la quota predefinita per la maggior parte dei modelli disponibili. Quindi, si assegnerà TPM a ogni distribuzione durante la creazione, e la quota disponibile per tale modello verrà ridotta di tale importo. È possibile continuare a creare distribuzioni e assegnare loro TPM fino a raggiungere il limite di quota. In questo caso, è possibile creare solo nuove distribuzioni di tale modello riducendo il TPM assegnato ad altre distribuzioni dello stesso modello (liberando così TPM per l'uso) oppure richiedendo e approvando l'aumento della quota del modello nell'area desiderata.

Quando viene creata una distribuzione, il TPM assegnato eseguirà direttamente il mapping al limite di velocità dei token al minuto applicato alle richieste di inferenza. Verrà applicato anche un limite di frequenza Requests-Per-Minute (RPM) il cui valore viene impostato proporzionalmente all'assegnazione TPM usando il rapporto seguente:

6 RPM per 1000 TPM.

La flessibilità di distribuire TPM a livello globale all'interno di una sottoscrizione e di un'area ha consentito al servizio OpenAI di Azure di allentare altre restrizioni:

• Le risorse massime per area vengono aumentate a 30.
• Il limite alla creazione di non più di una distribuzione dello stesso modello in una risorsa è stato rimosso.

Assegnazione della quota

Quando si crea una distribuzione di modelli, è possibile assegnare token al minuto (TPM) a tale distribuzione. TPM può essere modificato in incrementi di 1.000 e verrà eseguito il mapping ai limiti di velocità TPM e RPM applicati alla distribuzione, come illustrato in precedenza.

Per creare una nuova distribuzione all’interno di Azure AI Studio, in Risorse condivise selezionare Distribuzioni>Distribuisci modello>Distribuisci modello di base>Seleziona modello>Conferma.

Dopo la distribuzione è possibile modificare l'allocazione TPM selezionando Modifica in Risorse condivise>Distribuzioni in Azure OpenAI Studio. È anche possibile modificare questa selezione all'interno della nuova esperienza di gestione delle quote in Gestione>Quote.

Impostazioni specifiche del modello

Distribuzioni di modelli diverse, dette anche classi di modelli, hanno valori TPM massimi univoci che è ora possibile controllare. Rappresenta la quantità massima di token al minuto (TPM) che può essere allocata a quel tipo di distribuzione del modello in una determinata area.

Tutte le altre classi del modello hanno un valore TPM massimo comune.

Visualizzare e richiedere la quota

Per visualizzare tutte le allocazioni delle quote tra le distribuzioni in una determinata area, selezionare Gestione>Quota in Azure AI Studio:

• Distribuzione: distribuzioni di modelli divise per classe modello.
• Tipo quota: esiste un valore di quota per area per ogni tipo di modello. La quota copre tutte le versioni del modello.
• Allocazione quota: per il nome della quota, mostra la quantità di quota usata dalle distribuzioni e la quota totale approvata per la sottoscrizione e l'area. Questa quantità di quota usata è rappresentata anche nel grafico a barre.
• Richiesta quota: l'icona in questo campo passa a un modulo in cui è possibile inviare richieste di aumento della quota.

Migrazione di distribuzioni esistenti

Nell'ambito della transizione al nuovo sistema di quota e all'allocazione basata su TPM, tutte le distribuzioni del modello OpenAI di Azure esistenti sono state migrate automaticamente per usare la quota. Nei casi in cui l'allocazione TPM/RPM esistente supera i valori predefiniti dovuti all'aumento del limite di velocità personalizzato precedente, il TPM equivalente è stato assegnato alle distribuzioni interessate.

Informazioni sui limiti di frequenza

L'assegnazione di TPM a una distribuzione imposta i limiti di velocità Token al minuto (TPM) e Requests-Per-Minute (RPM) per la distribuzione, come descritto in precedenza. I limiti di frequenza TPM si basano sul numero massimo di token che vengono stimati per essere elaborati da una richiesta al momento della ricezione della richiesta. Non è uguale al numero di token usato per la fatturazione, che viene calcolato dopo il completamento di tutte le elaborazioni.

Quando ogni richiesta viene ricevuta, Azure OpenAI calcola un numero massimo stimato di token elaborati che include quanto segue:

• Testo del prompt e conteggio
• Impostazione del parametro max_tokens
• Impostazione del parametro best_of

Quando le richieste arrivano nell'endpoint di distribuzione, il conteggio stimato di token max-processed-token viene aggiunto a un numero di token in esecuzione di tutte le richieste reimpostate ogni minuto. Se in qualsiasi momento durante quel minuto viene raggiunto il valore limite di velocità TPM, altre richieste riceveranno un codice di risposta 429 fino a quando il contatore non viene reimpostato.

I limiti di velocità RPM si basano sul numero di richieste ricevute nel tempo. Il limite di velocità prevede che le richieste vengano distribuite uniformemente in un periodo di un minuto. Se questo flusso medio non viene mantenuto, le richieste possono ricevere una risposta 429 anche se il limite non viene soddisfatto quando misurato nel corso di un minuto. Per implementare questo comportamento, il servizio Azure OpenAI valuta la frequenza delle richieste in ingresso in un breve periodo di tempo, in genere 1 o 10 secondi. Se il numero di richieste ricevute durante tale periodo supera quello previsto al limite RPM impostato, le nuove richieste riceveranno un codice di risposta 429 fino al periodo di valutazione successivo. Ad esempio, se Azure OpenAI monitora la frequenza delle richieste a intervalli di 1 secondo, la limitazione della frequenza si verifica per una distribuzione a 600 RPM se vengono ricevute più di 10 richieste durante ogni periodo di 1 secondo (600 richieste al minuto = 10 richieste al secondo).

Procedure consigliate per il limite di velocità

Per ridurre al minimo i problemi relativi ai limiti di frequenza, è consigliabile usare le tecniche seguenti:

• Impostare max_tokens e best_of sui valori minimi che servono alle esigenze dello scenario. Ad esempio, non impostare un valore max-token di grandi dimensioni se si prevede che le risposte siano ridotte.
• Usare la gestione delle quote per aumentare il TPM nelle distribuzioni con traffico elevato e ridurre il TPM nelle distribuzioni con esigenze limitate.
• Implementare la logica di ripetizione dei tentativi nell'applicazione.
• Evitare modifiche brusche nel carico di lavoro. Aumentare gradualmente il carico di lavoro.
• Testare modelli di aumento del carico diversi.

Automatizzare la distribuzione

Questa sezione contiene brevi modelli di esempio che consentono di iniziare a creare a livello di codice distribuzioni che usano la quota per impostare i limiti di frequenza di token al minuto (TPM). Con l'introduzione della quota è necessario usare la versione 2023-05-01 dell'API per le attività correlate alla gestione delle risorse. Questa versione dell'API è solo per la gestione delle risorse e non influisce sulla versione dell'API usata per l'inferenza di chiamate come completamenti, completamenti della chat, incorporamento, generazione di immagini e così via.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CognitiveServices/accounts/{accountName}/deployments/{deploymentName}?api-version=2023-05-01

curl -X PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resource-group-temp/providers/Microsoft.CognitiveServices/accounts/docs-openai-test-001/deployments/gpt-35-turbo-test-deployment?api-version=2023-05-01 \
  -H "Content-Type: application/json" \
  -H 'Authorization: Bearer YOUR_AUTH_TOKEN' \
  -d '{"sku":{"name":"Standard","capacity":10},"properties": {"model": {"format": "OpenAI","name": "gpt-35-turbo","version": "0613"}}}'

GET https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.CognitiveServices/locations/{location}/usages?api-version=2023-05-01

curl -X GET https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.CognitiveServices/locations/eastus/usages?api-version=2023-05-01 \
  -H "Content-Type: application/json" \
  -H 'Authorization: Bearer YOUR_AUTH_TOKEN' 

az cognitiveservices account deployment create --model-format
                                               --model-name
                                               --model-version
                                               --name
                                               --resource-group
                                               [--capacity]
                                               [--deployment-name]
                                               [--scale-capacity]
                                               [--scale-settings-scale-type {Manual, Standard}]
                                               [--sku]

az login

az cognitiveservices account deployment create -g test-resource-group -n test-resource-name --deployment-name test-deployment-name --model-name gpt-35-turbo --model-version "0613" --model-format OpenAI --sku-capacity 10 --sku-name "Standard"

az cognitiveservices usage list --location

az cognitiveservices usage list -l eastus

//
// This Azure Resource Manager template shows how to use the new schema introduced in the 2023-05-01 API version to 
// create deployments that set the model version and the TPM limits for standard deployments.
//
{
    "type": "Microsoft.CognitiveServices/accounts/deployments",
    "apiVersion": "2023-05-01",
    "name": "arm-je-aoai-test-resource/arm-je-std-deployment",    // Update reference to parent Azure OpenAI resource
    "dependsOn": [
        "[resourceId('Microsoft.CognitiveServices/accounts', 'arm-je-aoai-test-resource')]"  // Update reference to parent Azure OpenAI resource
    ],
    "sku": {
        "name": "Standard",      
        "capacity": 10            // The deployment will be created with a 10K TPM limit
    },
    "properties": {
        "model": {
            "format": "OpenAI",
            "name": "gpt-35-turbo",
            "version": "0613"        // Version 0613 of gpt-35-turbo will be used
        }
    }
}

//
// This Bicep template shows how to use the new schema introduced in the 2023-05-01 API version to 
// create deployments that set the model version and the TPM limits for standard deployments.
//
resource arm_je_std_deployment 'Microsoft.CognitiveServices/accounts/deployments@2023-05-01' = {
  parent: arm_je_aoai_resource   // Replace this with a reference to the parent Azure OpenAI resource
  name: 'arm-je-std-deployment'
  sku: {
    name: 'Standard'            
    capacity: 10                 // The deployment will be created with a 10K TPM limit
  }
  properties: {
    model: {
      format: 'OpenAI'
      name: 'gpt-35-turbo'
      version: '0613'           // gpt-35-turbo version 0613 will be used
    }
  }
}

# This Terraform template shows how to use the new schema introduced in the 2023-05-01 API version to 
# create deployments that set the model version and the TPM limits for standard deployments.
# 
# The new schema is not yet available in the AzureRM provider (target v4.0), so this template uses the AzAPI
# provider, which provides a Terraform-compatible interface to the underlying ARM structures.
# 
# For more details on these providers:
#     AzureRM: https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs
#     AzAPI: https://registry.terraform.io/providers/azure/azapi/latest/docs
#

# 
terraform {
  required_providers {
    azapi   = { source  = "Azure/azapi" }
    azurerm = { source  = "hashicorp/azurerm" }
  }
}

provider "azapi" {
  # Insert auth info here as necessary
}

provider "azurerm" {
    # Insert auth info here as necessary  
    features {
    }
}

# 
# To create a complete example, AzureRM is used to create a new resource group and Azure OpenAI Resource
# 
resource "azurerm_resource_group" "TERRAFORM-AOAI-TEST-GROUP" {
  name     = "TERRAFORM-AOAI-TEST-GROUP"
  location = "canadaeast"
}

resource "azurerm_cognitive_account" "TERRAFORM-AOAI-TEST-ACCOUNT" {
  name                  = "terraform-aoai-test-account"
  location              = "canadaeast"
  resource_group_name   = azurerm_resource_group.TERRAFORM-AOAI-TEST-GROUP.name
  kind                  = "OpenAI"
  sku_name              = "S0"
  custom_subdomain_name = "terraform-test-account-"
  }


# 
# AzAPI is used to create the deployment so that the TPM limit and model versions can be set
#
resource "azapi_resource" "TERRAFORM-AOAI-STD-DEPLOYMENT" {
  type      = "Microsoft.CognitiveServices/accounts/deployments@2023-05-01"
  name      = "TERRAFORM-AOAI-STD-DEPLOYMENT"
  parent_id = azurerm_cognitive_account.TERRAFORM-AOAI-TEST-ACCOUNT.id

  body = jsonencode({
    sku = {                            # The sku object specifies the deployment type and limit in 2023-05-01
        name = "Standard",             
        capacity = 10                  # This deployment will be set with a 10K TPM limit
    },
    properties = {
        model = {
            format = "OpenAI",
            name = "gpt-35-turbo",
            version = "0613"           # Deploy gpt-35-turbo version 0613
        }
    }
  })
}

Eliminazione delle risorse

Quando si prova a eliminare una risorsa di OpenAI di Azure dal portale di Azure, se le distribuzioni sono ancora presenti, l'eliminazione viene bloccata fino a quando non vengono eliminate le distribuzioni associate. L'eliminazione delle distribuzioni consente innanzitutto di liberare correttamente le allocazioni delle quote in modo che possano essere usate nelle nuove distribuzioni.

Se tuttavia si elimina una risorsa usando l'API REST o un altro metodo programmatico, sarà possibile evitare la necessità di eliminare prima le distribuzioni. In questo caso, l'allocazione della quota associata rimarrà non disponibile per l'assegnazione a una nuova distribuzione per 48 ore fino a quando la risorsa non viene rimossa. Per attivare una rimozione immediata di una risorsa eliminata per liberare la quota, seguire le istruzioni per la rimozione di una risorsa eliminata.

Passaggi successivi

• Per esaminare le impostazioni predefinite delle quote per OpenAI di Azure, vedere l'articolo relativo a quote e limiti