Rövid útmutató: A GPT-35-Turbo és a GPT-4 használatának első lépései az Azure OpenAI szolgáltatással

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyenesen.

• A hozzáférést az Azure OpenAI a kívánt Azure-előfizetésen belül kapja meg.

  Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI-hoz való hozzáférésre a következő https://aka.ms/oai/accessűrlap kitöltésével jelentkezhet: . Ha probléma merül fel, nyisson meg egy hibát az adattárban, és lépjen velünk kapcsolatba.

• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Ugrás az Azure OpenAI Studióra

Lépjen az Azure OpenAI Studióba, https://oai.azure.com/ és jelentkezzen be olyan hitelesítő adatokkal, amelyek hozzáférnek az OpenAI-erőforráshoz. A bejelentkezési munkafolyamat során vagy után válassza ki a megfelelő könyvtárat, Azure-előfizetést és Azure OpenAI-erőforrást.

Az Azure OpenAI Studio kezdőlapján válassza a Csevegési játszótér lehetőséget.

Játszótér

Ismerkedjen meg az OpenAI képességeivel kód nélküli megközelítéssel az Azure OpenAI Studio Chat-játszótéren. Ezen a lapon gyorsan iterálhat és kísérletezhet a képességekkel.

Asszisztens beállítása

Az Assistant beállítási legördülő menüjében kiválaszthat néhány előre betöltött rendszerüzenet-példát az első lépésekhez.

A rendszerüzenetek útmutatást adnak a modellnek arról, hogyan kell viselkednie, és minden olyan környezetet, amelyre a válasz létrehozásakor hivatkoznia kell. Leírhatja az asszisztens személyiségét, megmondhatja, hogy mit kell és mit nem szabad válaszolnia, és megadhatja, hogyan formázhatja a válaszokat.

Néhány példa hozzáadása lehetővé teszi a modell által a kontextuson belüli tanuláshoz használt beszélgetési példák megadását.

A csevegési játszótér használata közben bármikor kiválaszthatja a Kód megtekintése lehetőséget a Python-, curl- és json-kódminták előzetes feltöltéséhez az aktuális csevegési munkamenet és beállítások kiválasztása alapján. Ezután használhatja ezt a kódot, és írhat egy alkalmazást, hogy elvégezze ugyanazt a feladatot, amit éppen a játszótéren végez.

Csevegési munkamenet

A Küldés gombra kattintva elküldi a beírt szöveget a befejezési API-nak, és az eredmények visszakerülnek a szövegmezőbe.

Válassza a Csevegés törlése gombot az aktuális beszélgetési előzmények törléséhez.

Beállítások

Panelek megjelenítése

Alapértelmezés szerint három panel van: asszisztens beállítása, csevegési munkamenet és beállítások. A panelek megjelenítése lehetővé teszi a panelek hozzáadását, eltávolítását és átrendeződését. Ha valaha bezár egy panelt, és vissza kell szereznie, a Panelek megjelenítése parancsot használva visszaállíthatja az elveszett panelt.

Csevegés indítása

1. Az asszisztens beállítási legördülő menüjében válassza az Xbox ügyfélszolgálati ügynökét

2. A rendszer kérni fogja, hogy frissíteni szeretné-e a rendszerüzenetet, és válassza a Folytatás lehetőséget.

3. A csevegési munkamenet paneljén adja meg a következő kérdést: "Szeretnék új Xboxot vásárolni", és válassza a Küldés lehetőséget.

4. A következőhöz hasonló választ kap:

   

5. Adjon meg egy következő kérdést, például: "mely modellek támogatják a 4K-t?"

   

6. Most, hogy már rendelkezik egy alapszintű beszélgetéssel, válassza a Kód megtekintése lehetőséget az Asszisztens beállítása területen, és az eddigi teljes beszélgetés mögött újra lejátszhatja a kódot:

#Note: The openai-python library support for Azure OpenAI is in preview.
import os
import openai
openai.api_type = "azure"
openai.api_base = "https://docs-test-001.openai.azure.com/"
openai.api_version = "2024-02-01"
openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
  engine="gpt-35-turbo", # replace this value with the deployment name you chose when you deployed the associated model.
  messages = [{"role":"system","content":"You are an Xbox customer support agent whose primary goal is to help users with issues they are experiencing with their Xbox devices. You are friendly and concise. You only provide factual answers to queries, and do not provide answers that are not related to Xbox."},{"role":"user","content":"How much is a PS5?"},{"role":"assistant","content":"I apologize, but I do not have information about the prices of other gaming devices such as the PS5. My primary focus is to assist with issues regarding Xbox devices. Is there a specific issue you are having with your Xbox device that I may be able to help with?"},{"role":"user","content":"I am interested in buying an Xbox?"},{"role":"assistant","content":"Great! There are several Xbox models available in the market, including the Xbox Series X, Xbox Series S, and Xbox One. The Xbox Series X is the latest and most powerful console, while the Xbox Series S is a more affordable option that still offers great performance. The Xbox One is the previous generation console, but it still has a large library of games available to play.\n\nBefore purchasing an Xbox, you may want to consider factors such as your budget, the types of games you want to play, and whether you want to play games in 4K resolution. Once you have decided on a console, you can purchase it from a retailer or directly from the Xbox website. Let me know if you have any other questions or concerns!"},{"role":"user","content":"Which models are 4K?"},{"role":"assistant","content":"Both the Xbox Series X and Xbox One X support 4K resolution gaming. The Xbox Series S, on the other hand, supports up to 1440p resolution gaming, but it can upscale games to 4K. It's worth noting that in order to take advantage of 4K gaming, you'll need a 4K TV or monitor that supports HDR (High Dynamic Range) and HDMI 2.0 or higher."}],
  temperature=0,
  max_tokens=350,
  top_p=0.95,
  frequency_penalty=0,
  presence_penalty=0,
  stop=None)

A parancssori struktúra ismertetése

Ha megvizsgálja a mintát a View-kódból, olyan egyedi jogkivonatokat fog látni, amelyek nem részei egy tipikus GPT-befejezési hívásnak. A GPT-35-Turbo speciális jogkivonatok használatával lett betanítva a parancssor különböző részeinek kijelölésére. A rendszer tartalmat biztosít a modellnek a két jogkivonat között <|im_start|><|im_end|> . A parancssor egy rendszerüzenettel kezdődik, amely a modell alapítására használható a modell környezetének vagy utasításainak belefoglalásával. Ezután a parancssor üzenetsorozatot tartalmaz a felhasználó és az asszisztens között.

Az asszisztens válasza a jogkivonat alatt jelenik meg, <|im_start|>assistant és azzal végződik <|im_end|> , hogy az asszisztens befejezte a választ. A Nyers szintaxis megjelenítése váltógombbal is megjelenítheti ezeket a jogkivonatokat a csevegési munkamenet paneljén.

A GPT-35-Turbo &GPT-4 útmutató részletesen bemutatja az új parancssori struktúrát és a gpt-35-turbo modell hatékony használatát.

A modell üzembe helyezése

Ha elégedett az Azure OpenAI Studio felhasználói élményével, közvetlenül a Studióból is üzembe helyezhet egy webalkalmazást a Telepítés a gombra kattintva.

Ez lehetővé teszi, hogy önálló webalkalmazásban, vagy a Copilot Studióban (előzetes verzió) telepítsen egy copilotot, ha saját adatokat használ a modellen.

Ha például egy webalkalmazás üzembe helyezését választja:

A webalkalmazás első üzembe helyezésekor válassza az Új webalkalmazás létrehozása lehetőséget. Válasszon egy nevet az alkalmazásnak, amely az alkalmazás URL-címének része lesz. Például: https://<appname>.azurewebsites.net.

Válassza ki a közzétett alkalmazás előfizetését, erőforráscsoportját, helyét és díjszabási csomagját. Meglévő alkalmazás frissítéséhez válassza a Közzététel egy meglévő webalkalmazásban lehetőséget, és válassza ki az előző alkalmazás nevét a legördülő menüből.

Ha úgy dönt, hogy üzembe helyez egy webalkalmazást, tekintse meg a használatának fontos szempontjait .

Az erőforrások eltávolítása

Ha végzett a csevegési játszótér tesztelésével, ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást vagy az erőforráscsoportot. Az erőforráscsoport törlése a hozzá társított egyéb erőforrásokat is törli.

• Portál
• Azure CLI

Következő lépések

