Affiner les grands modèles de langage (LLM) avec .NET Core, Python et Azure

Table des matières

1. Présentation
2. Pourquoi affiner les grands modèles de langage ?
3. Présentation de la solution
4. Paramètres d'environnement
5. Formation et mise au point à l'aide de Python
6. Intégrer des modèles affinés dans .NET Core
7. Déployer sur Azure
8. Bonnes pratiques
9. Conclusion

---

1. Présentation

Les

Les modèles linguistiques à grande échelle (LLM) ont reçu une large attention pour leur capacité à comprendre et à générer du texte de type humain. Cependant, de nombreuses organisations disposent d’ensembles de données et de vocabulaires uniques et spécifiques à un domaine qui peuvent ne pas être entièrement capturés par les modèles génériques. Le Le réglage fin permet aux développeurs d'adapter ces grands modèles à des environnements ou à des secteurs spécifiques, améliorant ainsi la précision et la pertinence.

Cet article explique comment affiner un LLM à l'aide de Python, puis intégrer et déployer le modèle résultant dans une application .NET Core C#, le tout sur Microsoft Azure pour plus d'évolutivité et de commodité.

---

2. Pourquoi affiner les grands modèles de langage ?

3. Spécificité du domaine : LLM peut être affiné pour utiliser une terminologie, des noms de produits ou un jargon spécifiques à l'industrie.

4. Améliorations des performances : les réglages fins réduisent souvent les erreurs et améliorent la pertinence dans les cas d'utilisation tels que le service client, la recherche et l'analyse.

5. Réduire les coûts : Au lieu de créer un modèle à partir de zéro, vous pouvez personnaliser un LLM puissant existant.

6. Amélioration de l'efficacité : Vous profitez de poids pré-entraînés et ajustez uniquement la couche ou les paramètres finaux, accélérant ainsi le processus.

---

3. Présentation de la solution

Composants et technologies

1. Python pour le réglage fin

   • Bibliothèques couramment utilisées (par exemple Hugging Face Transformers, PyTorch)
   • Simplification du processus de chargement et de réglage des modèles pré-entraînés

2. .NET Core C# pour l'intégration

   • Exposer un service backend ou une API pour affiner le modèle
   • Langage fortement typé, familier à de nombreux développeurs d'entreprise

3. Services Azure

   • Azure Machine Learning pour la formation et la gestion des modèles
   • Azure Storage pour les données et les artefacts de modèle
   • Azure App Service ou Azure Function pour l'hébergement d'applications .NET Core
   • Azure Key Vault (facultatif) pour protéger les informations d'identification

---

4. Paramètres d'environnement

Prérequis

• Abonnement Azure : requis pour créer des ressources telles que Machine Learning Workspace et App Service.
• Python 3.8  : installé localement pour le réglage fin du modèle.
• SDK .NET 6/7/8 : pour créer et exécuter des applications .NET Core C#.
• Visual Studio 2022 ou Visual Studio Code : IDE recommandé.
• Azure CLI : Utilisé pour configurer et gérer les services Azure via le terminal.
• Docker (facultatif) : peut être utilisé pour conteneuriser votre application si nécessaire.

---

5. Formation et mise au point avec Python

Cet exemple utilise Hugging Face Transformers - l'une des bibliothèques de réglage fin LLM les plus largement adoptées.

5.1 Configurer un environnement virtuel

<code>python -m venv venv
source venv/bin/activate  # 在 Windows 上：venv\Scripts\activate</code>

5.2 Installer les dépendances

<code>pip install torch transformers azureml-sdk</code>

5.3 Créer un espace de travail Azure Machine Learning

1. Groupe de ressources et Espace de travail :

<code>   az group create --name LLMFinetuneRG --location eastus
   az ml workspace create --name LLMFinetuneWS --resource-group LLMFinetuneRG</code>

