深度學習模型資料處理與批次訓練技巧

– 15 分鐘閱讀

深度學習模型的訓練離不開高效的資料處理流程。資料集的妥善劃分是模型泛化能力的基礎，訓練集、驗證集和測試集的比例組態需考量資料集大小和模型複雜度。PyTorch 的 DataLoader 提供了便捷的批次資料組織方式，透過自定義 Dataset 和 DataLoader，可以有效控制批次大小和資料讀取順序。模型訓練過程中，由於序列長度不一，需要對輸入資料進行填充，確保批次內資料長度一致。選擇合適的填充標記並正確處理目標 Token ID，才能避免填充資料影響模型訓練效果。模型微調階段，需根據評估結果迭代調整模型引數，以達到最佳效能。

簡單的複雜度：瞭解簡單與複雜的對比

在探討人工智慧和深度學習模型的複雜度時，瞭解「簡單」和「複雜」的對比至關重要。簡單是複雜的反義詞，代表著事物的直接性、易懂性和少陣列成部分。在人工智慧領域中，簡單的模型或演算法往往意味著更容易理解、實作和維護。

資料集的劃分

在進行深度學習模型的訓練之前，資料集的劃分是非常重要的一步。這涉及將資料分為訓練集、驗證集和測試集，以確保模型的泛化能力和避免過度擬合。以下是資料集劃分的一個例子：

train_portion = int(len(data) * 0.85)
test_portion = int(len(data) * 0.1)
val_portion = len(data) - train_portion - test_portion

train_data = data[:train_portion]
test_data = data[train_portion:train_portion + test_portion]
val_data = data[train_portion + test_portion:]

print("訓練集長度:", len(train_data))
print("驗證集長度:", len(val_data))
print("測試集長度:", len(test_data))

這個例子中，資料集被分為85%的訓練集、10%的測試集和5%的驗證集。這種劃分方式可以保證模型有足夠的資料進行訓練，並且能夠有效地評估模型的效能。

資料批次的組織

在深度學習中，資料批次（batch）的組織是一個非常重要的步驟。這涉及將資料分為小批次，以便模型可以高效地處理。以下是資料批次組織的一個例子：

import torch
from torch.utils.data import Dataset, DataLoader

class CustomDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

custom_dataset = CustomDataset(data)
batch_size = 32
data_loader = DataLoader(custom_dataset, batch_size=batch_size, shuffle=True)

在這個例子中，定義了一個自定義的資料集類別（CustomDataset），並使用PyTorch的DataLoader類別來組織資料批次。這樣可以方便地將資料批次餵入模型進行訓練。

圖表翻譯：

  graph LR
    A[資料集] --> B[訓練集]
    A --> C[驗證集]
    A --> D[測試集]
    B --> E[模型訓練]
    C --> F[模型評估]
    D --> G[模型測試]

這個圖表展示了資料集的劃分和模型訓練、評估、測試的流程。

資料準備與模型微調流程

在進行大語言模型（LLM）的訓練和評估時，資料準備和模型微調是兩個非常重要的步驟。以下是這個流程的詳細概述：

資料準備階段

  1. 資料下載和格式化：首先，我們需要下載所需的資料集，並將其格式化為模型可以接受的形式。這可能涉及清理資料、處理缺失值、轉換資料型別等步驟。
  2. 建立資料載入器：接下來，我們需要建立資料載入器，以便能夠高效地將資料餵入模型中。這通常涉及將資料分割為批次（batching），以便模型可以一次處理多個樣本。
  3. 載入預訓練模型：在資料準備完成後，我們可以載入一個預訓練的LLM模型。這個模型已經在大規模的文字資料集上進行了預訓練，可以為我們的特定任務提供一個良好的起點。
  4. 指令微調：接下來，我們需要對預訓練模型進行指令微調（instruction fine-tuning）。這涉及將模型在我們的特定任務上進行微調，以便它能夠學習到任務所需的知識和技能。

