API för Azure AI-modellinferens | Azure Machine Learning

Azure AI Model Inference är ett API som exponerar en gemensam uppsättning funktioner för grundläggande modeller och som kan användas av utvecklare för att använda förutsägelser från en mängd olika modeller på ett enhetligt och konsekvent sätt. Utvecklare kan prata med olika modeller som distribueras i Azure AI Studio utan att ändra den underliggande kod de använder.

Förmåner

Grundläggande modeller, som språkmodeller, har verkligen gjort anmärkningsvärda framsteg under de senaste åren. Dessa framsteg har revolutionerat olika områden, inklusive bearbetning av naturligt språk och visuellt innehåll, och de har aktiverat program som chattrobotar, virtuella assistenter och språköversättningstjänster.

Även om grundläggande modeller utmärker sig i specifika domäner saknar de en enhetlig uppsättning funktioner. Vissa modeller är bättre på specifika uppgifter och även i samma uppgift kan vissa modeller närma sig problemet på ett sätt medan andra i en annan. Utvecklare kan dra nytta av den här mångfalden genom att använda rätt modell för rätt jobb så att de kan:

• Förbättra prestandan i en specifik nedströmsaktivitet.
• Använd effektivare modeller för enklare uppgifter.
• Använd mindre modeller som kan köras snabbare på specifika uppgifter.
• Skapa flera modeller för att utveckla intelligenta upplevelser.

Med ett enhetligt sätt att använda grundläggande modeller kan utvecklare utnyttja alla dessa fördelar utan att offra portabilitet eller ändra den underliggande koden.

Tillgänglighet

Api:et för Azure AI-modellinferens är tillgängligt i följande modeller:

Modeller som distribueras till serverlösa API-slutpunkter:

• Cohere Embed V3-serien med modeller
• Cohere Command R-serien med modeller
• Meta Llama 2 chattfamilj av modeller
• Meta Llama 3 instruera familj av modeller
• Mistral-Small
• Mistral-Large
• Jais-serien med modeller
• Jamba-serien med modeller
• Phi-3-modellfamilj

Modeller som distribuerats till hanterad slutsatsdragning:

• Meta Llama 3 instruera familj av modeller
• Phi-3-modellfamilj
• Mixtral famility av modeller

API:et är kompatibelt med Azure OpenAI-modelldistributioner.

Kommentar

Azure AI-modellinferens-API:et är tillgängligt i hanterad slutsatsdragning (Managed Online Endpoints) för modeller som distribuerats efter den 24 juni 2024. Om du vill gå vidare med API:et distribuerar du om slutpunkten om modellen har distribuerats före det datumet.

Funktioner

I följande avsnitt beskrivs några av de funktioner som API:et exponerar. En fullständig specifikation av API:et finns i referensavsnittet.

Modaliteter

API:et anger hur utvecklare kan använda förutsägelser för följande metoder:

• Hämta information: Returnerar informationen om modellen som distribuerats under slutpunkten.
• Textinbäddningar: Skapar en inbäddningsvektor som representerar indatatexten.
• Textavslutningar: Skapar ett slutförande för den angivna prompten och parametrarna.
• Chattavslut: Skapar ett modellsvar för den angivna chattkonversationen.
• Bildinbäddningar: Skapar en inbäddningsvektor som representerar indatatexten och bilden.

Stöd för slutsatsdragnings-SDK

Du kan använda strömlinjeformade slutsatsdragningsklienter på valfritt språk för att använda förutsägelser från modeller som kör Azure AI-modellinferens-API:et.

Python

Installera paketet azure-ai-inference med hjälp av pakethanteraren, till exempel pip:

pip install azure-ai-inference

Sedan kan du använda paketet för att använda modellen. I följande exempel visas hur du skapar en klient för att använda chattavslutningar:

import os
from azure.ai.inference import ChatCompletionsClient
from azure.core.credentials import AzureKeyCredential

client = ChatCompletionsClient(
    endpoint=os.environ["AZUREAI_ENDPOINT_URL"],
    credential=AzureKeyCredential(os.environ["AZUREAI_ENDPOINT_KEY"]),
)

Om du använder en slutpunkt med stöd för Entra-ID kan du skapa klienten på följande sätt:

import os
from azure.ai.inference import ChatCompletionsClient
from azure.identity import AzureDefaultCredential

