Ejercicio - Instale el SDK de .NET para Azure OpenAI y cree su primera aplicación

10 minutos

Ahora que tenemos un conocimiento de las finalizaciones de texto y chat, vamos a crear una aplicación básica que las use.

Digamos que trabaja para una organización que recomienda senderos a excursionistas para explorar la naturaleza. Está considerando agregar una inteligencia artificial conversacional a la funcionalidad de recomendación y tiene el deseo de crear un prototipo.

Decide que debe usar la API de finalización de chat proporcionada por el modelo GPT-35-Turbo.

Creación de un recurso de Azure OpenAI

El primer paso es crear el recurso de Azure OpenAI e implementar el modelo. Vamos a usar el modelo GPT-3 Turbo en este ejercicio. Como se indica en la documentación, GPT-3.5 Turbo usa la API de finalizaciones de chat y es ideal para nuestro caso de uso.

Requisitos previos

Una suscripción de Azure
Acceso concedido a Azure OpenAI en la suscripción que quiera

Actualmente, solo puede obtener acceso a este servicio por aplicación. Para solicitar acceso a Azure OpenAI, rellene el formulario en https://aka.ms/oai/access.
CLI de Azure instalada

Creación de un recurso e implementación del modelo

La creación del recurso e implementación del modelo es un proceso de varios pasos. Recomendamos usar la CLI de Azure, ya que es más rápida que Azure Portal. Pero tenga en cuenta que puede usar el Azure Portal si lo desea.

Ejecute el comando az login para iniciar sesión si aún no lo ha hecho.
Al crear un nuevo recurso de Azure, puede elegir entre crear un grupo de recursos o usar uno existente. Este comando muestra cómo crear un nuevo grupo de recursos. Use el nombre HikingConversations-RG, sustituya el nombre de su elección o use el nombre de un grupo existente.
```
az group create \
--name HikingConversations-RG \
--location eastus
```
```
az group create `
--name HikingConversations-RG `
--location eastus
```

Ejecute el siguiente comando para crear un recurso OpenAI en el grupo de recursos HikingConversations-RG. Asigne al recurso de OpenAI el nombre HikingConversationsAI.

az cognitiveservices account create \
-n HikingConversationsAI \
-g HikingConversations-RG \
-l eastus \
--kind OpenAI \
--sku s0

az cognitiveservices account create `
-n HikingConversationsAI `
-g HikingConversations-RG `
-l eastus `
--kind OpenAI `
--sku s0

A continuación, queremos implementar el modelo GPT-35-Turbo en el recurso de OpenAI que hemos creado. Llame HikingRecommendationTurbo a la implementación del modelo. Tenga en cuenta que estamos usando HikingConversations-RG como nombre del grupo de recursos y HikingConversationsAI como nombre del recurso de OpenAI. Si ha usado valores diferentes, asegúrese de sustituir esos valores.

az cognitiveservices account deployment create \
-g HikingConversations-RG \
-n HikingConversationsAI \
--deployment-name HikingRecommendationTurbo \
--model-name gpt-35-turbo \
--model-version "0125" \
--model-format OpenAI \
--sku-capacity 1
--sku-name "Standard"

az cognitiveservices account deployment create `
-g HikingConversations-RG `
-n HikingConversationsAI `
--deployment-name HikingRecommendationTurbo `
--model-name gpt-35-turbo `
--model-version "0125"
--model-format OpenAI `
--sku-capacity 1
--sku-name "Standard"

Una vez creado el recurso y el modelo, es necesario obtener la dirección URL base y las claves de acceso para que el SDK de .NET pueda acceder al recurso de Azure OpenAI. Use estos comandos para obtener el punto de conexión y las claves de API principales y tome nota de ellos para su uso posterior:

El punto de conexión

az cognitiveservices account show \
-g HikingConversations-RG \
-n HikingConversationsAI \
--query "properties.endpoint"

az cognitiveservices account show `
-g HikingConversations-RG `
-n HikingConversationsAI `
--query "properties.endpoint"

Clave de API principal

az cognitiveservices account keys list \
-g HikingConversations-RG \
-n HikingConversationsAI \
--query "key1"

