Guida introduttiva: Introduzione alla generazione di testo con le API di completamento legacy

Prerequisiti

• Una sottoscrizione di Azure: crearne una gratuitamente.
• Una risorsa OpenAI di Azure con un modello distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Passare a OpenAI Studio di Azure

Passare a studio del Servizio OpenAI di Azure all’indirizzo https://oai.azure.com/ e accedere con le credenziali che dispongono dell’accesso alla risorsa OpenAI di Azure. Durante o dopo il flusso di lavoro di accesso, selezionare la directory appropriata, la sottoscrizione di Azure e la risorsa OpenAI di Azure.

Dalla pagina di destinazione di Azure OpenAI Studio, esplorare altri esempi per il completamento della richiesta, gestire le distribuzioni e i modelli e trovare risorse di apprendimento (ad esempio, la documentazione e i forum della community).

Playground

Iniziare a esplorare le funzionalità di Azure OpenAI con un approccio senza codice tramite il Playground GPT-3. Si tratta semplicemente di una casella di testo in cui è possibile inviare una richiesta di generazione di un completamento. Da questa pagina è possibile eseguire rapidamente l'iterazione e sperimentare con le funzionalità.

Per iniziare, è possibile selezionare una distribuzione e scegliere tra alcuni esempi precaricati. Se la risorsa non ha una distribuzione, selezionare Crea una distribuzione e seguire le istruzioni fornite dalla procedura guidata. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

È possibile sperimentare con le impostazioni di configurazione, ad esempio la temperatura e il testo della prerisposta, per migliorare le prestazioni dell'attività. Per altre informazioni su ogni parametro, vedere l'API REST.

• Se si seleziona il pulsante Genera, il testo immesso verrà inviato all'API di completamenti e i risultati verranno trasmessi nuovamente alla casella di testo.
• Selezionare il pulsante Annulla per annullare la chiamata di generazione precedente.
• Selezionare il pulsante Rigenera per completare insieme una chiamata di annullamento e di generazione.

OpenAI di Azure esegue anche la moderazione del contenuto sugli input delle richieste e sugli output generati. Le richieste o le risposte possono essere filtrate se dovesse essere rilevato contenuto dannoso. Per ulteriori informazioni, vedere l'articolo sul filtraggio del contenuto.

Nel Playground completamenti, è anche possibile visualizzare esempi di codice Python e Curl precompilati in base alle impostazioni selezionate. È sufficiente selezionare Visualizza codice accanto all'elenco a discesa degli esempi. È possibile scrivere un'applicazione per effettuare la stessa attività con OpenAI Python SDK, Curl o un altro client API REST.

Provare il riassunto del testo

Per usare Azure OpenAI per il riassunto del testo in Playground completamenti, seguire questa procedura:

1. Accedere ad Azure OpenAI Studio.

2. Selezionare la sottoscrizione e la risorsa OpenAI da usare.

3. Selezionare Playground completamenti nella pagina di destinazione.

4. Selezionare la distribuzione dall'elenco a discesa Distribuzioni. Se la risorsa non ha una distribuzione, selezionare Crea una distribuzione e quindi tornare a questo passaggio.

5. Immettere una richiesta per il modello.

   

6. Selezionare Generate. Azure OpenAI tenterà di acquisire il contesto del testo e riformularlo in modo conciso. Dovrebbe essere visualizzato un risultato simile al testo seguente:

L'accuratezza della risposta può variare in base al modello. Il modello basato su gpt-35-turbo-instruct in questo esempio è adatto a questo tipo di riepilogo, anche se in generale è consigliabile usare l'API di completamento della chat alternativa, a meno che non si abbia un caso d'uso specifico particolarmente adatto all'API di completamento.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Ulteriori informazioni su come generare il completamento migliore nella Guida pratica sui completamenti.
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Codice sorgente | Pacchetto (NuGet) | Esempi

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Versione corrente di .NET Core
• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo-instruct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Creare una nuova applicazione .NET Core

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome azure-openai-quickstart. Questo comando crea un semplice progetto "Hello World" con un singolo file di origine C#: program.cs.