client = ChatCompletionsClient(
    endpoint=os.environ["AZUREAI_ENDPOINT_URL"],
    credential=AzureDefaultCredential(),
)

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

JavaScript

Installera paketet @azure-rest/ai-inference med npm:

npm install @azure-rest/ai-inference

Sedan kan du använda paketet för att använda modellen. I följande exempel visas hur du skapar en klient för att använda chattavslutningar:

import ModelClient from "@azure-rest/ai-inference";
import { isUnexpected } from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";

const client = new ModelClient(
    process.env.AZUREAI_ENDPOINT_URL, 
    new AzureKeyCredential(process.env.AZUREAI_ENDPOINT_KEY)
);

För slutpunkt med stöd för Microsoft Entra-ID kan du skapa din klient på följande sätt:

import ModelClient from "@azure-rest/ai-inference";
import { isUnexpected } from "@azure-rest/ai-inference";
import { AzureDefaultCredential } from "@azure/identity";

const client = new ModelClient(
    process.env.AZUREAI_ENDPOINT_URL, 
    new AzureDefaultCredential()
);

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

C#

Installera Azure AI-slutsatsdragningsbiblioteket med följande kommando:

dotnet add package Azure.AI.Inference --prerelease

För slutpunkt med stöd för Microsoft Entra-ID (tidigare Azure Active Directory) installerar du Azure.Identity paketet:

dotnet add package Azure.Identity

Importera följande namnområden:

using Azure;
using Azure.Identity;
using Azure.AI.Inference;

Sedan kan du använda paketet för att använda modellen. I följande exempel visas hur du skapar en klient för att använda chattavslutningar:

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_INFERENCE_ENDPOINT")),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);

För slutpunkt med stöd för Microsoft Entra-ID (tidigare Azure Active Directory):

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_INFERENCE_ENDPOINT")),
    new DefaultAzureCredential(includeInteractiveCredentials: true)
);

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

REST

Använd referensavsnittet för att utforska API-designen och vilka parametrar som är tillgängliga. Referensavsnittet för chattavslut beskriver till exempel hur du använder vägen /chat/completions för att generera förutsägelser baserat på chattformaterade instruktioner:

Begär

POST /chat/completions?api-version=2024-04-01-preview
Authorization: Bearer <bearer-token>
Content-Type: application/json

Utökningsbarhet

AZURE AI Model Inference API anger en uppsättning modaliteter och parametrar som modeller kan prenumerera på. Vissa modeller kan dock ha ytterligare funktioner som API:et anger. I dessa fall tillåter API:et att utvecklaren skickar dem som extra parametrar i nyttolasten.

Genom att ange ett huvud extra-parameters: pass-throughförsöker API:et skicka alla okända parametrar direkt till den underliggande modellen. Om modellen kan hantera den parametern slutförs begäran.

I följande exempel visas en begäran som skickar parametern safe_prompt som stöds av Mistral-Large, som inte anges i AZURE AI Model Inference API:

Python

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    model_extras={
        "safe_mode": True
    }
)

print(response.choices[0].message.content)

Dricks

När du använder Azure AI Inference SDK konfigurerar med hjälp model_extras av begäran extra-parameters: pass-through automatiskt åt dig.

JavaScript

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    "extra-parameters": "pass-through",
    body: {
        messages: messages,
        safe_mode: true
    }
});

console.log(response.choices[0].message.content)

C#

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    AdditionalProperties = { { "logprobs", BinaryData.FromString("true") } },
};

response = client.Complete(requestOptions, extraParams: ExtraParameters.PassThrough);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

REST

Begär

POST /chat/completions?api-version=2024-04-01-preview
Authorization: Bearer <bearer-token>
Content-Type: application/json
extra-parameters: pass-through

{
    "messages": [
    {
        "role": "system",
        "content": "You are a helpful assistant"
    },
    {
        "role": "user",
        "content": "Explain Riemann's conjecture in 1 paragraph"
    }
    ],
    "temperature": 0,
    "top_p": 1,
    "response_format": { "type": "text" },
    "safe_prompt": true
}

Kommentar

