torchtext如何進行文本數據處理

這篇“torchtext如何進行文本數據處理”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“torchtext如何進行文本數據處理”文章吧。

首先整體介紹一下torchtext的組件

torchtext包含以下組件：

Field :主要包含以下數據預處理的配置信息，比如指定分詞方法，是否轉成小寫，起始字符，結束字符，補全字符以及詞典等等

Dataset :繼承自pytorch的Dataset，用于加載數據，提供了TabularDataset可以指點路徑，格式，Field信息就可以方便的完成數據加載。同時torchtext還提供預先構建的常用數據集的Dataset對象，可以直接加載使用，splits方法可以同時加載訓練集，驗證集和測試集。

Iterator : 主要是數據輸出的模型的迭代器，可以支持batch定制

1. Field

Field 包含一寫文本處理的通用參數的設置，同時還包含一個詞典對象，可以把文本數據表示成數字類型，進而可以把文本表示成需要的tensor類型

以下是Field對象包含的參數：

sequential: 是否把數據表示成序列，如果是False, 不能使用分詞 默認值: True.

use_vocab: 是否使用詞典對象. 如果是False 數據的類型必須已經是數值類型. 默認值: True.

init_token: 每一條數據的起始字符 默認值: None.

eos_token: 每條數據的結尾字符 默認值: None.

fix_length: 修改每條數據的長度為該值，不夠的用pad_token補全. 默認值: None.

tensor_type: 把數據轉換成的tensor類型 默認值: torch.LongTensor.

preprocessing:在分詞之后和數值化之前使用的管道 默認值: None.

postprocessing: 數值化之后和轉化成tensor之前使用的管道默認值: None.

lower: 是否把數據轉化為小寫 默認值: False.

tokenize: 分詞函數. 默認值: str.split.

include_lengths: 是否返回一個已經補全的最小batch的元組和和一個包含每條數據長度的列表 . 默認值: False.

batch_first: Whether to produce tensors with the batch dimension first. 默認值: False.

pad_token: 用于補全的字符. 默認值: "<pad>".

unk_token: 不存在詞典里的字符. 默認值: "<unk>".

pad_first: 是否補全第一個字符. 默認值: False.

重要的幾個方法：

pad(minibatch): 在一個batch對齊每條數據

build_vocab(): 建立詞典

numericalize(): 把文本數據數值化，返回tensor

簡單的栗子如下，建一個Field對象

TEXT = data.Field(tokenize=data.get_tokenizer('spacy'), 
                  init_token='<SOS>', eos_token='<EOS>',lower=True)

2.Dataset

torchtext的Dataset是繼承自pytorch的Dataset，提供了一個可以下載壓縮數據并解壓的方法（支持.zip, .gz, .tgz）

splits方法可以同時讀取訓練集，驗證集，測試集

TabularDataset可以很方便的讀取CSV, TSV, or JSON格式的文件，例子如下：

train, val, test = data.TabularDataset.splits(
        path='./data/', train='train.tsv',
        validation='val.tsv', test='test.tsv', format='tsv',
        fields=[('Text', TEXT), ('Label', LABEL)])

加載數據后可以建立詞典，建立詞典的時候可以使用與訓練的word vector

TEXT.build_vocab(train, vectors="glove.6B.100d")

3. Iterator

Iterator是torchtext到模型的輸出，它提供了我們對數據的一般處理方式，比如打亂，排序，等等，可以動態修改batch大小，這里也有splits方法 可以同時輸出訓練集，驗證集，測試集

參數如下：

dataset: 加載的數據集

batch_size: Batch 大小.

batch_size_fn: 產生動態的batch大小 的函數

sort_key: 排序的key

train: 是否是一個訓練集

repeat: 是否在不同epoch中重復迭代

shuffle: 是否打亂數據

sort: 是否對數據進行排序

sort_within_batch: batch內部是否排序

device: 建立batch的設備 -1:CPU ；0,1 ...：對應的GPU

使用方式如下：

train_iter, val_iter, test_iter = data.Iterator.splits(
        (train, val, test), sort_key=lambda x: len(x.Text),
        batch_sizes=(32, 256, 256), device=-1)

4.其他

torchtext提供常用文本數據集，并可以直接加載使用：

train,val,test = datasets.WikiText2.splits(text_field=TEXT)

現在包含的數據集包括：

Sentiment analysis: SST and IMDb
Question classification: TREC
Entailment: SNLI
Language modeling: WikiText-2
Machine translation: Multi30k, IWSLT, WMT14

完整例子如下，短短幾行就把詞典和數據batch做好了。

import spacy
import torch
from torchtext import data, datasets
spacy_en = spacy.load('en')
def tokenizer(text): # create a tokenizer function
    return [tok.text for tok in spacy_en.tokenizer(text)]