1. Configurez l'environnement local pour vous connecter à l'espace de travail (à l'aide d'un fichier config.json ou de variables d'environnement).

5.4 Script de réglage fin (train.py)

<code>import os
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from azureml.core import Workspace, Run

# 连接到 Azure ML
ws = Workspace.from_config()
run = Run.get_context()

model_name = "gpt2"  # 示例模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 加载自定义数据集（本地或来自 Azure 存储）
# 示例：Azure ML 中的文本文件或数据集
train_texts = ["此处输入您的特定领域文本..."]  # 简化版
train_encodings = tokenizer(train_texts, truncation=True, padding=True)

class CustomDataset(torch.utils.data.Dataset):
    def __init__(self, encodings):
        self.encodings = encodings
    def __len__(self):
        return len(self.encodings["input_ids"])
    def __getitem__(self, idx):
        return {k: torch.tensor(v[idx]) for k, v in self.encodings.items()}

train_dataset = CustomDataset(train_encodings)

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    save_steps=100,
    logging_steps=100
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

trainer.train()

# 保存微调后的模型
trainer.save_model("./fine_tuned_model")
tokenizer.save_pretrained("./fine_tuned_model")</code>

5.5 Enregistrer le modèle dans Azure

<code>from azureml.core.model import Model

model = Model.register(
    workspace=ws,
    model_path="./fine_tuned_model",
    model_name="myFineTunedLLM"
)</code>

À ce stade, votre modèle affiné est stocké dans Azure Machine Learning pour un accès et un contrôle de version faciles.

---

6. Intégrer des modèles affinés dans .NET Core

6.1 Créer un projet d'API Web .NET Core

<code>dotnet new webapi -n FineTunedLLMApi
cd FineTunedLLMApi</code>

6.2 Ajouter des dépendances

• HttpClient pour appeler des points de terminaison Azure ou une API d'inférence locale
• Newtonsoft.Json (si vous préférez utiliser JSON.NET pour la sérialisation)
• Azure.Storage.Blobs ou Azure.Identity pour un accès sécurisé aux ressources Azure

<code>dotnet add package Microsoft.Extensions.Http
dotnet add package Microsoft.Azure.Storage.Blob
dotnet add package Newtonsoft.Json</code>

6.3 ModelConsumerService.cs

Supposons que vous avez déployé votre modèle affiné en tant que service Web (par exemple, en utilisant Azure Container Instance ou un point de terminaison personnalisé dans Azure ML). L'extrait de code suivant appelle le service pour obtenir les résultats d'achèvement.

<code>using Newtonsoft.Json;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class ModelConsumerService
{
    private readonly HttpClient _httpClient;

    public ModelConsumerService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("FineTunedModel");
    }

    public async Task<string> GetCompletionAsync(string prompt)
    {
        var requestBody = new { prompt = prompt };
        var content = new StringContent(
            JsonConvert.SerializeObject(requestBody),
            Encoding.UTF8, 
            "application/json");

        var response = await _httpClient.PostAsync("/predict", content);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}</code>

6.4 LLMController.cs

<code>using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

[ApiController]
[Route("[controller]")]
public class LLMController : ControllerBase
{
    private readonly ModelConsumerService _modelService;

    public LLMController(ModelConsumerService modelService)
    {
        _modelService = modelService;
    }

    [HttpPost("complete")]
    public async Task<IActionResult> CompletePrompt([FromBody] PromptRequest request)
    {
        var result = await _modelService.GetCompletionAsync(request.Prompt);
        return Ok(new { Completion = result });
    }
}

public class PromptRequest
{
    public string Prompt { get; set; }
}</code>

6.5 Configuration des applications .NET Core

Dans Program.cs ou Startup.cs :

<code>var builder = WebApplication.CreateBuilder(args);

// 注册 HttpClient
builder.Services.AddHttpClient("FineTunedModel", client =>
{
    client.BaseAddress = new Uri("https://your-model-endpoint/");
});

// 注册 ModelConsumerService
builder.Services.AddTransient<ModelConsumerService>();

builder.Services.AddControllers();
var app = builder.Build();

app.MapControllers();
app.Run();</code>

---

7. Déployer sur Azure

8. Azure App Service :

   • Pour de nombreuses applications .NET Core, il s’agit du chemin le plus simple.
   • Créez une nouvelle Web App depuis le portail Azure ou via la CLI.

<code>python -m venv venv
source venv/bin/activate  # 在 Windows 上：venv\Scripts\activate</code>

1. Fonction Azure (facultatif) :

   • Idéal pour exécuter une logique sans serveur basée sur les événements si votre utilisation est intermittente ou planifiée.

2. Service Azure Kubernetes (AKS) (Avancé) :

   • Idéal pour un déploiement à grande échelle.
   • Conteneurisez votre application à l'aide de Docker et envoyez-la vers Azure Container Registry (ACR).

---

8. Bonnes pratiques

9. Confidentialité des données : Garantissez un traitement responsable des données sensibles ou propriétaires, en particulier lors de la formation du modèle.

10. Surveillance et journalisation : intégrez Azure Application Insights pour surveiller les performances, suivre l'utilisation et détecter les anomalies.

11. Sécurité : utilisez Azure Key Vault pour stocker les clés (clés API, chaînes de connexion).

12. Gestion des versions du modèle : suivez différentes versions affinées de votre modèle dans Azure ML ; revenez aux anciennes versions si nécessaire.

13. Hint Engineering : Affinez vos indices pour obtenir les meilleurs résultats de votre modèle affiné.

---

9. Conclusion

Affinez le LLM à l'aide de Python et Azure Machine Learning, puis intégrez-les dans les applications .NET Core, vous permettant ainsi de créer une puissante IA spécifique à un domaine solutions. Cette combinaison constitue un excellent choix pour les organisations cherchant à tirer parti de l’écosystème d’IA de Python et des capacités d’entreprise de .NET, le tout optimisé par l’extensibilité d’Azure.

Avec une planification minutieuse de la sécurité, de la gouvernance des données et du DevOps, vous pouvez lancer une solution prête pour la production qui répond aux besoins du monde réel, en fournissant des fonctionnalités linguistiques précises et spécifiques à un domaine dans un cadre puissant et facile à entretenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!