Feinabstimmung großer Sprachmodelle (LLMs) mit .NET Core, Python und Azure

Inhaltsverzeichnis

1. Einführung
2. Warum große Sprachmodelle verfeinern?
3. Lösungsübersicht
4. Umgebungseinstellungen
5. Training und Feinabstimmung mit Python
6. Integrieren Sie fein abgestimmte Modelle in .NET Core
7. Bereitstellung in Azure
8. Best Practices
9. Fazit

---

1. Einführung

Groß angelegte Sprachmodelle (LLMs) haben aufgrund ihrer Fähigkeit, menschenähnlichen Text zu verstehen und zu generieren, große Aufmerksamkeit erhalten. Allerdings verfügen viele Organisationen über einzigartige, domänenspezifische Datensätze und Vokabulare, die von generischen Modellen möglicherweise nicht vollständig erfasst werden. Feinabstimmung ermöglicht es Entwicklern, diese großen Modelle an bestimmte Umgebungen oder Branchen anzupassen und so die Genauigkeit und Relevanz zu verbessern.

In diesem Artikel wird erläutert, wie man ein LLM mit Python verfeinert und dann das resultierende Modell in eine .NET Core C#-Anwendung integriert und bereitstellt, alles auf Microsoft Azure für Skalierbarkeit und Komfort.

---

2. Warum große Sprachmodelle verfeinern?

3. Domänenspezifität: LLM kann auf die Verwendung branchenspezifischer Terminologie, Produktnamen oder Fachsprache abgestimmt werden.

4. Leistungsverbesserungen: Durch Feinabstimmung werden häufig Fehler reduziert und die Relevanz in Anwendungsfällen wie Kundenservice, Forschung und Analyse verbessert.

5. Kosten senken: Anstatt ein Modell von Grund auf neu zu erstellen, können Sie ein vorhandenes leistungsstarkes LLM anpassen.

6. Verbesserung der Effizienz: Sie nutzen vorab trainierte Gewichte und passen nur die letzte Ebene oder Parameter an, wodurch der Prozess beschleunigt wird.

---

3. Lösungsübersicht

Komponenten und Technologien

1. Python zur Feinabstimmung

   • Häufig verwendete Bibliotheken (z. B. Hugging Face Transformers, PyTorch)
   • Der Prozess des Ladens und Optimierens vorab trainierter Modelle wurde vereinfacht

2. .NET Core C# für die Integration

   • Stellen Sie einen Backend-Dienst oder eine API zur Feinabstimmung des Modells bereit
   • Stark typisierte Sprache, die vielen Unternehmensentwicklern vertraut ist

3. Azure Services

   • Azure Machine Learningfür Training und Modellmanagement
   • Azure Storage für Daten und Modellartefakte
   • Azure App Service oder Azure Function zum Hosten von .NET Core-Anwendungen
   • Azure Key Vault (optional) zum Schutz von Anmeldeinformationen

---

4. Umgebungseinstellungen

Voraussetzungen

• Azure-Abonnement: Erforderlich zum Erstellen von Ressourcen wie Machine Learning Workspace und App Service.
• Python 3.8 : Zur Feinabstimmung des Modells lokal installiert.
• .NET 6/7/8 SDK: Zum Erstellen und Ausführen von .NET Core C#-Anwendungen.
• Visual Studio 2022 oder Visual Studio Code: Empfohlene IDE.
• Azure CLI: Wird zum Konfigurieren und Verwalten von Azure-Diensten über das Terminal verwendet.
• Docker (optional): Kann bei Bedarf zum Containerisieren Ihrer Anwendung verwendet werden.

---

5. Training und Feinabstimmung mit Python

In diesem Beispiel werden Hugging Face Transformers verwendet – eine der am weitesten verbreiteten LLM-Feinabstimmungsbibliotheken.

5.1 Virtuelle Umgebung einrichten

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

5.2 Abhängigkeiten installieren

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

5.3 Erstellen Sie einen Azure Machine Learning-Arbeitsbereich