Standardvärdet för extra-parameters returnerar error ett fel om en extra parameter anges i nyttolasten. Du kan också ange extra-parameters: drop att släppa valfri okänd parameter i begäran. Använd den här funktionen om du råkar skicka begäranden med extra parametrar som du vet att modellen inte stöder, men du vill att begäran ska slutföras ändå. Ett typiskt exempel på detta är att ange seed parametern.

Modeller med olika uppsättning funktioner

Azure AI Model Inference API anger en allmän uppsättning funktioner, men var och en av modellerna kan välja att implementera dem eller inte. Ett specifikt fel returneras i de fall där modellen inte kan stödja en specifik parameter.

I följande exempel visas svaret för en begäran om chattavslut som anger parametern reponse_format och ber om ett svar i JSON format. I exemplet returneras felet 422 till användaren eftersom modellen inte stöder den här funktionen.

Python

import json
from azure.ai.inference.models import SystemMessage, UserMessage, ChatCompletionsResponseFormatJSON
from azure.core.exceptions import HttpResponseError

try:
    response = client.complete(
        messages=[
            SystemMessage(content="You are a helpful assistant."),
            UserMessage(content="How many languages are in the world?"),
        ],
        response_format=ChatCompletionsResponseFormatJSON()
    )
except HttpResponseError as ex:
    if ex.status_code == 422:
        response = json.loads(ex.response._content.decode('utf-8'))
        if isinstance(response, dict) and "detail" in response:
            for offending in response["detail"]:
                param = ".".join(offending["loc"])
                value = offending["input"]
                print(
                    f"Looks like the model doesn't support the parameter '{param}' with value '{value}'"
                )
    else:
        raise ex

JavaScript

try {
    var messages = [
        { role: "system", content: "You are a helpful assistant" },
        { role: "user", content: "How many languages are in the world?" },
    ];
    
    var response = await client.path("/chat/completions").post({
        body: {
            messages: messages,
            response_format: { type: "json_object" }
        }
    });
}
catch (error) {
    if (error.status_code == 422) {
        var response = JSON.parse(error.response._content)
        if (response.detail) {
            for (const offending of response.detail) {
                var param = offending.loc.join(".")
                var value = offending.input
                console.log(`Looks like the model doesn't support the parameter '${param}' with value '${value}'`)
            }
        }
    }
    else 
    {
        throw error
    }
}

C#

try
{
    requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are a helpful assistant"),
            new ChatRequestUserMessage("How many languages are in the world?"),
        },
        ResponseFormat = new ChatCompletionsResponseFormatJSON()
    };

    response = client.Complete(requestOptions);
    Console.WriteLine(response.Value.Choices[0].Message.Content);
}
catch (RequestFailedException ex)
{
    if (ex.Status == 422)
    {
        Console.WriteLine($"Looks like the model doesn't support a parameter: {ex.Message}");
    }
    else
    {
        throw;
    }
}

REST

Begär

POST /chat/completions?api-version=2024-04-01-preview
Authorization: Bearer <bearer-token>
Content-Type: application/json

{
    "messages": [
    {
        "role": "system",
        "content": "You are a helpful assistant"
    },
    {
        "role": "user",
        "content": "Explain Riemann's conjecture in 1 paragraph"
    }
    ],
    "temperature": 0,
    "top_p": 1,
    "response_format": { "type": "json_object" },
}

Response

{
    "status": 422,
    "code": "parameter_not_supported",
    "detail": {
        "loc": [ "body", "response_format" ],
        "input": "json_object"
    },
    "message": "One of the parameters contain invalid values."
}

Dricks

Du kan kontrollera egenskapen detail.loc för att förstå platsen för den felaktiga parametern och detail.input för att se värdet som skickades i begäran.

Innehållssäkerhet

Azure AI-modellinferens-API:et stöder Azure AI Content Safety. När du använder distributioner med Azure AI Content Safety på passerar indata och utdata genom en uppsättning klassificeringsmodeller som syftar till att identifiera och förhindra utdata från skadligt innehåll. Systemet för innehållsfiltrering (förhandsversion) identifierar och vidtar åtgärder för specifika kategorier av potentiellt skadligt innehåll i både inkommande prompter och slutföranden av utdata.

I följande exempel visas svaret på en begäran om chattavslut som har utlöst innehållssäkerhet.

Python

from azure.ai.inference.models import AssistantMessage, UserMessage, SystemMessage
from azure.core.exceptions import HttpResponseError

