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.
Domänenspezifität: LLM kann auf die Verwendung branchenspezifischer Terminologie, Produktnamen oder Fachsprache abgestimmt werden.
Leistungsverbesserungen: Durch Feinabstimmung werden häufig Fehler reduziert und die Relevanz in Anwendungsfällen wie Kundenservice, Forschung und Analyse verbessert.
Kosten senken: Anstatt ein Modell von Grund auf neu zu erstellen, können Sie ein vorhandenes leistungsstarkes LLM anpassen.
Verbesserung der Effizienz: Sie nutzen vorab trainierte Gewichte und passen nur die letzte Ebene oder Parameter an, wodurch der Prozess beschleunigt wird.
Python zur Feinabstimmung
.NET Core C# für die Integration
Azure Services
In diesem Beispiel werden Hugging Face Transformers verwendet – eine der am weitesten verbreiteten LLM-Feinabstimmungsbibliotheken.
<code>python -m venv venv source venv/bin/activate # 在 Windows 上：venv\Scripts\activate</code>
<code>pip install torch transformers azureml-sdk</code>
<code> az group create --name LLMFinetuneRG --location eastus az ml workspace create --name LLMFinetuneWS --resource-group LLMFinetuneRG</code>
<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><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.
<code>dotnet new webapi -n FineTunedLLMApi cd FineTunedLLMApi</code>
<code>dotnet add package Microsoft.Extensions.Http dotnet add package Microsoft.Azure.Storage.Blob dotnet add package Newtonsoft.Json</code>
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><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>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>Azure App Service:
<code>python -m venv venv source venv/bin/activate # 在 Windows 上：venv\Scripts\activate</code>
Azure-Funktion (optional):
Azure Kubernetes Service (AKS) (Erweitert):
Datenschutz: Sorgen Sie für einen verantwortungsvollen Umgang mit sensiblen oder geschützten Daten, insbesondere während der Modellschulung.
Überwachung und Protokollierung: Integrieren Sie mit Azure Application Insights, um die Leistung zu überwachen, die Nutzung zu verfolgen und Anomalien zu erkennen.
Sicherheit: Verwenden Sie Azure Key Vault zum Speichern von Schlüsseln (API-Schlüssel, Verbindungszeichenfolgen).
Modellversionierung: Verfolgen Sie bei Bedarf verschiedene optimierte Versionen Ihres Modells in Azure ML;
Hint Engineering: Verfeinern Sie Ihre Hinweise, um die besten Ergebnisse mit Ihrem fein abgestimmten Modell zu erzielen.
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!
Einführung in die Eigenschaften des virtuellen Raums
So lösen Sie eine verstümmelte HTML-Seite
So schreiben Sie eine API-Schnittstelle
So gleichen Sie Zahlen in regulären Ausdrücken ab
So fügen Sie HTML einen CSS-Stil hinzu
So verwenden Sie den Befehl „find', um Dateien unter Linux zu finden
MySQL-Paging-Methode
940mx-Grafikkarte
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
