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é.
Spécificité du domaine : LLM peut être affiné pour utiliser une terminologie, des noms de produits ou un jargon spécifiques à l'industrie.
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.
Réduire les coûts : Au lieu de créer un modèle à partir de zéro, vous pouvez personnaliser un LLM puissant existant.
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.
Python pour le réglage fin
.NET Core C# pour l'intégration
Services Azure
Cet exemple utilise Hugging Face Transformers - l'une des bibliothèques de réglage fin LLM les plus largement adoptées.
<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>À ce stade, votre modèle affiné est stocké dans Azure Machine Learning pour un accès et un contrôle de version faciles.
<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>
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><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>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>Azure App Service :
<code>python -m venv venv source venv/bin/activate # 在 Windows 上：venv\Scripts\activate</code>
Fonction Azure (facultatif) :
Service Azure Kubernetes (AKS) (Avancé) :
Confidentialité des données : Garantissez un traitement responsable des données sensibles ou propriétaires, en particulier lors de la formation du modèle.
Surveillance et journalisation : intégrez Azure Application Insights pour surveiller les performances, suivre l'utilisation et détecter les anomalies.
Sécurité : utilisez Azure Key Vault pour stocker les clés (clés API, chaînes de connexion).
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.
Hint Engineering : Affinez vos indices pour obtenir les meilleurs résultats de votre modèle affiné.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