1. Ressourcengruppe und Arbeitsbereich:

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

1. Konfigurieren Sie die lokale Umgebung für die Verbindung mit dem Arbeitsbereich (mithilfe einer config.json-Datei oder Umgebungsvariablen).

5.4 Feinabstimmungsskript (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 Modell in Azure registrieren

<code>from azureml.core.model import Model

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

Zu diesem Zeitpunkt wird Ihr fein abgestimmtes Modell für einfachen Zugriff und Versionskontrolle in Azure Machine Learning gespeichert.

---

6. Feinabgestimmte Modelle in .NET Core integrieren

6.1 .NET Core Web API-Projekt erstellen

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

6.2 Abhängigkeiten hinzufügen

• HttpClient zum Aufrufen von Azure-Endpunkten oder der lokalen Inferenz-API
• Newtonsoft.Json (wenn Sie JSON.NET für die Serialisierung bevorzugen)
• Azure.Storage.Blobs oder Azure.Identity für sicheren Zugriff auf Azure-Ressourcen

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

6.3 ModelConsumerService.cs

Angenommen, Sie haben Ihr fein abgestimmtes Modell als Webdienst bereitgestellt (z. B. mithilfe von Azure Container Instance oder einem benutzerdefinierten Endpunkt in Azure ML). Der folgende Codeausschnitt ruft den Dienst auf, um Abschlussergebnisse abzurufen.

<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 Konfigurieren von .NET Core-Anwendungen

In Program.cs oder 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. Bereitstellung in Azure

8. Azure App Service:

   • Für viele .NET Core-Anwendungen ist dies der einfachste Weg.
   • Erstellen Sie eine neue Web-App über das Azure-Portal oder über die CLI.

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

1. Azure-Funktion (optional):

   • Ideal für die Ausführung serverloser, ereignisgesteuerter Logik, wenn Ihre Nutzung zeitweise oder geplant ist.

2. Azure Kubernetes Service (AKS) (Erweitert):

   • Ideal für den Einsatz in großem Maßstab.
   • Containerisieren Sie Ihre Anwendung mit Docker und übertragen Sie sie an Azure Container Registry (ACR).

---

8. Best Practices

9. Datenschutz: Sorgen Sie für einen verantwortungsvollen Umgang mit sensiblen oder geschützten Daten, insbesondere während der Modellschulung.

10. Überwachung und Protokollierung: Integrieren Sie mit Azure Application Insights, um die Leistung zu überwachen, die Nutzung zu verfolgen und Anomalien zu erkennen.

11. Sicherheit: Verwenden Sie Azure Key Vault zum Speichern von Schlüsseln (API-Schlüssel, Verbindungszeichenfolgen).

12. Modellversionierung: Verfolgen Sie bei Bedarf verschiedene optimierte Versionen Ihres Modells in Azure ML;

13. Hint Engineering: Verfeinern Sie Ihre Hinweise, um die besten Ergebnisse mit Ihrem fein abgestimmten Modell zu erzielen.

---

9. Fazit

Optimieren Sie LLM mit Python und Azure Machine Learning und integrieren Sie sie dann in .NET Core-Anwendungen, sodass Sie leistungsstarke domänenspezifische KI erstellen können Lösungen. Diese Kombination ist eine ausgezeichnete Wahl für Unternehmen, die das KI-Ökosystem von Python und die Unternehmensfunktionen von .NET nutzen möchten, alles unterstützt durch die Erweiterbarkeit von Azure.

Mit sorgfältiger Planung für Sicherheit, Datenverwaltung und DevOps können Sie eine produktionsbereite Lösung auf den Markt bringen, die reale Anforderungen erfüllt und genaue domänenspezifische Sprachfunktionen in einem leistungsstarken und einfach zu wartenden Framework bereitstellt.

Das obige ist der detaillierte Inhalt vonFeinabstimmung großer Sprachmodelle (LLMs) mit .NET Core, Python und Azure. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!