Introducción al kernel semántico para .NET
En este artículo, explorará los conceptos y las funcionalidades principales del kernel semántico. El kernel semántico es una opción eficaz y recomendada para trabajar con IA en aplicaciones .NET. En las siguientes secciones, obtendrá información sobre:
- Cómo agregar el kernel semántico al proyecto
- Conceptos básicos del kernel semántico
Este artículo sirve como una introducción al kernel semántico específicamente en el contexto de .NET. Para obtener información más completa y aprendizaje sobre kernel semántico, consulte los siguientes recursos:
Agregar el kernel semántico a un proyecto de .NET
El SDK de kernel semántico está disponible como un paquete NuGet para .NET y se integra con configuraciones de aplicaciones estándar.
Instale el paquete Microsoft.SemanticKernel mediante el comando siguiente:
dotnet add package Microsoft.SemanticKernel
Nota:
Aunque Microsoft.SemanticKernel proporciona características principales del kernel semántico, las funcionalidades adicionales requieren que instale paquetes adicionales. Por ejemplo, el paquete Microsoft.SemanticKernel.Plugins.Memory proporciona acceso a características relacionadas con la memoria. Para más información, vea la documentación del kernel semántico.
Cree y configure una instancia de Kernel mediante la clase KernelBuilder para acceder al kernel semántico y trabajar con él. El Kernel contiene servicios, datos y conexiones para organizar integraciones entre el código y los modelos de IA.
Configure el Kernel en una aplicación de consola de .NET:
var builder = Kernel.CreateBuilder();
// Add builder configuration and services
var kernel = builder.Build();
Configure el kernel en una aplicación ASP.NET Core:
var builder = WebApplication.CreateBuilder();
builder.Services.AddKernel();
// Add builder configuration and services
var app = builder.Build();
¿Qué es kernel semántico?
El kernel semántico es un SDK de código abierto que integra y organiza modelos y servicios de inteligencia artificial como OpenAI, Azure OpenAI y Hugging Face con lenguajes de programación convencionales como C#, Python y Java.
El SDK de kernel semántico beneficia a los desarrolladores empresariales de las maneras siguientes:
- Simplifica la integración de las funcionalidades de inteligencia artificial en las aplicaciones existentes para habilitar una solución cohesiva para productos empresariales.
- Minimiza el tiempo de aprendizaje de trabajar con diferentes modelos o servicios de IA, gracias a abstracciones que reducen la complejidad.
- Mejora la confiabilidad al reducir el comportamiento imprevisible de las indicaciones y respuestas de los modelos de IA. Puede ajustar las indicaciones y planear tareas para crear una experiencia de usuario controlada y predecible.
El kernel semántico se basa en varios conceptos básicos:
- Conexiones: interfaz con los servicios y orígenes de datos externos de inteligencia artificial.
- Complementos: encapsula las funciones que pueden usar las aplicaciones.
- Planificador: organiza los planes de ejecución y las estrategias en función del comportamiento del usuario.
- Memoria: abstrae y simplifica la administración de contextos para las aplicaciones de IA.
Estos bloques de creación se exploran en más detalle en las secciones siguientes.
Conexiones
El SDK de kernel semántico incluye un conjunto de conectores que permiten a los desarrolladores integrar LLM y otros servicios en sus aplicaciones existentes. Estos conectores sirven como puente entre el código de aplicación y los modelos o servicios de IA. El kernel semántico controla muchos problemas y desafíos comunes de conexión para que pueda centrarse en la creación de sus propios flujos de trabajo y características.
El siguiente fragmento de código crea un Kernel y agrega una conexión a un modelo de Azure OpenAI:
using Microsoft.SemanticKernel;
// Create kernel
var builder = Kernel.CreateBuilder();
// Add a chat completion service:
builder.Services.AddAzureOpenAIChatCompletion(
"your-resource-name",
"your-endpoint",
"your-resource-key",
"deployment-model");
var kernel = builder.Build();
Complementos
Los complementos de kernel semántico encapsulan funciones de lenguaje estándar para las aplicaciones y los modelos de IA que se van a consumir. Puede crear sus propios complementos o confiar en los complementos proporcionados por el SDK. Estos complementos simplifican las tareas en las que los modelos de inteligencia artificial son ventajosos y se combinan eficazmente con métodos de C# más tradicionales. Las funciones de complemento suelen clasificarse en dos tipos: funciones semánticas y funciones nativas.
Funciones semánticas
Las funciones semánticas son básicamente indicaciones de IA definidas en el código que el kernel semántico puede personalizar y a los que puede llamar según sea necesario. Puede crear plantillas con estas indicaciones para usar variables, indicaciones personalizadas y finalización de formato, etc.
El siguiente fragmento de código define y registra una función semántica:
var userInput = Console.ReadLine();
// Define semantic function inline.
string skPrompt = @"Summarize the provided unstructured text in a sentence that is easy to understand.
Text to summarize: {{$userInput}}";
// Register the function
kernel.CreateSemanticFunction(
promptTemplate: skPrompt,
functionName: "SummarizeText",
pluginName: "SemanticFunctions"
);
Funciones nativas
Las funciones nativas son métodos de C# a los que el kernel semántico puede llamar directamente para manipular o recuperar datos. Realizan operaciones que son más adecuadas para las instrucciones de código tradicionales en lugar de las indicaciones de LLM.
El siguiente fragmento de código define y registra una función nativa:
// Define native function
public class NativeFunctions {
[SKFunction, Description("Retrieve content from local file")]
public async Task<string> RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName);
if (content.Length <= maxSize) return content;
return content.Substring(0, maxSize);
}
}
//Import native function
string plugInName = "NativeFunction";
string functionName = "RetrieveLocalFile";
var nativeFunctions = new NativeFunctions();
kernel.ImportFunctions(nativeFunctions, plugInName);
Planner
El planificador es un componente principal del kernel semántico que proporciona orquestación de inteligencia artificial para administrar la integración sin problemas entre los modelos de IA y los complementos. Esta capa diseña estrategias de ejecución de solicitudes de usuario y organiza dinámicamente complementos para realizar tareas complejas con la planificación asistida por IA.
Vea el siguiente fragmento de pseudocódigo:
// Native function definition and kernel configuration code omitted for brevity
// Configure and create the plan
string planDefinition = "Read content from a local file and summarize the content.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel);
string assetsFolder = @"../../assets";
string fileName = Path.Combine(assetsFolder,"docs","06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName);
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition);
// Execute the plan
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan);
Console.WriteLine($"Summarization: {kernelResult.GetValue<string>()}");
El código anterior crea un plan ejecutable secuencial para leer contenido de un archivo local y resumirlo. El plan configura instrucciones para leer el archivo mediante una función nativa y, a continuación, analizarlo mediante un modelo de IA.
Memoria
Los almacenes de vectores del kernel semántico proporcionan abstracciones sobre modelos de incrustación, bases de datos vectoriales y otros datos para simplificar la gestión del contexto para las aplicaciones de IA. Los almacenes de vectores son independientes de la base de datos LLM o de vectores subyacente, lo que ofrece una experiencia de desarrollador uniforme. Puede configurar características de memoria para almacenar datos en una variedad de orígenes o servicios, incluidos Búsqueda de Azure AI y Azure Cache for Redis.
Tenga en cuenta el fragmento de código siguiente:
var facts = new Dictionary<string,string>();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/en-us/azure/machine-learning/",
@"Azure Machine Learning is a cloud service for accelerating and
managing the machine learning project lifecycle. Machine learning professionals,
data scientists, and engineers can use it in their day-to-day workflows"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/en-us/azure/azure-sql/",
@"Azure SQL is a family of managed, secure, and intelligent products
that use the SQL Server database engine in the Azure cloud."
);
string memoryCollectionName = "SummarizedAzureDocs";
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
collection: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value,
externalId: fact.Key.Split(";")[2].Trim(),
externalSourceName: "Azure Documentation"
);
}
El código anterior carga un conjunto de hechos en memoria para que los datos estén disponibles para usarlos al interactuar con modelos de IA y organizar tareas.