TEXT = data.Field(sequential=True, tokenize=tokenizer, lower=True, fix_length=150)
LABEL = data.Field(sequential=False, use_vocab=False)
train, val, test = data.TabularDataset.splits(
        path='./data/', train='train.tsv',
        validation='val.tsv', test='test.tsv', format='tsv',
        fields=[('Text', TEXT), ('Label', LABEL)])
TEXT.build_vocab(train, vectors="glove.6B.100d")
train_iter, val_iter, test_iter = data.Iterator.splits(
        (train, val, test), sort_key=lambda x: len(x.Text),
        batch_sizes=(32, 256, 256), device=-1)
vocab = TEXT.vocab

補充：使用TorchText處理我們自己的數據集

TorchText可以讀取三種數據格式:json, tsv (tab separated values 制表分隔值)和csv(comma separated values 逗號分隔值)。

處理JSON數據

從json開始，你的數據必須是json行格式，也就是說，它必須是這樣的:

{"name": "John", "location": "United Kingdom", "age": 42, "quote": ["i", "love", "the", "united kingdom"]}
{"name": "Mary", "location": "United States", "age": 36, "quote": ["i", "want", "more", "telescopes"]}

也就是說，每一行都是一個json對象。data/trian.json為例。

然后我們定義字段：

from torchtext import data
from torchtext import datasets
NAME = data.Field()
SAYING = data.Field()
PLACE = data.Field()

接下來，我們必須告訴TorchText哪個字段應用于json對象的哪個元素。

對于json數據，我們必須創建一個字典:

鍵與json對象的鍵匹配

值為元組，其中:

第一個元素成為batch對象的屬性名

第二個元素是字段的名稱

一些注意事項：

fields字典中鍵的順序并不重要，只要它的鍵與json數據鍵匹配即可。

字段名不必與json對象中的鍵匹配，例如，我們使用PLACE來表示“location”字段。

當處理json數據時，并不是所有的鍵都必須使用，例如，我們沒有使用“age”字段。

同樣，如果json字段的值是一個字符串，那么將應用字段標記化(默認情況下是將字符串按空格分隔)，然而，如果值是一個列表，則不應用標記化。通常情況下，將數據標記為一個列表是一個好主意，這節省了時間，因為您不必等待TorchText來做這件事。

json字段的值不必是相同的類型。有些例子的“引號”可以是字符串，有些則是列表。標記化將只應用于那些以“引號”表示字符串的字符串。

如果你正在使用一個json字段，每個例子必須有一個該字段的實例，例如在這個例子中所有的例子必須有一個name，location和quote。但是，由于我們沒有使用age字段，因此示例中沒有age字段也沒有關系。

fields = {'name': ('n', NAME), 'location': ('p', PLACE), 'quote': ('s', SAYING)}

現在，在訓練循環中，我們可以通過數據迭代器進行迭代并且通過batch.n訪問name，通過batch.p訪問location，通過batch.s訪問quote。

然后我們使用TabularDataset.splits函數創建我們的數據集（train_data和test_data）

path參數指定兩個數據集中共同的頂級文件夾，train和test參數指定每個數據集的文件名，例如，這里的train數據集位于data/train.json。

我們告訴函數我們正在使用json數據，并將前面定義的fields字典傳遞給它。

train_data, test_data = data.TabularDataset.splits(
                            path = 'data',
                            train = 'train.json',
                            test = 'test.json',
                            format = 'json',
                            fields = fields
)

如果已經有驗證數據集，則可以將其路徑作為validation 參數傳遞。

train_data, valid_data, test_data = data.TabularDataset.splits(
                                        path = 'data',
                                        train = 'train.json',
                                        validation = 'valid.json',
                                        test = 'test.json',
                                        format = 'json',
                                        fields = fields
)

然后，我們可以查看一個示例，以確保它已經正確地工作。

請注意字段名(n、p和s)是如何與fields字典中定義的內容匹配的。

還請注意p中的單詞“United Kingdom”是如何被標記化分開的，而s中的“United Kingdom”則沒有。這是由于前面提到的原因，TorchText假設任何作為列表的json字段都已經被標記化了，并且不再應用進一步的標記化。

print(vars(train_data[0]))
{'n': ['John'], 'p': ['United', 'Kingdom'], 's': ['i', 'love', 'the', 'united kingdom']}

現在我們可以使用train_data、test_data和valid_data來構建詞匯表并創建迭代器。我們可以使用batch.n, batch.p and batch.s訪問分別表示names、places和sayings的所有屬性。

處理CSV/TSV數據

csv和tsv非常相似，只是csv的元素用逗號分隔，而tsv用制表符分隔。

用上面的例子，我們的tsv數據將會是:

name    location    age quote
John    United Kingdom  42  i love the united kingdom
Mary    United States   36  i want more telescopes

也就是說，每一行的元素都由制表符分隔，每行有一個示例。第一行通常是標題(即每個列的名稱)，但你的數據也可能沒有標題。

tsv或csv數據中不能有列表。

字段的定義方式與json稍有不同。現在我們使用一個元組列表，其中每個元素也是一個元組。這些內部元組的第一個元素將成為batch對象的屬性名，第二個元素是字段名。