• További információ az új gpt-35-turbo modell használatáról a GPT-35-Turbo & GPT-4 útmutatóval.
• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Forráskódcsomag (NuGet) | Samples| Retrieveal Augmented Generation (RAG) enterprise chat template | |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• A .NET 7 SDK
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Egy új .NET Core-alkalmazás létrehozása

Egy konzolablakban (például parancsmag, PowerShell vagy Bash) a dotnet new paranccsal hozzon létre egy új konzolalkalmazást a névvel azure-openai-quickstart. Ez a parancs egy egyszerű ""Helló világ!" alkalmazás" projektet hoz létre egyetlen C#-forrásfájllal: Program.cs.

dotnet new console -n azure-openai-quickstart

Módosítsa a könyvtárat az újonnan létrehozott alkalmazásmappára. Az alkalmazást a következőkkel hozhatja létre:

dotnet build

A buildkimenet nem tartalmazhat figyelmeztetést vagy hibát.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Telepítse az OpenAI .NET ügyfélkódtárat a következőkkel:

dotnet add package Azure.AI.OpenAI --prerelease

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Mintaalkalmazás létrehozása

Nyissa meg a program.cs fájlt a projektkönyvtárban, és cserélje le a következő kódra:

Válaszstreamelés nélkül

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName = "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

Response<ChatCompletions> response = client.GetChatCompletions(chatCompletionsOptions);

Console.WriteLine(response.Value.Choices[0].Message.Content);

Console.WriteLine();

dotnet run program.cs

Hozam

Yes, many of the Azure AI services support customer managed keys. Some examples include Text Analytics, Speech Services, and Translator. However, it's important to note that not all services support customer managed keys, so it's best to check the documentation for each individual service to see if it is supported.

Ez megvárja, amíg a modell a teljes választ generálja az eredmények nyomtatása előtt. Ha aszinkron módon szeretné streamelni a választ, és ki szeretné nyomtatni az eredményeket, a következő példában lecserélheti a program.cs tartalmát a kódra.

Aszinkron streameléssel

using Azure;
using Azure.AI.OpenAI;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key));

var chatCompletionsOptions = new ChatCompletionsOptions()
{
    DeploymentName= "gpt-35-turbo", //This must match the custom deployment name you chose for your model
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("Does Azure OpenAI support customer managed keys?"),
        new ChatRequestAssistantMessage("Yes, customer managed keys are supported by Azure OpenAI."),
        new ChatRequestUserMessage("Do other Azure AI services support this too?"),
    },
    MaxTokens = 100
};

await foreach (StreamingChatCompletionsUpdate chatUpdate in client.GetChatCompletionsStreaming(chatCompletionsOptions))
{
    if (chatUpdate.Role.HasValue)
    {
        Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
    }
    if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
    {
        Console.Write(chatUpdate.ContentUpdate);
    }
}

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Forráskódcsomag (Go)| -minták |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• Helyileg telepített 1.21.0-s vagy újabb verzió.
• Egy Azure OpenAI-szolgáltatáserőforrás a gpt-35-turbo modell üzembe helyezésével. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Mintaalkalmazás létrehozása

Hozzon létre egy chat_completions.go nevű új fájlt. Másolja a következő kódot a chat_completions.go fájlba .

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
    //modelDeploymentID = deployment name, if model name and deployment name do not match change this value to name chosen when you deployed the model.
	modelDeploymentID := "gpt-35-turbo" 

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential, err := azopenai.NewKeyCredential(azureOpenAIKey)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	// This is a conversation in progress.
	// NOTE: all messages, regardless of role, count against token usage for this API.
	messages := []azopenai.ChatMessage{
		// You set the tone and rules of the conversation with a prompt as the system role.
		{Role: to.Ptr(azopenai.ChatRoleSystem), Content: to.Ptr("You are a helpful assistant.")},

		// The user asks a question
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Does Azure OpenAI support customer managed keys?")},

		// The reply would come back from the Azure OpenAI model. You'd add it to the conversation so we can maintain context.
		{Role: to.Ptr(azopenai.ChatRoleAssistant), Content: to.Ptr("Yes, customer managed keys are supported by Azure OpenAI")},

		// The user answers the question based on the latest reply.
		{Role: to.Ptr(azopenai.ChatRoleUser), Content: to.Ptr("Do other Azure AI services support this too?")},

		// from here you'd keep iterating, sending responses back from the chat completions API
	}

	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
		// This is a conversation in progress.
		// NOTE: all messages count against token usage for this API.
		Messages:   messages,
		Deployment: modelDeploymentID,
	}, nil)

	if err != nil {
		//  TODO: Update the following line with your application specific error handling logic
		log.Fatalf("ERROR: %s", err)
	}

	for _, choice := range resp.Choices {
		fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
	}

}