try:
    response = client.complete(
        messages=[
            SystemMessage(content="You are an AI assistant that helps people find information."),
            UserMessage(content="Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."),
        ]
    )

    print(response.choices[0].message.content)

except HttpResponseError as ex:
    if ex.status_code == 400:
        response = json.loads(ex.response._content.decode('utf-8'))
        if isinstance(response, dict) and "error" in response:
            print(f"Your request triggered an {response['error']['code']} error:\n\t {response['error']['message']}")
        else:
            raise ex
    else:
        raise ex

JavaScript

try {
    var messages = [
        { role: "system", content: "You are an AI assistant that helps people find information." },
        { role: "user", content: "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills." },
    ]

    var response = await client.path("/chat/completions").post({
        body: {
            messages: messages,
        }
    });
    
    console.log(response.body.choices[0].message.content)
}
catch (error) {
    if (error.status_code == 400) {
        var response = JSON.parse(error.response._content)
        if (response.error) {
            console.log(`Your request triggered an ${response.error.code} error:\n\t ${response.error.message}`)
        }
        else
        {
            throw error
        }
    }
}

C#

try
{
    requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are an AI assistant that helps people find information."),
            new ChatRequestUserMessage(
                "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
            ),
        },
    };

    response = client.Complete(requestOptions);
    Console.WriteLine(response.Value.Choices[0].Message.Content);
}
catch (RequestFailedException ex)
{
    if (ex.ErrorCode == "content_filter")
    {
        Console.WriteLine($"Your query has trigger Azure Content Safeaty: {ex.Message}");
    }
    else
    {
        throw;
    }
}

REST

Begär

POST /chat/completions?api-version=2024-04-01-preview
Authorization: Bearer <bearer-token>
Content-Type: application/json

{
    "messages": [
    {
        "role": "system",
        "content": "You are a helpful assistant"
    },
    {
        "role": "user",
        "content": "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
    }
    ],
    "temperature": 0,
    "top_p": 1,
}

Response

{
    "status": 400,
    "code": "content_filter",
    "message": "The response was filtered",
    "param": "messages",
    "type": null
}

Komma igång

Azure AI Model Inference API stöds för närvarande i vissa modeller som distribueras som serverlösa API-slutpunkter och hanterade onlineslutpunkter. Distribuera någon av de modeller som stöds och använd exakt samma kod för att använda deras förutsägelser.

Python

Klientbiblioteket azure-ai-inference gör slutsatsdragningar, inklusive chattavslut, för AI-modeller som distribueras av Azure AI Studio och Azure Machine Learning Studio. Den stöder serverlösa API-slutpunkter och hanterade beräkningsslutpunkter (kallades tidigare managed online-slutpunkter).

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

JavaScript

Klientbiblioteket @azure-rest/ai-inference gör slutsatsdragningar, inklusive chattavslut, för AI-modeller som distribueras av Azure AI Studio och Azure Machine Learning Studio. Den stöder serverlösa API-slutpunkter och hanterade beräkningsslutpunkter (kallades tidigare managed online-slutpunkter).

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

C#

Klientbiblioteket Azure.Ai.Inference gör slutsatsdragningar, inklusive chattavslut, för AI-modeller som distribueras av Azure AI Studio och Azure Machine Learning Studio. Den stöder serverlösa API-slutpunkter och hanterade beräkningsslutpunkter (kallades tidigare managed online-slutpunkter).

Utforska våra exempel och läs API-referensdokumentationen för att komma igång.

REST

Utforska referensavsnittet i API:et för Azure AI-modellinferens för att se parametrar och alternativ för att använda modeller, inklusive modeller för chattavslut, som distribueras av Azure AI Studio och Azure Machine Learning Studio. Den stöder serverlösa API-slutpunkter och hanterade beräkningsslutpunkter (kallades tidigare managed online-slutpunkter).

• Hämta information: Returnerar informationen om modellen som distribuerats under slutpunkten.
• Textinbäddningar: Skapar en inbäddningsvektor som representerar indatatexten.
• Textavslutningar: Skapar ett slutförande för den angivna prompten och parametrarna.
• Chattavslut: Skapar ett modellsvar för den angivna chattkonversationen.
• Bildinbäddningar: Skapar en inbäddningsvektor som representerar indatatexten och bilden.