dotnet new console -n azure-openai-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

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

Installare la libreria client .NET OpenAI con:

dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.17

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare un’applicazione di esempio

Dalla directory del progetto, aprire il file program.cs e sostituirlo con il codice seguente:

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

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

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

CompletionsOptions completionsOptions = new()
{
    DeploymentName = "gpt-35-turbo-instruct",
    Prompts = { "When was Microsoft founded?" },
};

Response<Completions> completionsResponse = client.GetCompletions(completionsOptions);
string completion = completionsResponse.Value.Choices[0].Text;
Console.WriteLine($"Chatbot: {completion}");

dotnet run program.cs

Output

Chatbot:

Microsoft was founded on April 4, 1975.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente | Pacchetto (Go)| Esempi

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Passare alla versione 1.21.0 o successiva installata in locale.
• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo-instuct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare un’applicazione di esempio

Creare un nuovo file denominato completions.go. Copiare il codice seguente nel file completions.go.

package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")
	modelDeploymentID := "gpt-35-turbo-instruct"

	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

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

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

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

	if err != nil {
		// TODO: handle error
	}

	resp, err := client.GetCompletions(context.TODO(), azopenai.CompletionsOptions{
		Prompt:         []string{"What is Azure OpenAI, in 20 words or less"},
		MaxTokens:      to.Ptr(int32(2048)),
		Temperature:    to.Ptr(float32(0.0)),
		DeploymentName: &modelDeploymentID,
	}, nil)

	if err != nil {
		// TODO: handle error
	}

	for _, choice := range resp.Choices {
		fmt.Fprintf(os.Stderr, "Result: %s\n", *choice.Text)
	}

}

Aprire un prompt dei comandi ed eseguire:

go mod init completions.go

Prossima esecuzione:

go mod tidy

go run completions.go

Output

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente | Artefatto (Maven) | Esempi

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente

• La versione più recente di Java Development Kit (JDK)
• Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.

• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo-instruct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Java

Creare un nuovo progetto Gradle.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Installare Java SDK

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare la configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe OpenAIQuickstart. Importa la libreria di Visione artificiale di Azure.

plugins {
    java
    application
}
application { 
    mainClass.set("GetCompletionsSample")
}
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")
}

Creare un’applicazione di esempio

1. Creare un file Java

   Dalla directory di lavoro eseguire il comando seguente per creare una cartella di origine del progetto:

   mkdir -p src/main/java
   

   Passare alla nuova cartella e creare un file denominato GetCompletionsSample.java.

2. Aprire GetCompletionsSample.java nell'editor o nell'IDE preferito e incollare il codice seguente.

   package com.azure.ai.openai.usage;
   
   import com.azure.ai.openai.OpenAIClient;
   import com.azure.ai.openai.OpenAIClientBuilder;
   import com.azure.ai.openai.models.Choice;
   import com.azure.ai.openai.models.Completions;
   import com.azure.ai.openai.models.CompletionsOptions;
   import com.azure.ai.openai.models.CompletionsUsage;
   import com.azure.core.credential.AzureKeyCredential;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GetCompletionsSample {
   
       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-instruct";
   
           OpenAIClient client = new OpenAIClientBuilder()
               .endpoint(endpoint)
               .credential(new AzureKeyCredential(azureOpenaiKey))
               .buildClient();
   
           List<String> prompt = new ArrayList<>();
           prompt.add("When was Microsoft founded?");
   
           Completions completions = client.getCompletions(deploymentOrModelId, new CompletionsOptions(prompt));
   
           System.out.printf("Model ID=%s is created at %s.%n", completions.getId(), completions.getCreatedAt());
           for (Choice choice : completions.getChoices()) {
               System.out.printf("Index: %d, Text: %s.%n", choice.getIndex(), choice.getText());
           }
   
           CompletionsUsage usage = completions.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());
       }
   }
   

   Importante

   Per la produzione, usare un metodo sicuro per l'archiviazione e l'accesso alle proprie credenziali, ad esempio Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sulla sicurezza dei servizi di Azure AI.