Most nyisson meg egy parancssort, és futtassa a következőt:

go mod init chat_completions.go

Következő futtatás:

go mod tidy
go run chat_completions.go

Hozam

Content[0]: Yes, many Azure AI services also support customer managed keys. These services enable you to bring your own encryption keys for data at rest, which provides you with more control over the security of your data.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Forráskód-összetevő (Maven) | Samples | Retrieveal Augmented Generation (RAG) enterprise chat template | IntelliJ IDEA |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .

• A Java Development Kit (JDK) aktuális verziója

• A Gradle buildelési eszköz vagy egy másik függőségkezelő.
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Új Java-alkalmazás létrehozása

Hozzon létre egy új Gradle-projektet.

Egy konzolablakban (pl. cmd, PowerShell vagy Bash) hozzon létre egy új mappát az alkalmazásnak, majd navigáljon oda.

mkdir myapp && cd myapp

Futtassa a gradle init parancsot a munkakönyvtárból. Ez a parancs alapvető buildfájlokat hoz létre a Gradle-hez, beleértve a build.gradle.kts fájlt, amelyet futásidőben használnak az alkalmazás létrehozásához és konfigurálásához.

gradle init --type basic

Amikor a rendszer kéri, hogy válasszon egy DSL-t, válassza a Kotlin lehetőséget.

A Java SDK telepítése

Ez a rövid útmutató a Gradle függőségkezelőt használja. A Maven Central-adattárban megtalálhatja a többi függőségkezelő ügyfélkódtárát és információit.

Keresse meg a build.gradle.kts fájlt, és nyissa meg a kívánt IDE- vagy szövegszerkesztővel. Ezután másolja a következő buildkonfigurációba. Ez a konfiguráció java-alkalmazásként definiálja a projektet, amelynek belépési pontja az OpenAIQuickstart osztály. Importálja az Azure AI Vision-kódtárat.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.3")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Mintaalkalmazás létrehozása

1. Java-fájl létrehozása.

   A munkakönyvtárban futtassa a következő parancsot a projekt forrásmappájának létrehozásához:

   mkdir -p src/main/java
   

   Lépjen az új mappára, és hozzon létre egy OpenAIQuickstart.java nevű fájlt.

