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)

# 加載自定義數(shù)據(jù)集（本地或來(lái)自 Azure 存儲(chǔ)）
# 示例：Azure ML 中的文本文件或數(shù)據(jù)集
train_texts = ["此處輸入您的特定領(lǐng)域文本..."]  # 簡(jiǎn)化版
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()

# 保存微調(diào)后的模型
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);

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

// 注冊(cè) 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!