模型評估階段

  1. 評分回應：在模型微調完成後，我們需要評估模型的效能。這通常涉及計算模型對一組測試資料的回應，並根據某些評分標準（如準確率、F1分數等）對回應進行評分。
  2. 微調和評估：根據評分結果，我們可能需要對模型進行進一步的微調，以提高其效能。這個過程可能需要多次迭代，直到模型達到期望的效能水平。

微調和評估流程

整個流程可以分為三個階段：

  1. 資料準備階段：這個階段涉及資料下載、格式化、建立資料載入器和載入預訓練模型等步驟。
  2. 微調階段：在這個階段，我們對預訓練模型進行指令微調，以便它能夠學習到任務所需的知識和技能。
  3. 評估階段：最後，我們評估模型的效能，並根據評分結果對模型進行進一步的微調，以提高其效能。

內容解密：

在上述流程中，每一步都非常重要。資料準備階段為模型提供了高品質的輸入資料，而微調階段則使得模型能夠學習到任務所需的知識和技能。評估階段則幫助我們瞭解模型的效能，並對其進行進一步的改進。

圖表翻譯：

以下是上述流程的Mermaid圖表：

  flowchart TD
    A[資料下載和格式化] --> B[建立資料載入器]
    B --> C[載入預訓練模型]
    C --> D[指令微調]
    D --> E[評分回應]
    E --> F[微調和評估]

這個圖表展示了資料準備、模型微調和評估之間的流程關係。每個步驟都非常重要，共同構成了整個LLM訓練和評估流程。

資料預處理與批次處理

在進行大語言模型（LLM）的微調之前，需要對資料進行預處理，以確保資料能夠被模型正確地理解和處理。這個過程包括將資料填充到相同的長度，以便能夠將多個指令範例組合成一個批次。

資料填充

為了能夠將多個指令範例組合成一個批次，需要將所有的資料填充到相同的長度。這個過程可以透過在資料後面新增填充符號來完成。填充符號是一種特殊的符號，代表空白或無效的資料。

自定義批次處理函式

在 PyTorch 中，可以透過自定義批次處理函式來處理特定的資料格式。在這個例子中，需要實作一個自定義的 collate 函式來處理指令微調的資料集。這個函式需要能夠將資料填充到相同的長度，並且能夠將資料轉換成模型能夠理解的格式。

資料集類別

為了簡化資料預處理的過程，可以建立一個 InstructionDataset 類別來封裝資料預處理的邏輯。這個類別需要能夠將資料填充到相同的長度，並且能夠將資料轉換成模型能夠理解的格式。

實作批次處理

批次處理的過程可以分成五個子步驟：

  1. 格式化資料：使用提示範本來格式化資料。
  2. 分詞：使用之前章節中介紹的分詞技術來分詞格式化的資料。
  3. 新增填充符號：在資料後面新增填充符號，以便能夠將資料填充到相同的長度。
  4. 建立目標 token ID：建立目標 token ID，以便能夠計算損失函式。
  5. 替換填充符號：替換填充符號，以便能夠在損失函式中忽略填充符號。

以下是實作批次處理的程式碼範例：

import torch
from torch.utils.data import Dataset, DataLoader

class InstructionDataset(Dataset):
    def __init__(self, data, prompt_template):
        self.data = data
        self.prompt_template = prompt_template

    def __getitem__(self, idx):
        # 格式化資料
        formatted_data = self.prompt_template.format(self.data[idx])

        # 分詞
        tokenized_data = tokenize(formatted_data)

        # 新增填充符號
        padded_data = pad_sequence(tokenized_data, max_length=512)

        # 建立目標 token ID
        target_token_ids = torch.tensor(padded_data)

        # 替換填充符號
        target_token_ids[target_token_ids == -100] = 0

        return target_token_ids

    def __len__(self):
        return len(self.data)

# 建立資料集
dataset = InstructionDataset(data, prompt_template)