2. Nyissa meg OpenAIQuickstart.java az előnyben részesített szerkesztőben vagy IDE-ben, és illessze be az alábbi kódot.

   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.ChatChoice;
   import com.azure.ai.openai.models.ChatCompletions;
   import com.azure.ai.openai.models.ChatCompletionsOptions;
   import com.azure.ai.openai.models.ChatMessage;
   import com.azure.ai.openai.models.ChatRole;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GetChatCompletionsSample {
   
       public static void main(String[] args) {
           String azureOpenaiKey = System.getenv("AZURE_OPENAI_API_KEY");;
           String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");;
           String deploymentOrModelId = "gpt-35-turbo";
   
         OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<ChatMessage> chatMessages = new ArrayList<>();
           chatMessages.add(new ChatMessage(ChatRole.SYSTEM, "You are a helpful assistant"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Does Azure OpenAI support customer managed keys?"));
           chatMessages.add(new ChatMessage(ChatRole.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           chatMessages.add(new ChatMessage(ChatRole.USER, "Do other Azure AI services support this too?"));
   
           ChatCompletions chatCompletions = client.getChatCompletions(deploymentOrModelId, new ChatCompletionsOptions(chatMessages));
   
           System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
           for (ChatChoice choice : chatCompletions.getChoices()) {
               ChatMessage message = choice.getMessage();
               System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
               System.out.println("Message:");
               System.out.println(message.getContent());
           }
   
           System.out.println();
           CompletionsUsage usage = chatCompletions.getUsage();
           System.out.printf("Usage: number of prompt token is %d, "
                   + "number of completion token is %d, and number of total tokens in request and response is %d.%n",
               usage.getPromptTokens(), usage.getCompletionTokens(), usage.getTotalTokens());
       }
   }  
   

   Fontos

   Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. A hitelesítő adatok biztonságával kapcsolatos további információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

3. Lépjen vissza a projekt gyökérmappájához, és hozza létre az alkalmazást a következőkkel:

   gradle build
   

   Ezután futtassa a gradle run következő paranccsal:

   gradle run
   

Hozam

Model ID=chatcmpl-7JYnyE4zpd5gaIfTRH7hNpeVsvAw4 is created at 1684896378.
Index: 0, Chat Role: assistant.
Message:
Yes, most of the Azure AI services support customer managed keys. However, there may be some exceptions, so it is best to check the documentation of each specific service to confirm.

Usage: number of prompt token is 59, number of completion token is 36, and number of total tokens in request and response is 95.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Forráskód-összetevők (Maven) | Minta |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• A Java Development Kit (JDK) aktuális verziója
• A Spring Boot CLI-eszköz
• Egy Azure OpenAI-szolgáltatáserőforrás a gpt-35-turbo modell üzembe helyezésével. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

export SPRING_AI_AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export SPRING_AI_AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"
export SPRING_AI_AZURE_OPENAI_MODEL="REPLACE_WITH_YOUR_MODEL_NAME_HERE"

Új Spring-alkalmazás létrehozása

Hozzon létre egy új Spring-projektet.

Egy Bash-ablakban hozzon létre egy új könyvtárat az alkalmazáshoz, és navigáljon hozzá.

mkdir ai-chat-demo && cd ai-chat-demo

Futtassa a spring init parancsot a munkakönyvtárból. Ez a parancs létrehoz egy standard könyvtárstruktúrát a Spring-projekthez, beleértve a fő Java-osztály forrásfájlját és a Maven-alapú projektek kezeléséhez használt pom.xml fájlt.

spring init -a ai-chat-demo -n AIChat --force --build maven -x

A létrehozott fájlok és mappák a következő struktúrához hasonlítanak:

ai-chat-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aichatdemo/
    |                   |-- AiChatApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aichatdemo/
                        |-- AiChatApplicationTests.java

Spring-alkalmazás szerkesztése

1. Szerkessze a pom.xml fájlt.

   A projektkönyvtár gyökeréből nyissa meg a pom.xml fájlt az előnyben részesített szerkesztőben vagy IDE-ben, és írja felül a fájlt a következő tartalommal:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.2.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>ai-chat-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AIChat</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.experimental.ai</groupId>
               <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
               <version>0.7.0-SNAPSHOT</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
       <repositories>
           <repository>
               <id>spring-snapshots</id>
               <name>Spring Snapshots</name>
               <url>https://repo.spring.io/snapshot</url>
               <releases>
                   <enabled>false</enabled>
               </releases>
           </repository>
       </repositories>
   </project>
   

2. Az src/main/java/com/example/aichatdemo mappában nyissa meg a AiChatApplication.java az előnyben részesített szerkesztőben vagy IDE-ben, és illessze be a következő kódot:

   package com.example.aichatdemo;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.ChatMessage;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class AiChatApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiChatApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending chat prompts to AI service. One moment please...\r\n"));
   
           final List<Message> msgs = new ArrayList<>();
   
           msgs.add(new ChatMessage(MessageType.SYSTEM, "You are a helpful assistant"));
           msgs.add(new ChatMessage(MessageType.USER, "Does Azure OpenAI support customer managed keys?"));
           msgs.add(new ChatMessage(MessageType.ASSISTANT, "Yes, customer managed keys are supported by Azure OpenAI?"));
           msgs.add(new ChatMessage(MessageType.USER, "Do other Azure AI services support this too?"));
   
           final var resps = aiClient.generate(new Prompt(msgs));
   
           System.out.println(String.format("Prompt created %d generated response(s).", resps.getGenerations().size()));
   
           resps.getGenerations().stream()
             .forEach(gen -> {
                 final var role = gen.getInfo().getOrDefault(ROLE_INFO_KEY, MessageType.ASSISTANT.getValue());
   
                 System.out.println(String.format("Generated respose from \"%s\": %s", role, gen.getText()));
             });
       }
   
   }
   

   Fontos

   Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vaultot. A hitelesítő adatok biztonságával kapcsolatos további információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

3. Lépjen vissza a projekt gyökérmappájához, és futtassa az alkalmazást az alábbi paranccsal:

   ./mvnw spring-boot:run
   

Hozam

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.5)

2023-11-07T13:31:10.884-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : No active profile set, falling back to 1 default profile: "default"
2023-11-07T13:31:11.595-06:00  INFO 6248 --- [           main] c.example.aichatdemo.AiChatApplication   : Started AiChatApplication in 0.994 seconds (process running for 1.28)
Sending chat prompts to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Yes, other Azure AI services also support customer managed keys. Azure AI Services, Azure Machine Learning, and other AI services in Azure provide options for customers to manage and control their encryption keys. This allows customers to have greater control over their data and security.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Forráskódcsomag (npm) | Minták lekérése kiterjesztett generációs (RAG) vállalati csevegési sablonhoz | | |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• A Node.js LTS-verziói
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Csomópontalkalmazás létrehozása

Egy konzolablakban (pl. cmd, PowerShell vagy Bash) hozzon létre egy új mappát az alkalmazásnak, majd navigáljon oda. Ezután futtassa a npm init parancsot egy csomópontalkalmazás létrehozásához egy package.json fájllal.

npm init

Telepítse az ügyfélkódtárat

Telepítse a JavaScripthez készült Azure OpenAI ügyfélkódtárat az npm használatával:

npm install @azure/openai

Az alkalmazás package.json fájlja frissül a függőségekkel.

Mintaalkalmazás létrehozása

Nyisson meg egy parancssort, ahol az új projektet szeretné, és hozzon létre egy ChatCompletion.js nevű új fájlt. Másolja a következő kódot a ChatCompletion.js fájlba.

const { OpenAIClient, AzureKeyCredential } = require("@azure/openai");
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] ;
const azureApiKey = process.env["AZURE_OPENAI_API_KEY"] ;

const messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "Does Azure OpenAI support customer managed keys?" },
  { role: "assistant", content: "Yes, customer managed keys are supported by Azure OpenAI" },
  { role: "user", content: "Do other Azure AI services support this too" },
];

async function main() {
  console.log("== Chat Completions Sample ==");

  const client = new OpenAIClient(endpoint, new AzureKeyCredential(azureApiKey));
  const deploymentId = "gpt-35-turbo";
  const result = await client.getChatCompletions(deploymentId, messages);

  for (const choice of result.choices) {
    console.log(choice.message);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

Futtassa a szkriptet a következő paranccsal:

node.exe ChatCompletion.js

Hozam

== Chat Completions Sample ==
{
  role: 'assistant',
  content: 'Yes, most Azure AI services support customer managed keys. It is always best to check the specific service documentation to confirm this.'
}

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

• Az Azure OpenAI áttekintése
• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Kódtár forráskódcsomagja (PyPi) | Retrieveal Augmented Generation (RAG) enterprise chat template | |

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• Python 3.8 vagy újabb verzió.
• A következő Python-kódtárak: operációs rendszer.
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Telepítse az OpenAI Python ügyfélkódtárat a következőkkel:

pip install openai

pip install openai==0.28.1

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Új Python-alkalmazás létrehozása

1. Hozzon létre egy új Python-fájlt quickstart.py néven. Ezután nyissa meg a kívánt szerkesztőben vagy IDE-ben.

2. Cserélje le a quickstart.py tartalmát a következő kódra.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

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

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

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

3. Futtassa az alkalmazást a python gyorsútmutató-fájlban található paranccsal:

   python quickstart.py
   

Hozam

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.",
        "role": "assistant"
      }
    }
  ],
  "created": 1679001781,
  "id": "chatcmpl-6upLpNYYOx2AhoOYxl9UgJvF4aPpR",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 39,
    "prompt_tokens": 58,
    "total_tokens": 97
  }
}
Yes, most of the Azure AI services support customer managed keys. However, not all services support it. You can check the documentation of each service to confirm if customer managed keys are supported.

Az üzenetstruktúra ismertetése

A GPT-35-Turbo és a GPT-4 modellek úgy vannak optimalizálva, hogy beszélgetésként formázott bemenetekkel működjenek. A messages változó különböző szerepkörökkel rendelkező szótártömböt ad át a rendszer, a felhasználó és az asszisztens által meghatározott beszélgetésben. A rendszerüzenet a modell beállításához használható a környezet vagy a modell válaszára vonatkozó utasítások megadásával.

