Vue d’ensemble du noyau sémantique pour .NET
Dans cet article, vous explorez les concepts et fonctionnalités de base du noyau sémantique. Le noyau sémantique est un choix puissant et recommandé pour travailler avec l’IA dans des applications .NET. Dans les sections à venir, vous allez apprendre :
- Comment ajouter un noyau sémantique à votre projet
- Les concepts de base du noyau sémantique
Cet article est une introduction au noyau sémantique dans le contexte de .NET. Pour obtenir des informations plus complètes et des formations sur le noyau sémantique, consultez les ressources suivantes :
Ajouter un noyau sémantique à un projet .NET
Le kit de développement logiciel (SDK) de noyau sémantique est disponible en tant que package NuGet pour .NET et s’intègre aux configurations d’application standards.
Installez le package Microsoft.SemanticKernel à l’aide de la commande suivante :
dotnet add package Microsoft.SemanticKernel
Remarque
Bien que Microsoft.SemanticKernel fournisse des fonctionnalités de base du noyau sémantique, des fonctionnalités supplémentaires nécessitent l’installation de packages supplémentaires. Par exemple, le package Microsoft.SemanticKernel.Plugins.Memory permet d’accéder aux fonctionnalités liées à la mémoire. Pour plus d’informations, consultez la documentation du noyau sémantique.
Créez et configurez une instance Kernel à l’aide de la classe KernelBuilder pour accéder au noyau sémantique et l’utiliser. Le Kernel contient des services, des données et des connexions afin d’orchestrer des intégrations entre votre code et vos modèles d’IA.
Configurer le Kernel dans une application console .NET :
var builder = Kernel.CreateBuilder();
// Add builder configuration and services
var kernel = builder.Build();
Configurer le noyau dans une application ASP.NET Core :
var builder = WebApplication.CreateBuilder();
builder.Services.AddKernel();
// Add builder configuration and services
var app = builder.Build();
Comprendre le noyau sémantique
Le noyau sémantique est un kit de développement logiciel (SDK) open source qui intègre et orchestre des modèles et services d’IA tels qu’OpenAI, Azure OpenAI et Hugging Face avec des langages de programmation classiques tels que C#, Python et Java.
Le kit de développement logiciel (SDK) de noyau sémantique offre aux développeurs d’entreprise les avantages suivants :
- Simplifie l’intégration des fonctionnalités d’IA dans des applications existantes afin d’activer une solution cohérente pour les produits d’entreprise.
- Réduit la courbe d’apprentissage de l’utilisation de différents modèles ou services d’IA en fournissant des résumés qui réduisent la complexité.
- Améliore la fiabilité en réduisant le comportement imprévisible des invites et réponses des modèles d’IA. Vous pouvez affiner les invites et planifier des tâches pour créer une expérience utilisateur contrôlée et prévisible.
Le noyau sémantique est construit autour de plusieurs concepts de base :
- Connexions : se connectent aux services et sources de données d’IA externes.
- Plug-ins : encapsulent des fonctions que les applications peuvent utiliser.
- Planificateur : orchestre les plans d’exécution et les stratégies en fonction du comportement de l’utilisateur.
- Mémoire: résume et simplifie la gestion du contexte des applications d’IA.
Ces éléments constitutifs sont explorés plus en détail dans les sections suivantes.
Connexions
Le kit de développement logiciel (SDK) de noyau sémantique inclut un ensemble de connecteurs qui permettent aux développeurs d’intégrer des LLM et d’autres services dans leurs applications existantes. Ces connecteurs servent de pont entre le code de l’application et les modèles ou services d’IA. Le noyau sémantique gère pour vous de nombreux problèmes et difficultés de connexion courants. Vous pouvez donc vous concentrer sur la création de vos propres flux de travail et fonctionnalités.
L’extrait de code suivant crée un Kernel et ajoute une connexion à un modèle 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();
Plug-ins
Les plug-ins du noyau sémantique encapsulent des fonctions de langage standards à consommer par les applications et modèles d’IA. Vous pouvez créer vos propres plug-ins ou vous appuyer sur des plug-ins fournis par le kit de développement logiciel (SDK). Ces plug-ins simplifient les tâches dans lesquelles les modèles d’IA sont avantageux et les combinent efficacement avec des méthodes C# plus classiques. Les fonctions de plug-in sont généralement classées en deux types : les fonctions sémantiques et les fonctions natives.
Fonctions sémantiques
Les fonctions sémantiques sont essentiellement des invites d’IA définies dans votre code que le noyau sémantique peut personnaliser et appeler si nécessaire. Vous pouvez modéliser ces invites pour utiliser des variables, une invite personnalisée et une mise en forme de saisie automatique, etc.
L’extrait de code suivant définit et inscrit une fonction sémantique :
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"
);
Fonctions natives
Les fonctions natives sont des méthodes C# que le noyau sémantique peut appeler directement pour manipuler ou récupérer des données. Elles effectuent des opérations mieux adaptées aux instructions de code classiques au lieu d’invites LLM.
L’extrait de code suivant définit et inscrit une fonction native :
// 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);
Planificateur
Le planificateur est un composant de base du noyau sémantique qui fournit une orchestration d’IA afin de gérer une intégration transparente entre les modèles d’IA et les plug-ins. Cette couche conçoit des stratégies d’exécution à partir des demandes utilisateur et orchestre dynamiquement les plug-ins pour effectuer des tâches complexes avec une planification assistée par l’IA.
Considérez le pseudo extrait de code suivant :
// 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>()}");
Le code précédent crée un plan séquentiel exécutable pour lire le contenu d’un fichier local et le résumer. Le plan configure des instructions pour lire le fichier à l’aide d’une fonction native, puis l’analyser à l’aide d’un modèle d’IA.
Mémoire
Les magasins de vecteurs de Semantic Kernel fournissent des abstractions sur les modèles d'intégration, les bases de données vectorielles et d'autres données afin de simplifier la gestion du contexte pour les applications d'IA. Les magasins de vecteurs ne dépendent pas de la base de données LLM ou Vector sous-jacente, ce qui permet aux développeurs de bénéficier d'une expérience uniforme. Vous pouvez configurer les fonctionnalités de mémoire pour stocker des données dans une variété de sources ou de service, notamment Azure AI Search et Azure Cache for Redis.
Prenez l'exemple de l'extrait de code suivant :
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"
);
}
Le code précédent charge un ensemble de faits en mémoire afin que les données soient disponibles lors de l’interaction avec les modèles d’IA et l’orchestration des tâches.