az cognitiveservices account keys list `
-g HikingConversations-RG `
-n HikingConversationsAI `
--query "key1"

Crear aplicación de consola y agregar el SDK de OpenAI

A continuación, queremos crear una aplicación de consola de .NET básica y agregar el SDK de Azure OpenAI.

Ejecute lo siguiente para crear una nueva aplicación de .NET llamada HikingConversationsAI.
```
dotnet new console -n HikingConversationsAI
```
Cambie al directorio HikingConversationsAI que se acaba de crear.
```
cd HikingConversationsAI
```

A continuación, agregue el SDK de Azure OpenAI.

dotnet add package Azure.AI.OpenAI --prerelease

Abra el proyecto en VS Code o Visual Studio.
En el archivo Program.cs, elimine todo el código existente.
Agregue using Azure.AI.OpenAI; a la parte superior del archivo Program.cs.
Agregue using Azure; a la parte superior del archivo Program.cs.
Agregue tres variables de nivel de clase que contengan referencias al punto de conexión del recurso de Azure OpenAI, la clave de API principal y el nombre del modelo que implementó.
```
string openAIEndpoint = "<YOUR ENDPOINT URL VALUE>";
string openAIAPIKey = "<YOUR PRIMARY API KEY VALUE>";
string openAIDeploymentName = "HikingRecommendationTurbo";
```
En los pasos anteriores, denominamos la implementación HikingRecommendationTurbo. Si ha usado un valor diferente, asegúrese de usarlo en su lugar.

Por último, cree una instancia de la clase necesaria para comunicarse con el recurso de Azure OpenAI.

var endpoint = new Uri(openAIEndpoint);
var credentials = new AzureKeyCredential(openAIAPIKey);
var openAIClient = new AzureOpenAIClient(endpoint, credentials);

Crear el aviso del sistema

Vamos a crear el símbolo del sistema inicial que proporcionará las instrucciones iniciales al modelo.

Primero, cree una instrucción que indique al modelo cómo desea que actúe durante la conversación al recomendar rutas de senderismo.

var systemPrompt = 
"""
You are a hiking enthusiast who helps people discover fun hikes. You are upbeat and friendly. 
You ask people what type of hikes they like to take and then suggest some.
""";

A continuación, cree un List<ChatMessage> para contener todos los mensajes que se enviarán a y desde el modelo.
```
List<ChatMessage> chatHistory = new();
```
A continuación, cree un nuevo SystemChatMessage objeto y agréguelo a la chatHistory lista. Estableceremos el ChatMessage que provendrá del rol Sistema.
```
SystemChatMessage systemMessage = ChatMessage.CreateSystemMessage(systemPrompt);

chatHistory.Add(systemMessage);
```

Iniciar la conversación

A continuación, enviaremos el primer mensaje al modelo, iniciando la conversación.

Cree una solicitud para el usuario y agréguela como mensaje de usuario en chatHistory.

string userGreeting = """
Hi there hiking recommendation bot! 
Can't wait to hear what you have in store for me!
""";

UserChatMessage userGreetingMessage = ChatMessage.CreateUserMessage(userGreeting);
chatHistory.Add(userGreetingMessage);

Console.WriteLine($"User >>> {userGreeting}");

Ahora deberá obtener una referencia al ChatClient objeto . Este objeto es responsable de facilitar las conversaciones de chat con el modelo. Por lo tanto, deberá indicar al objeto cliente de Azure OpenAI qué modelo desea usar de los que ha implementado.
```
var chatClient = openAIClient.GetChatClient(openAIDeploymentName);
```
A continuación, llame a la CompleteChatAsyncfunción de laChatClient clase pasando el chatHistory.
```
var response = await chatClient.CompleteChatAsync(chatHistory);
```

Después, lea el valor que ha devuelto el modelo.

Console.WriteLine($"AI >>> {response.Value.Content.Last().Text}");

Veamos lo que tenemos hasta ahora. Para ejecutar la aplicación, escriba dotnet run en el terminal.
Cambie el valor de userGreetingMessage para ver cómo el modelo puede responder de forma diferente.

En una ejecución de ejemplo, vemos lo siguiente:

Hello! Great to hear from you. What type of hikes are you interested in? Do you enjoy easy scenic walks, challenging trails, or something in between? Do you prefer hikes with waterfalls, mountain views, or unique geological formations?

Puede recibir algo diferente, ya que el modelo no es determinista o puede producir una salida diferente incluso con la misma entrada.

Continuar la conversación

Para continuar vamos a responder a la conversación y, a continuación, generar la respuesta.

Asegúrese de conservar el contexto de la conversación. Para ello, agregue la respuesta que se devolvió directamente a la lista chatHistory.
```
var assistantMessage = ChatMessage.CreateAssistantMessage(response.Value.Content.Last().Text);

chatHistory.Add(assistantMessage); 
```

A continuación, cree otro mensaje de usuario y envíelo al modelo.

var hikeRequest = 
"""
I would like a strenuous hike near where I live that ends with
a view that is amazing.
""";

Console.WriteLine($"User >>> {hikeRequest}");

UserChatMessage hikeMessage = ChatMessage.CreateUserMessage(hikeRequest);

chatHistory.Add(hikeMessage);

response = await chatClient.CompleteChatAsync(chatHistory); 

Console.WriteLine($"AI >>> {response.Value.Content.Last().Text}");

Puede experimentar cambiando la variable hikeRequest para solicitar diferentes tipos de excursiones. En un ejemplo de ejecución recibimos lo siguiente:

Great choice! If you're up for a challenge, I recommend checking out the hike to Poo Poo Point in Issaquah, Washington. The hike is 7.2 miles roundtrip, with an elevation gain of 1,858 feet, so it's definitely a workout. But the stunning views of Mount Rainier and the Cascade Mountains make it all worthwhile. Plus, you'll get to see paragliders taking off from Poo Poo Point. It's a popular hike, so I recommend going early to avoid crowds. Let me know if you need more information!

Resumen

Ahora podemos usar el SDK de Azure OpenAI junto con el modelo gpt-35-turbo para crear conversaciones que ayuden a proporcionar recomendaciones de senderismo. A continuación, veamos cómo podemos mejorar las solicitudes que se envían al modelo.

Comentarios

¿Le ha resultado útil esta página?