A GPT-35-Turbo &GPT-4 útmutató részletes bevezetést nyújt az új modellekkel való kommunikáció lehetőségeibe.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

• Útmutatónkból többet is megtudhat a GPT-35-Turbo és a GPT-4 modellek használatáról.
• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

REST API Spec |

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyenesen.
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Beállítás

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra van szükség.

Nyissa meg az erőforrást az Azure Portalon. A Kulcsok > végpont szakasz az Erőforrás-kezelés szakaszban található. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Környezeti változók

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE" 

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

REST API

Bash-rendszerhéjban futtassa a következő parancsot. A GPT-35-Turbo vagy GPT-4 modellek üzembe helyezésekor a választott üzembe helyezési nevet kell lecserélnie gpt-35-turbo . A modell nevének megadása hibaüzenetet eredményez, kivéve, ha az alapul szolgáló modell nevével azonos központi telepítési nevet választott.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo/chat/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{"messages":[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},{"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},{"role": "user", "content": "Do other Azure AI services support this too?"}]}'

A parancs első sorának formátuma egy példavégponttal a következőképpen curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/chat/completions?api-version=2024-02-01 \ jelenik meg, ha kettős hibaellenőrzést tapasztal, hogy ne legyen megkettőzve a / végpont és /openai/deploymentsa végpont elválasztásakor.

Ha ezt a parancsot egy normál Windows-parancssorban szeretné futtatni, módosítania kell a szöveget a sortörések és a \ sorok eltávolításához.

Hozam

{"id":"chatcmpl-6v7mkQj980V1yBec6ETrKPRqFjNw9",
"object":"chat.completion","created":1679072642,
"model":"gpt-35-turbo",
"usage":{"prompt_tokens":58,
"completion_tokens":68,
"total_tokens":126},
"choices":[{"message":{"role":"assistant",
"content":"Yes, other Azure AI services also support customer managed keys. Azure AI services offer multiple options for customers to manage keys, such as using Azure Key Vault, customer-managed keys in Azure Key Vault or customer-managed keys through Azure Storage service. This helps customers ensure that their data is secure and access to their services is controlled."},"finish_reason":"stop","index":0}]}

A kimeneti formázás az olvasás megkönnyítése érdekében van beállítva, a tényleges kimenet egy sortörés nélküli szövegblokk.

Az üzenetstruktúra ismertetése

A GPT-35-Turbo és a GPT-4 modellek úgy vannak optimalizálva, hogy beszélgetésként formázott bemenetekkel működjenek. A messages változó különböző szerepkörökkel rendelkező szótártömböt ad át a rendszer, a felhasználó és az asszisztens által meghatározott beszélgetésben. A rendszerüzenet a modell beállításához használható a környezet vagy a modell válaszára vonatkozó utasítások megadásával.

A GPT-35-Turbo &GPT-4 útmutató részletes bevezetést nyújt az új modellekkel való kommunikáció lehetőségeibe.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure CLI

Következő lépések

• Útmutatónkból többet is megtudhat a GPT-35-Turbo és a GPT-4 modellek használatáról.
• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát

Előfeltételek

• Azure-előfizetés – Ingyenes létrehozás
• Hozzáférés az Azure OpenAI szolgáltatáshoz a kívánt Azure-előfizetésben. Ezen szolgáltatáshoz jelenleg csak alkalmazás útján kapható hozzáférés. Az Azure OpenAI szolgáltatáshoz való hozzáférésre az űrlap kitöltésével jelentkezhet a következő címen https://aka.ms/oai/access: .
• Használhatja a legújabb verziót, a PowerShell 7-et vagy a Windows PowerShell 5.1-et.
• Azure OpenAI-szolgáltatáserőforrás üzembe helyezett modellel. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.
• Egy Azure OpenAI-szolgáltatás erőforrása, amely az üzembe helyezett modelleket vagy gpt-4 azokat gpt-35-turbo tartalmazza. A modellek üzembe helyezéséről a modellek üzembe helyezésének ismertetőjében talál további információt.

Kulcs és végpont lekérése

Az Azure OpenAI-ra való sikeres híváshoz egy végpontra és egy kulcsra lesz szüksége.

Nyissa meg az erőforrást az Azure Portalon. A végpont és a kulcsok az Erőforrás-kezelés szakaszban találhatók. Másolja ki a végpontot és a hozzáférési kulcsot, mivel mindkettőre szüksége lesz az API-hívások hitelesítéséhez. A következők bármelyikét használhatja: KEY1 vagy KEY2. A két kulcs mindig lehetővé teszi a kulcsok biztonságos elforgatását és újragenerálását anélkül, hogy szolgáltatáskimaradást okoz.

Állandó környezeti változók létrehozása és hozzárendelése a kulcshoz és a végponthoz.

Környezeti változók

$Env:AZURE_OPENAI_API_KEY = 'YOUR_KEY_VALUE'
$Env:AZURE_OPENAI_ENDPOINT = 'YOUR_ENDPOINT'

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

echo export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment
echo export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Új PowerShell-szkript létrehozása

1. Hozzon létre egy új, quickstart.ps1 nevű PowerShell-fájlt. Ezután nyissa meg a kívánt szerkesztőben vagy IDE-ben.

2. Cserélje le a quickstart.ps1 tartalmát a következő kódra. A változót a engine GPT-35-Turbo vagy a GPT-4 modellek üzembe helyezésekor választott üzembe helyezési névre kell állítania. A modell nevének megadása hibaüzenetet eredményez, kivéve, ha az alapul szolgáló modell nevével azonos központi telepítési nevet választott.

   # Azure OpenAI metadata variables
   $openai = @{
      api_key     = $Env:AZURE_OPENAI_API_KEY
      api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
      api_version = '2024-02-01' # this may change in the future
      name        = 'YOUR-DEPLOYMENT-NAME-HERE' #This will correspond to the custom name you chose for your deployment when you deployed a model.
   }
   
   # Completion text
   $messages = @()
   $messages += @{
     role = 'system'
     content = 'You are a helpful assistant.'
   }
   $messages += @{
     role = 'user'
     content = 'Does Azure OpenAI support customer managed keys?'
   }
   $messages += @{
     role = 'assistant'
     content = 'Yes, customer managed keys are supported by Azure OpenAI.'
   }
   $messages += @{
     role = 'user'
     content = 'Do other Azure AI services support this too?'
   }
   
   # Header for authentication
   $headers = [ordered]@{
      'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
      messages = $messages
   } | ConvertTo-Json
   
   # Send a request to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/chat/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return $response
   

   Fontos

   Éles környezetben használja a hitelesítő adatok biztonságos tárolásának és elérésének biztonságos módját, például a PowerShell titkos kulcskezelését az Azure Key Vaulttal. A hitelesítő adatok biztonságával kapcsolatos további információkért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

3. Futtassa a szkriptet a PowerShell használatával:

   ./quickstart.ps1
   

Hozam

# the output of the script will be a .NET object containing the response
id      : chatcmpl-7sdJJRC6fDNGnfHMdfHXvPkYFbaVc
object  : chat.completion
created : 1693255177
model   : gpt-35-turbo
choices : {@{index=0; finish_reason=stop; message=}}
usage   : @{completion_tokens=67; prompt_tokens=55; total_tokens=122}

# convert the output to JSON
./quickstart.ps1 | ConvertTo-Json -Depth 3

# or to view the text returned, select the specific object property
$reponse = ./quickstart.ps1
$response.choices.message.content

Az üzenetstruktúra ismertetése

A GPT-35-Turbo és a GPT-4 modellek úgy vannak optimalizálva, hogy beszélgetésként formázott bemenetekkel működjenek. A messages változó különböző szerepkörökkel rendelkező szótártömböt ad át a rendszer, a felhasználó és az asszisztens által meghatározott beszélgetésben. A rendszerüzenet a modell beállításához használható a környezet vagy a modell válaszára vonatkozó utasítások megadásával.

A GPT-35-Turbo &GPT-4 útmutató részletes bevezetést nyújt az új modellekkel való kommunikáció lehetőségeibe.

Az erőforrások eltávolítása

Ha törölni és eltávolítani szeretne egy Azure OpenAI-erőforrást, törölheti az erőforrást. Az erőforrás törlése előtt törölnie kell az üzembe helyezett modelleket.

• Portál
• Azure PowerShell

Következő lépések

• Útmutatónkból többet is megtudhat a GPT-35-Turbo és a GPT-4 modellek használatáról.
• További példákért tekintse meg az Azure OpenAI-minták GitHub-adattárát