大語言模型微調與評估

# 匯入必要的函式
from chapter05 import calc_loss_loader, train_model_simple

# 將模型移到指定裝置（GPU或CPU）
model.to(device)

# 計算初始損失
initial_train_loss = calc_loss_loader(model, train_loader)
initial_val_loss = calc_loss_loader(model, val_loader)

print(f"初始訓練損失：{initial_train_loss}")
print(f"初始驗證損失：{initial_val_loss}")

# 訓練模型
train_model_simple(model, train_loader, val_loader, device)

# 評估模型
model.eval()
with torch.no_grad():
    total_correct = 0
    for batch in test_loader:
        inputs, labels = batch
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total_correct += (predicted == labels).sum().item()

accuracy = total_correct / len(test_loader.dataset)
print(f"測試精確度：{accuracy:.2f}%")

# 提取和檢查輸出結果
with torch.no_grad():
    for batch in test_loader:
        inputs, labels = batch
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        print(f"輸出結果：{predicted}")

# 定性評估
with torch.no_grad():
    for batch in test_loader:
        inputs, labels = batch
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        print(f"定性評估結果：{predicted}")

import time

start_time = time.time()

# 初始化最佳化器
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

# 設定epoch數量
num_epochs = 5

# 定義評估頻率
eval_freq = 100

# 設定開始上下文
start_context = val_data[0]

# 訓練模型
for epoch in range(num_epochs):
    # 訓練過程
    model.train()
    for batch in train_loader:
        # 前向傳播
        inputs, labels = batch
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = calc_loss(outputs, labels)
        loss.backward()
        optimizer.step()
    
    # 評估模型
    model.eval()
    with torch.no_grad():
        eval_loss = calc_loss_loader(val_loader, model, device)
        print(f"Epoch {epoch+1}, Eval Loss: {eval_loss}")

import torch
import torch.optim as optim

# 設定隨機種子以確保可重現性
torch.manual_seed(123)

# 定義最佳化器
optimizer = optim.AdamW(model.parameters(), lr=0.00005, weight_decay=0.1)

# 設定訓練引數
num_epochs = 2

# 進行訓練
train_losses, val_losses, tokens_seen = train_model_simple(
    model, train_loader, val_loader, optimizer, device,
    num_epochs=num_epochs, eval_freq=5, eval_iter=5,
    start_context=format_input(val_data[0]), tokenizer=tokenizer
)

end_time = time.time()
execution_time_minutes = (end_time - start_time) / 60
print(f"Training completed in {execution_time_minutes:.2f} minutes.")

### Instruction: Convert the active sentence to passive: 'The chef cooks the meal every day.'

### Response: The meal is cooked every day by 玄貓.

plot_losses(train_losses, val_losses)

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

# 載入預訓練模型和tokenizer
model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
tokenizer = AutoTokenizer.from_pretrained("t5-base")

# 定義訓練引數
num_epochs = 2
batch_size = 8
max_length = 1024

# 建立訓練資料集
train_data =...

# 建立驗證資料集
val_data =...

# 對模型進行微調
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for batch in train_data:
        input_ids = batch["input_ids"].to(device)
        attention_mask = batch["attention_mask"].to(device)
        labels = batch["labels"].to(device)
        
        optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
        
        optimizer.zero_grad()
        
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    print(f"Epoch {epoch+1}, Loss: {total_loss / len(train_data)}")
    
    model.eval()
    val_loss = 0
    with torch.no_grad():
        for batch in val_data:
            input_ids = batch["input_ids"].to(device)
            attention_mask = batch["attention_mask"].to(device)
            labels = batch["labels"].to(device)
            
            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
            loss = outputs.loss
            
            val_loss += loss.item()
    
    print(f"Epoch {epoch+1}, Val Loss: {val_loss / len(val_data)}")

# 對模型進行評估
test_data =...

model.eval()
with torch.no_grad():
    for entry in test_data:
        input_text = format_input(entry)
        token_ids = generate(
            model=model,
            idx=text_to_token_ids(input_text, tokenizer).to(device),
            max_new_tokens=256,
            context_size=BASE_CONFIG["context_length"],
            eos_id=50256
        )
        generated_text = token_ids_to_text(token_ids, tokenizer)
        
        response_text = (
            generated_text[len(input_text):]
           .replace("### Response:", "")
           .strip()
        )
        
        print(f"Input: {input_text}")
        print(f"Response: {response_text}")

print(input_text)
print(f"\n正確輸出:\n>> {entry['output']}")
print(f"\n模型輸出:\n>> {response_text.strip()}")

from tqdm import tqdm

for i, entry in tqdm(enumerate(test_data), total=len(test_data)):
    input_text = format_input(entry)
    token_ids = generate(
        model=model,
        idx=text_to_token_ids(input_text, tokenizer).to(device),
        max_new_tokens=256,
        context_size=BASE_CONFIG["context_length"],
        eos_id=50256
    )
    generated_text = token_ids_to_text(token_ids, tokenizer)
    response_text = generated_text[len(input_text):].replace("### Response:", "")
    # 將回應追加到測試集字典中
    test_set[entry['id']] = response_text

import json
import torch

# 載入 Llama 3 模型
model = torch.load("llama3.pth")

# 定義評估函式
def evaluate_llm(instruction, input_text):
    # 使用 Ollama 來執行 Llama 3 模型
    output = model.generate(input_text, instruction)

    # 評估輸出結果
    score = evaluate_output(output)

    return score

# 定義評估輸出結果的函式
def evaluate_output(output):
    # 實作評估邏輯
    pass

# 載入測試資料
with open("test_data.json", "r") as file:
    test_data = json.load(file)

# 進行評估
for item in test_data:
    instruction = item["instruction"]
    input_text = item["input"]
    score = evaluate_llm(instruction, input_text)

    # 儲存評估結果
    item["score"] = score

# 儲存評估結果
with open("evaluated_test_data.json", "w") as file:
    json.dump(test_data, file)