3. Tornare alla cartella radice del progetto e compilare l'app con:

   gradle build
   

   Eseguirlo quindi con il comando gradle run:

   gradle run
   

Output

Model ID=cmpl-7JZRbWuEuHX8ozzG3BXC2v37q90mL is created at 1684898835.
Index: 0, Text:

Microsoft was founded on April 4, 1975..
Usage: number of prompt token is 5, number of completion token is 11, and number of total tokens in request and response is 16.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente | Artefatti (Maven) | Esempio

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• La versione più recente di Java Development Kit (JDK)
• Strumento dell'interfaccia della riga di comando di Spring Boot
• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Spring

Creare un nuovo progetto Spring.

In una finestra Bash creare una nuova directory per l'app e passare a essa.

mkdir ai-completion-demo && cd ai-completion-demo

Eseguire il comando spring init dalla directory di lavoro. Questo comando crea una struttura di directory standard per il progetto Spring, incluso il file di origine della classe Java principale e il file pom.xml usato per la gestione dei progetti basati su Maven.

spring init -a ai-completion-demo -n AICompletion --force --build maven -x

I file e le cartelle generati sono simili alla struttura seguente:

ai-completion-demo/
|-- pom.xml
|-- mvn
|-- mvn.cmd
|-- HELP.md
|-- src/
    |-- main/
    |   |-- resources/
    |   |   |-- application.properties
    |   |-- java/
    |       |-- com/
    |           |-- example/
    |               |-- aicompletiondemo/
    |                   |-- AiCompletionApplication.java
    |-- test/
        |-- java/
            |-- com/
                |-- example/
                    |-- aicompletiondemo/
                        |-- AiCompletionApplicationTests.java

Modificare l'applicazione Spring

1. Modificare il file pom.xml.

   Dalla radice della directory del progetto aprire il file pom.xml nell'editor o nell'IDE preferito e sovrascrivere il file con il contenuto seguente:

   <?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-completion-demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>AICompletion</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. Dalla cartella src/main/java/com/example/aicompletiondemo aprire AiCompletionApplication.java nell'editor o nell'IDE preferito e incollare il codice seguente:

   package com.example.aicompletiondemo;
   
   import java.util.Collections;
   import java.util.List;
   
   import org.springframework.ai.client.AiClient;
   import org.springframework.ai.prompt.Prompt;
   import org.springframework.ai.prompt.messages.Message;
   import org.springframework.ai.prompt.messages.MessageType;
   import org.springframework.ai.prompt.messages.UserMessage;
   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 AiCompletionApplication implements CommandLineRunner
   {
       private static final String ROLE_INFO_KEY = "role";
   
       @Autowired
       private AiClient aiClient;
   
       public static void main(String[] args) {
           SpringApplication.run(AiCompletionApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception
       {
           System.out.println(String.format("Sending completion prompt to AI service. One moment please...\r\n"));
   
           final List<Message> msgs =
                   Collections.singletonList(new UserMessage("When was Microsoft founded?"));
   
           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()));
             });
       }
   
   }
   

   Importante

   Per la produzione, usare un metodo sicuro per l'archiviazione e l'accesso alle proprie credenziali, ad esempio Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sulla sicurezza dei servizi di Azure AI.

3. Tornare alla cartella radice del progetto ed eseguire l'app usando il comando seguente:

   ./mvnw spring-boot:run
   

Output

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

2023-11-07T12:47:46.126-06:00  INFO 98687 --- [           main] c.e.a.AiCompletionApplication            : No active profile set, falling back to 1 default profile: "default"
2023-11-07T12:47:46.823-06:00  INFO 98687 --- [           main] c.e.a.AiCompletionApplication            : Started AiCompletionApplication in 0.925 seconds (process running for 1.238)
Sending completion prompt to AI service. One moment please...