# 建立批次處理函式
def collate_fn(batch):
    # 格式化資料
    formatted_batch = [item[0] for item in batch]

    # 分詞
    tokenized_batch = [tokenize(item) for item in formatted_batch]

    # 新增填充符號
    padded_batch = pad_sequence(tokenized_batch, max_length=512)

    # 建立目標 token ID
    target_token_ids = torch.tensor(padded_batch)

    # 替換填充符號
    target_token_ids[target_token_ids == -100] = 0

    return target_token_ids

# 建立資料載入器
dataloader = DataLoader(dataset, batch_size=32, collate_fn=collate_fn)

圖表翻譯：

此圖示：

  graph LR
    A[格式化資料] --> B[分詞]
    B --> C[新增填充符號]
    C --> D[建立目標 token ID]
    D --> E[替換填充符號]

圖表翻譯：

此圖示展示了批次處理的過程，包括格式化資料、分詞、新增填充符號、建立目標 token ID 和替換填充符號。每個步驟都會將資料轉換成下一個步驟所需的格式，最終產生出能夠被模型理解的批次資料。

處理填充Token和目標Token ID的建立

在自然語言處理（NLP）任務中，尤其是在序列到序列的模型中，填充Token的使用是常見的。這些Token用於使輸入序列的長度一致，以便於模型的訓練和預測。然而，當處理這些Token時，我們需要確保它們不會干擾模型對實際資料的學習。

步驟1：替換填充Token

首先，我們需要識別出填充Token並將其替換為適當的佔位符。這一步驟確保了在模型訓練過程中，填充Token不會被誤認為是有意義的資料。例如，如果我們使用一個名為 [PAD] 的特殊Token作為填充Token，我們就需要將所有出現的填充Token替換為這個特殊Token。

步驟2：調整序列長度

接下來，我們需要調整所有序列的長度，使其一致。這通常是透過在序列末尾新增填充Token來實作的，直到所有序列都達到相同的長度。這一步驟對於模型的輸入格式是一致的至關重要，因為大多數深度學習模型要求批次中的所有序列都具有相同的長度。

步驟3：建立目標Token ID

最後，我們需要為模型的輸出建立目標Token ID。這涉及到將目標序列轉換為Token ID序列，該序列可以用於模型的訓練。目標Token ID序列應該與輸入序列的長度一致，並且應該反映出目標序列中每個Token的實際ID。

範例

假設我們有一個序列 [21106, 318, 281, 12064, 326, 8477, 257, 4876, 13]，並且我們想要將其調整到與另一個序列相同的長度，該序列是 [21106, 318, 281, 12064, 326, 8477, 257, 4876, 13, 50256, 50256, 50256]。為了使兩個序列的長度一致，我們可能會在第一個序列末尾新增填充Token 50256，直到它達到與第二個序列相同的長度。

import numpy as np

# 原始序列
sequence1 = np.array([21106, 318, 281, 12064, 326, 8477, 257, 4876, 13])

# 目標序列
sequence2 = np.array([21106, 318, 281, 12064, 326, 8477, 257, 4876, 13, 50256, 50256, 50256])

# 填充Token
padding_token = 50256

# 計算需要新增的填充Token數量
num_padding_tokens = len(sequence2) - len(sequence1)

# 新增填充Token到sequence1
padded_sequence1 = np.pad(sequence1, (0, num_padding_tokens), mode='constant', constant_values=padding_token)

print(padded_sequence1)

這樣，padded_sequence1 就會是 [21106, 318, 281, 12064, 326, 8477, 257, 4876, 13, 50256, 50256, 50256]，它現在與 sequence2 的長度一致。這種方法確保了所有序列都具有相同的長度，這對於模型的訓練和預測是必要的。

圖表翻譯：

  flowchart TD
    A[原始序列] -->|轉換|> B[目標序列]
    B -->|填充|> C[填充後序列]
    C -->|訓練|> D[模型訓練]
    D -->|預測|> E[預測結果]

這個流程圖描述了從原始序列到目標序列的轉換過程，包括填充Token和模型訓練及預測的步驟。

Instruction:

實作一個自訂的Dataset類別，來組織訓練資料，包括將輸入轉換為token ID、新增結尾token、建立目標token ID列表，並替換特定的padding token。

Response:

import torch
from torch.utils.data import Dataset

class InstructionDataset(Dataset):
    def __init__(self, data, tokenizer, max_len):
        self.data = data
        self.tokenizer = tokenizer
        self.max_len = max_len

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        instruction = self.data[idx]['instruction']
        response = self.data[idx]['response']

        encoding = self.tokenizer.encode_plus(
            instruction,
            add_special_tokens=True,
            max_length=self.max_len,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt'
        )

        decoding = self.tokenizer.encode_plus(
            response,
            add_special_tokens=True,
            max_length=self.max_len,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt'
        )

        # 新增結尾token
        input_ids = encoding['input_ids'].flatten()
        attention_mask = encoding['attention_mask'].flatten()
        labels = decoding['input_ids'].flatten()

        # 替換特定的padding token
        for i in range(len(input_ids)):
            if input_ids[i] == 50256:
                input_ids[i] = 213

        return {
            'input_ids': input_ids,
            'attention_mask': attention_mask,
            'labels': labels
        }

這個實作中，我們定義了一個InstructionDataset類別，繼承自PyTorch的Dataset類別。該類別負責組織訓練資料，包括將輸入轉換為token ID、新增結尾token、建立目標token ID列表，並替換特定的padding token。

自然語言處理中的批次處理實作

在自然語言處理任務中，批次處理是一種常見的最佳化技術，用於提高模型的執行效率。以下是實作批次處理的步驟：

1. 資料預處理

首先，我們需要對輸入的資料進行預處理。這包括將文字資料轉換為模型可以理解的格式，例如將文字轉換為token ID序列。

2. 批次構建

接下來，我們需要構建批次。批次是指一組資料的集合，模型一次性地處理這組資料。構建批次的過程包括將預處理後的資料按照特定的順序排列，然後將其轉換為模型可以接受的格式。

3. 模型輸入

最後，我們需要將批次輸入到模型中。模型會對批次中的每個資料進行處理，然後輸出結果。

實作批次處理的程式碼

以下是實作批次處理的程式碼範例：

class InstructionDataset:
    def __init__(self, data, tokenizer):
        self.data = data
        self.encoded_texts = []
        for entry in data:
            instruction_plus_input = self.format_input(entry)
            response_text = self.format_response(entry)
            full_text = instruction_plus_input + response_text
            self.encoded_texts.append(tokenizer.encode(full_text))

    def __getitem__(self, index):
        return self.encoded_texts[index]

    def __len__(self):
        return len(self.data)

    def format_input(self, entry):
        # 將輸入資料轉換為特定的格式
        instruction = entry['instruction']
        input_text = entry['input']
        return f"### Instruction:\n{instruction}\n### Input:\n{input_text}"

    def format_response(self, entry):
        # 將輸出資料轉換為特定的格式
        output = entry['output']
        return f"\n\n### Response:\n{output}"

批次處理的優點

批次處理有以下優點：

  • 提高效率：批次處理可以提高模型的執行效率，因為模型可以一次性地處理多個資料。
  • 減少計算量：批次處理可以減少計算量，因為模型只需要對批次中的每個資料進行一次計算。

批次處理的應用場景

批次處理可以應用於以下場景：

  • 自然語言處理：批次處理可以用於自然語言處理任務，例如文字分類別、情感分析等。
  • 影像處理：批次處理可以用於影像處理任務，例如影像分類別、物體偵測等。

圖表翻譯：

  flowchart TD
    A[開始] --> B[資料預處理]
    B --> C[批次構建]
    C --> D[模型輸入]
    D --> E[模型輸出]
    E --> F[結果]

在上述流程圖中，我們可以看到批次處理的步驟，從資料預處理到模型輸出。這個流程圖展示了批次處理的基本步驟和流程。

7.2 自定義資料集格式化與批次處理

在進行微調訓練時，為了加速訓練過程，需要對資料集進行格式化和批次處理。這一步驟對於提高模型的效率和準確度至關重要。

7.2.1 資料集格式化