與json數據不同，元組必須與tsv數據中的順序相同。因此，當跳過一列數據時，需要使用一個none元組，如果沒有，那么我們的SAYING字段將應用到tsv數據的age列，而quote列將不會被使用。

但是，如果您只想使用name和age列，您可以只使用兩個元組，因為它們是前兩個列。

我們更改TabularDataset以讀取正確的.tsv文件，并將format參數更改為'tsv'。

如果你的數據有一個標題頭，我們的數據就有，它必須通過傳遞skip_header = True來跳過。如果沒有，TorchText會認為頭部是一個例子。默認情況下，skip_header為False。

fields = [('n', NAME), ('p', PLACE), (None, None), ('s', SAYING)]

train_data, valid_data, test_data = data.TabularDataset.splits(
                                        path = 'data',
                                        train = 'train.tsv',
                                        validation = 'valid.tsv',
                                        test = 'test.tsv',
                                        format = 'tsv',
                                        fields = fields,
                                        skip_header = True
)

print(vars(train_data[0]))
{'n': ['John'], 'p': ['United', 'Kingdom'], 's': ['i', 'love', 'the', 'united', 'kingdom']}

最后，我們將討論csv文件。

這與tsv文件幾乎完全相同，只是格式參數設置為“csv”。

fields = [('n', NAME), ('p', PLACE), (None, None), ('s', SAYING)]
train_data, valid_data, test_data = data.TabularDataset.splits(
                                        path = 'data',
                                        train = 'train.csv',
                                        validation = 'valid.csv',
                                        test = 'test.csv',
                                        format = 'csv',
                                        fields = fields,
                                        skip_header = True
)

print(vars(train_data[0]))

{'n': ['John'], 'p': ['United', 'Kingdom'], 's': ['i', 'love', 'the', 'united', 'kingdom']}

為什么JSON好于CSV/TSV？

csv或tsv數據無法存儲列表。這意味著數據不能被標記化，因此每次運行通過TorchText讀取數據的Python腳本時，數據都必須被標記化。使用高級的標記器，如spaCy標記器，需要不可忽略的大量時間。因此，最好是對數據集進行標記并以json行格式存儲它們。

如果tsv數據中出現制表符，或csv數據中出現逗號，TorchText會認為它們是列之間的分隔符。這將導致數據被錯誤地解析。最糟糕的是，TorchText不會提醒你這一點，因為它無法分辨字段中的制表符/逗號和作為分隔符的制表符/逗號之間的區別。由于json數據本質上是一個字典，您可以通過它的鍵訪問字段中的數據，所以不必擔心“surprise”分隔符。

迭代器

使用上面的任何數據集，我們就可以構建詞匯表并創建迭代器。

NAME.build_vocab(train_data)
SAYING.build_vocab(train_data)
PLACE.build_vocab(train_data)

然后，我們可以在定義批處理大小和設備后，創建迭代器。

默認情況下，訓練數據在每個epoch進行洗牌，但驗證/測試數據是排序的。然而，TorchText不知道該用什么來排序我們的數據，如果我們不告訴它，它就會拋出錯誤。

有兩種方法來處理這個問題，你可以通過傳遞sort = False來告訴迭代器不要對驗證/測試數據進行排序，或者你可以通過傳遞sort_key來告訴迭代器如何對數據進行排序。sort key是一個函數，它返回一個用于對數據進行排序的鍵。例如，lambda x: x.s將根據它們的s屬性(即它們的quote)對示例進行排序。理想情況下，您希望使用sort key，因為BucketIterator將能夠對示例進行排序，然后最小化每個批處理中的填充量。

然后，我們可以遍歷迭代器來獲得批量數據。注意，默認情況下TorchText的批處理維度是在第二維。

import torch
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
BATCH_SIZE = 1
train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, valid_data, test_data),
    sort = False, #don't sort test/validation data
    batch_size=BATCH_SIZE,
    device=device)
train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, valid_data, test_data),
    sort_key = lambda x: x.s, #sort by s attribute (quote)
    batch_size=BATCH_SIZE,
    device=device)
print('Train:')
for batch in train_iterator:
    print(batch)
    
print('Valid:')
for batch in valid_iterator:
    print(batch)
    
print('Test:')
for batch in test_iterator:
    print(batch)

Train:
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 2x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 5x1 (GPU 0)]
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 2x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 4x1 (GPU 0)]
Valid:
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 2x1 (GPU 0)]
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 4x1 (GPU 0)]
Test:
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 3x1 (GPU 0)]
[torchtext.data.batch.Batch of size 1]
	[.n]:[torch.cuda.LongTensor of size 1x1 (GPU 0)]
	[.p]:[torch.cuda.LongTensor of size 2x1 (GPU 0)]
	[.s]:[torch.cuda.LongTensor of size 3x1 (GPU 0)]

以上就是關于“torchtext如何進行文本數據處理”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。