Prompt created 1 generated response(s).
Generated respose from "assistant": Microsoft was founded on April 4, 1975.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente | Pacchetto (npm) | Esempi

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Versioni LTS di Node.js
• Interfaccia della riga di comando di Azure usata per l'autenticazione senza password in un ambiente di sviluppo locale, creare il contesto necessario eseguendo l'accesso tramite l'interfaccia della riga di comando di Azure.
• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo-instruct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

Installare la libreria client

Installare i pacchetti necessari per JavaScript con npm dal contesto della nuova directory:

npm install openai @azure/identity

Il file package.json dell'app verrà aggiornato con le dipendenze.

Creare un’applicazione di esempio

Aprire un prompt dei comandi nella posizione in cui è stato creato il nuovo progetto e creare un nuovo file denominato Completion.js. Copiare il codice seguente nel file Completion.js.

const { AzureOpenAI } = require("openai");
const { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiVersion = "2024-04-01-preview";
const deployment = "gpt-35-turbo-instruct"; //The deployment name for your completions API model. The instruct model is the only new model that supports the legacy API.

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

const prompt = ["When was Microsoft founded?"];

async function main() {
  console.log("== Get completions Sample ==");

  const client = new AzureOpenAI({ endpoint, azureADTokenProvider, apiVersion, deployment });  

  const result = await client.completions.create({ prompt, model: deployment, max_tokens: 128 });

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

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

node.exe Completion.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";
const apiVersion = "2024-04-01-preview";
const deployment = "gpt-35-turbo-instruct"; //The deployment name for your completions API model. The instruct model is the only new model that supports the legacy API.

const prompt = ["When was Microsoft founded?"];

async function main() {
  console.log("== Get completions Sample ==");

  const client = new AzureOpenAI({ endpoint, apiKey, apiVersion, deployment });  

  const result = await client.completions.create({ prompt, model: deployment, max_tokens: 128 });

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

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

node.exe Completion.js

Output

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Panoramica di Azure OpenAI
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente | Pacchetto (npm) | Esempi

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Versioni LTS di Node.js
• TypeScript
• Interfaccia della riga di comando di Azure usata per l'autenticazione senza password in un ambiente di sviluppo locale, creare il contesto necessario eseguendo l'accesso tramite l'interfaccia della riga di comando di Azure.
• Una risorsa del servizio OpenAI di Azure con il modello gpt-35-turbo-instruct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

Installare la libreria client

Installare i pacchetti necessari per JavaScript con npm dal contesto della nuova directory:

npm install openai @azure/identity

Il file package.json dell'app verrà aggiornato con le dipendenze.

Creare un’applicazione di esempio

Aprire un prompt dei comandi in cui è stato creato il nuovo progetto e creare un nuovo file denominato Completion.ts. Copiare il codice seguente nel file Completion.ts.

import { 
  DefaultAzureCredential, 
  getBearerTokenProvider 
} from "@azure/identity";
import { AzureOpenAI } from "openai";
import { type Completion } from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-35-turbo-instruct";

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

// Chat prompt and max tokens
const prompt = ["When was Microsoft founded?"];
const maxTokens = 128;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function getCompletion(
  client: AzureOpenAI,
  prompt: string[],
  max_tokens: number
): Promise<Completion> {
  return client.completions.create({
    prompt,
    model: "",
    max_tokens,
  });
}
async function printChoices(completion: Completion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.text);
  }
}
export async function main() {
  console.log("== Get completions Sample ==");

  const client = getClient();
  const completion = await getCompletion(client, prompt, maxTokens);
  await printChoices(completion);
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

tsc

node.exe Completion.js

import { AzureOpenAI } from "openai";
import { type Completion } from "openai/resources/index";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"] || "<endpoint>";
const apiKey = process.env["AZURE_OPENAI_API_KEY"] || "<api key>";

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-08-01-preview";
const deploymentName = "gpt-35-turbo-instruct";

// Chat prompt and max tokens
const prompt = ["When was Microsoft founded?"];
const maxTokens = 128;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function getCompletion(
  client: AzureOpenAI,
  prompt: string[],
  max_tokens: number
): Promise<Completion> {
  return client.completions.create({
    prompt,
    model: "",
    max_tokens,
  });
}
async function printChoices(completion: Completion): Promise<void> {
  for (const choice of completion.choices) {
    console.log(choice.text);
  }
}
export async function main() {
  console.log("== Get completions Sample ==");

  const client = getClient();
  const completion = await getCompletion(client, prompt, maxTokens);
  await printChoices(completion);
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

tsc

node.exe Completion.js

Output

== Get completions Sample ==

Microsoft was founded on April 4, 1975.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Panoramica di Azure OpenAI
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Codice sorgente della libreria | Pacchetto (PyPi) |

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Python 3.8 o versioni successive
• Le librerie Python seguenti: os, requests, json
• Una risorsa del servizio OpenAI di Azure con un modello gpt-35-turbo-instruct distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Installare la libreria client Python OpenAI con:

pip install openai

pip install openai==0.28.1

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata al servizio Azure OpenAI, sarà necessario quanto segue:

Passare alla risorsa nel portale di Azure. Le chiavi e gli endpoint sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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"

Creare una nuova applicazione Python

1. Creare un nuovo file Python denominato quickstart.py. Quindi, aprirlo nell'editor o nell'IDE preferito.

2. Sostituire il contenuto di quickstart.py con il codice seguente. Modificare il codice in modo da aggiungervi la chiave, l'endpoint e il nome della distribuzione:

import os
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-02-01",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )
    
deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. Use a gpt-35-turbo-instruct deployment. 
    
# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = client.completions.create(model=deployment_name, prompt=start_phrase, max_tokens=10)
print(start_phrase+response.choices[0].text)

import os
import openai

openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
openai.api_type = 'azure'
openai.api_version = '2024-02-01' # this might change in the future

deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 

# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = openai.Completion.create(engine=deployment_name, prompt=start_phrase, max_tokens=10)
text = response['choices'][0]['text'].replace('\n', '').replace(' .', '.').strip()
print(start_phrase+text)

1. Eseguire l'applicazione con il comando python nel file di avvio rapido.

   python quickstart.py
   

Output

L'output includerà il testo della risposta che segue il prompt Write a tagline for an ice cream shop.. In questo esempio, Azure OpenAI ha restituito The coldest ice cream in town!.

Sending a test completion job
Write a tagline for an ice cream shop. The coldest ice cream in town!

Eseguire il codice più volte per vedere quali altri tipi di risposte si ottengono, poiché la risposta non sarà sempre la stessa.

Informazioni sui risultati

Poiché l'esempio di Write a tagline for an ice cream shop. fornisce poco contesto, è normale che il modello non restituisca sempre i risultati previsti. Se la risposta sembra imprevista o troncata, è possibile modificare il numero massimo di token.

OpenAI di Azure esegue anche la moderazione del contenuto sugli input delle richieste e sugli output generati. Le richieste o le risposte possono essere filtrate se viene rilevato contenuto dannoso. Per ulteriori informazioni, vedere l'articolo sul filtraggio del contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Ulteriori informazioni su come generare il completamento migliore nella Guida pratica sui completamenti.
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• Python 3.8 o versioni successive
• Le librerie Python seguenti: os, requests, json
• Una risorsa OpenAI di Azure con un modello distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Impostazione

Recuperare la chiave e l'endpoint

Per eseguire correttamente una chiamata a OpenAI di Azure, è necessario quanto segue:

Passare alla risorsa nel portale di Azure. Endpoint e Chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

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

Nella shell BASH eseguire il comando seguente. Sarà necessario sostituire gpt-35-turbo-instruct con il nome di distribuzione scelto durante la distribuzione del modello gpt-35-turbo-instruct. Se si immette il nome del modello, verrà generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante.

curl $AZURE_OPENAI_ENDPOINT/openai/deployments/gpt-35-turbo-instruct/completions?api-version=2024-02-01 \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d "{\"prompt\": \"Once upon a time\"}"

Il formato della prima riga del comando con un endpoint di esempio viene visualizzato come indicato di seguito curl https://docs-test-001.openai.azure.com/openai/deployments/{YOUR-DEPLOYMENT_NAME_HERE}/completions?api-version=2024-02-01 \. Se si verifica un errore, verificare che non sia presente un raddoppio del / alla separazione tra l'endpoint e /openai/deployments.

Se si desidera eseguire questo comando in un normale prompt dei comandi di Windows, è necessario modificare il testo per rimuovere le interruzioni di riga e \.

Output

L'output dell'API dei completamenti sarà simile al seguente.

{
    "id": "ID of your call",
    "object": "text_completion",
    "created": 1675444965,
    "model": "gpt-35-turbo-instruct",
    "choices": [
        {
            "text": " there lived in a little village a woman who was known as the meanest",
            "index": 0,
            "finish_reason": "length",
            "logprobs": null
        }
    ],
    "usage": {
        "completion_tokens": 16,
        "prompt_tokens": 3,
        "total_tokens": 19
    }
}

Il servizio Azure OpenAI esegue anche la moderazione del contenuto sugli input delle richieste e sugli output generati. Le richieste o le risposte possono essere filtrate se dovesse essere rilevato contenuto dannoso. Per ulteriori informazioni, vedere l'articolo sul filtraggio del contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Azure portal
• Interfaccia della riga di comando di Azure

Passaggi successivi

• Ulteriori informazioni su come generare il completamento migliore nella Guida pratica sui completamenti.
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Prerequisiti

• Una sottoscrizione di Azure: creare un account gratuitamente
• È possibile usare la versione più recente, PowerShell 7 o Windows PowerShell 5.1.
• Una risorsa del servizio OpenAI di Azure con un modello distribuito. Per ulteriori informazioni sulla distribuzione del modello, vedere la guida alla distribuzione delle risorse.

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata al servizio Azure OpenAI, sarà necessario quanto segue:

Passare alla risorsa nel portale di Azure. Endpoint e Chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

$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

Creare un nuovo script di PowerShell

1. Creare un nuovo file di PowerShell denominato quickstart.ps1. Quindi, aprirlo nell'editor o nell'IDE preferito.

2. Sostituire il contenuto di quickstart.ps1 con il codice seguente. Modificare il codice in modo da aggiungervi la chiave, l'endpoint e il nome della distribuzione:

   # 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
   $prompt = 'Once upon a time...'
   
   # Header for authentication
   $headers = [ordered]@{
       'api-key' = $openai.api_key
   }
   
   # Adjust these values to fine-tune completions
   $body = [ordered]@{
       prompt      = $prompt
       max_tokens  = 10
       temperature = 2
       top_p       = 0.5
   } | ConvertTo-Json
   
   # Send a completion call to generate an answer
   $url = "$($openai.api_base)/openai/deployments/$($openai.name)/completions?api-version=$($openai.api_version)"
   
   $response = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json'
   return "$prompt`n$($response.choices[0].text)"
   

   Importante

   Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio La gestione dei segreti di PowerShell con Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sulla sicurezza dei servizi di Azure AI.

3. Eseguire lo script con PowerShell:

   ./quickstart.ps1
   

Output

L'output includerà il testo della risposta che segue il prompt Once upon a time. In questo esempio, Azure OpenAI ha restituito There was a world beyond the mist...where a.

Once upon a time...
 There was a world beyond the mist...where a

Eseguire il codice più volte per vedere quali altri tipi di risposte si ottengono, poiché la risposta non sarà sempre la stessa.

Informazioni sui risultati

Poiché l'esempio di Once upon a time... fornisce poco contesto, è normale che il modello non restituisca sempre i risultati previsti. Se la risposta sembra imprevista o troncata, è possibile modificare il numero massimo di token.

OpenAI di Azure esegue anche la moderazione del contenuto sugli input delle richieste e sugli output generati. Le richieste o le risposte possono essere filtrate se dovesse essere rilevato contenuto dannoso. Per ulteriori informazioni, vedere l'articolo sul filtraggio del contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

• Azure portal
• Azure PowerShell

Passaggi successivi

• Ulteriori informazioni su come generare il completamento migliore nella Guida pratica sui completamenti.
• Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.