首先，需要對資料集進行格式化，以便模型能夠正確地理解和處理資料。這涉及到將原始資料轉換為模型可以接受的格式。在這個過程中，需要使用特定的範本來組織資料，以確保每個資料入口都具有相同的結構和格式。

7.2.2 資料分詞

接下來，需要對格式化的資料進行分詞。分詞是指將文字資料分解為單個的詞彙或符號，以便模型能夠更好地理解資料的含義。在這個過程中，會使用到分詞器（tokenizer）來將文字資料轉換為模型可以接受的格式。

7.2.3 批次處理

批次處理是指將多個資料入口組合成一個批次，以便模型能夠一次性地處理多個資料入口。這可以大大提高模型的效率和速度。在進行批次處理時，需要確保每個批次中的資料入口都具有相同的長度，以便模型能夠正確地處理資料。

自定義批次處理函式

為了實作批次處理，需要自定義一個批次處理函式。這個函式需要能夠自動地對每個批次中的資料入口進行填充，以確保每個批次中的資料入口都具有相同的長度。以下是自定義批次處理函式的一個例子：

import tiktoken

def custom_collate(batch):
    # 取得批次中的最大長度
    max_length = max(len(entry) for entry in batch)
    
    # 對每個資料入口進行填充
    padded_batch = []
    for entry in batch:
        # 對資料入口進行填充
        padded_entry = entry + [50256] * (max_length - len(entry))
        padded_batch.append(padded_entry)
    
    return padded_batch

在這個例子中，自定義批次處理函式使用了 tiktoken 函式庫來對資料入口進行填充。函式首先計算出批次中的最大長度，然後對每個資料入口進行填充，以確保每個資料入口都具有相同的長度。

7.2.4 實作批次處理

實作批次處理後，需要將其應用到模型的訓練過程中。這可以透過在模型的訓練迴圈中呼叫自定義批次處理函式來實作。以下是實作批次處理的一個例子：

# 定義模型和資料集
model =...
dataset =...

# 定義批次大小
batch_size = 32

# 建立資料載入器
data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, collate_fn=custom_collate)

# 訓練模型
for epoch in range(10):
    for batch in data_loader:
        # 對每個批次進行訓練
        model.train()
        optimizer.zero_grad()
        outputs = model(batch)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

在這個例子中，實作批次處理後，需要將其應用到模型的訓練過程中。這可以透過在模型的訓練迴圈中呼叫自定義批次處理函式來實作。

圖表翻譯：

以下是對批次處理過程的視覺化圖表：

  flowchart TD
    A[資料集] --> B[格式化]
    B --> C[分詞]
    C --> D[批次處理]
    D --> E[模型訓練]

在這個圖表中，展示了批次處理過程的各個步驟，包括資料集格式化、分詞、批次處理和模型訓練。

程式碼分析與最佳化

在進行程式碼分析與最佳化時，首先需要了解程式碼的結構和邏輯。給定的程式碼片段似乎是一系列的陣列操作，但缺乏明確的上下文和函式定義。然而，我們可以嘗試對其進行一些基本的分析和最佳化。

程式碼重構

首先，觀察到程式碼中有多個陣列被重複定義，例如 [0, 1, 2, 3, 4] 和 [5, 6] 等。這些陣列可以被提取出來，定義為常數或變數，以提高程式碼的可讀性和可維護性。

# 定義常數
ARRAY_1 = [0, 1, 2, 3, 4]
ARRAY_2 = [5, 6]
ARRAY_3 = [7, 8, 9]

重複程式碼的消除

其次，程式碼中有一些重複的操作，例如 [8, 1] 和 [10, 3, 11, 6] 等。這些操作可以被封裝成函式，以消除重複程式碼。

def process_array(array):
    # 對陣列進行某種操作
    return array

# 使用函式處理陣列
result_1 = process_array([8, 1])
result_2 = process_array([10, 3, 11, 6])

錯誤值的處理

最後，程式碼中出現了一些錯誤值，例如 50256。這些值可能是由於某種計算錯誤或資料錯誤引起的。需要對這些值進行檢查和處理，以確保程式碼的正確性。

def check_value(value):
    # 檢查值是否為錯誤值
    if value == 50256:
        return False
    return True

# 使用函式檢查值
if not check_value(50256):
    print("錯誤值")
內容解密：

上述程式碼片段展示瞭如何對給定的陣列進行操作和最佳化。透過定義常數、封裝函式和檢查錯誤值，可以提高程式碼的品質和可靠性。這些技術可以應用於各種程式設計場景，以提高開發效率和程式碼品質。

圖表翻譯：

  flowchart TD
    A[開始] --> B[定義常數]
    B --> C[封裝函式]
    C --> D[檢查錯誤值]
    D --> E[輸出結果]

圖表翻譯：

此圖表展示了程式碼最佳化的流程。首先，定義常數以提高可讀性和可維護性。然後，封裝函式以消除重複程式碼。接著，檢查錯誤值以確保程式碼的正確性。最後，輸出結果以展示程式碼的執行效果。

資料批次處理

在進行深度學習訓練時，資料的批次處理是一個重要的步驟。這涉及將資料組織成批次，以便模型能夠高效地進行訓練。以下是實作批次處理的步驟和相關概念的詳細解釋。

批次處理的必要性

批次處理的主要目的是確保所有訓練樣本在同一批次中具有相同的長度。這是因為大多數深度學習模型要求輸入資料具有固定的長度。如果沒有批次處理，模型將無法高效地處理變長資料。

實作批次處理

實作批次處理的一種方法是使用自定義的拼接函式（collate function）。以下是使用Python實作的簡單範例：

def 自定義拼接函式(
    批次資料,
    填充標記編號=50256,
    裝置="cpu"
):
    # 找到批次中最長的序列長度
    批次最大長度 = max(len(專案) + 1 for 專案 in 批次資料)
    
    # 對每個序列進行填充
    填充後的批次 = []
    for 專案 in 批次資料:
        # 將序列填充到批次最大長度
        填充後的專案 = 專案 + [填充標記編號] * (批次最大長度 - len(專案))
        填充後的批次.append(填充後的專案)
    
    # 傳回填充後的批次
    return 填充後的批次

內容解密：

上述程式碼中，我們首先找到批次中最長的序列長度。然後，我們對每個序列進行填充，將其填充到批次最大長度。這樣可以確保所有序列在同一批次中具有相同的長度。最後，我們傳回填充後的批次。

圖表視覺化

以下是使用Mermaid語法繪製的批次處理流程圖：

  flowchart TD
    A[收集資料] --> B[分割資料]
    B --> C[計算最大長度]
    C --> D[填充序列]
    D --> E[傳回填充後的批次]

圖表翻譯：

此圖表展示了批次處理的流程。首先，我們收集資料並將其分割成序列。然後，我們計算批次中最長的序列長度。接下來，我們對每個序列進行填充，將其填充到批次最大長度。最後，我們傳回填充後的批次。

從技術架構視角來看，本文探討的資料預處理、批次處理和填充機制是深度學習模型訓練流程中的關鍵環節。透過Python程式碼範例和流程圖，文章清晰地闡述瞭如何將變長資料轉換為固定長度批次，以符合深度學習模型的輸入要求。分析階段的程式碼範例雖然簡潔，但有效地展示了資料集劃分、資料載入器構建、填充機制實作以及自定義拼接函式的設計思路。然而，程式碼範例缺乏對不同分詞器（Tokenizer）的應用說明，這在實務操作中是一個重要的考量因素。對於不同型別的資料和模型，Tokenizer的選擇和組態會直接影響模型的效能。此外，文章對於填充策略的討論也較為簡略，例如未提及不同填充策略（例如頭部填充、尾部填充）對模型訓練的影響。展望未來，隨著模型架構的演進和資料集規模的擴大，更高效的批次處理策略和填充機制將成為重要的研究方向。玄貓認為，深入理解資料批次處理的底層邏輯，並根據實際應用場景選擇合適的策略和工具，才能最大程度地發揮深度學習模型的效能。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。