PyTorch torchtext
PyTorch エコシステムには、torchvision画像データを処理するものや、torchaudio音声データを処理するものがありますが、テキスト処理の分野では、公式がかつて提供していたtorchtextライブラリにはいくつかの変更がありました。このセクションでは、テキストデータの前処理、語彙の構築、データの読み込みなどの操作をさまざまな方法で行う方法を紹介します。
注意:torchtext ライブラリはいくつかのリファクタリングを経験しました。以下の使用を推奨します。torchtext.legacyまたは、独自のテキスト処理パイプラインを構築してください。最新の torchtext バージョンは復帰し、よりモダンな API を提供しています。
1. テキストデータ前処理の基礎
テキスト前処理は NLP タスクの最初のステップであり、トークナイゼーション、語彙の構築、エンコーディングなどの操作が含まれます。
1.1 基本的なテキスト処理フロー
例
import re
from collections import Counter
class SimpleTokenizer:
"""
簡単なトークナイザ:スペースと句読点で分割
"""
def __init__(self):
# 句読点マッピング
self.punctuation = str.maketrans('', '', '.,!?;:"\'-()[]{}')
def tokenize(self, text):
# 小文字に変換
text = text.lower()
# 句読点を除去
text = text.translate(self.punctuation)
# トークナイズ
tokens = text.split()
return tokens
class Vocabulary:
"""
語彙構築
"""
def __init__(self, min_freq=2, max_size=10000):
self.min_freq = min_freq
self.max_size = max_size
self.word2idx = {'<PAD>': 0, '<UNK>': 1}
self.idx2word = {0: '<PAD>', 1: '<UNK>'}
self.word_count = Counter()
def build_vocab(self, texts):
"""テキストリストから語彙を構築"""
tokenizer = SimpleTokenizer()
# 単語頻度を集計
for text in texts:
tokens = tokenizer.tokenize(text)
self.word_count.update(tokens)
# 語彙を構築
for word, count in self.word_count.most_common(self.max_size):
if count < self.min_freq:
break
if word not in self.word2idx:
idx = len(self.word2idx)
self.word2idx[word] = idx
self.idx2word[idx] = word
print(f"語彙サイズ: {len(self.word2idx)}")
def encode(self, text, max_len=50):
"""テキストをインデックス系列にエンコード"""
tokenizer = SimpleTokenizer()
tokens = tokenizer.tokenize(text)[:max_len]
# エンコード
indices = [
self.word2idx.get(token, self.word2idx['<UNK>'])
for token in tokens
]
# ゼロパディング
if len(indices) < max_len:
indices += [self.word2idx['<PAD>']] * (max_len - len(indices))
return indices
def decode(self, indices):
"""インデックス系列をテキストにデコード"""
tokens = [self.idx2word.get(idx, '<UNK>') for idx in indices]
return ' '.join(tokens)
# 使用例
texts = [
"Hello world",
"This is a test",
"PyTorch is great for deep learning",
"Natural language processing is fun",
"Deep learning enables many applications",
]
vocab = Vocabulary(min_freq=1, max_size=100)
vocab.build_vocab(texts)
# エンコード
encoded = vocab.encode("Hello deep learning world!", max_len=10)
print(f"エンコード結果: {encoded}")
# デコード
decoded = vocab.decode(encoded)
print(f"デコード結果: {decoded}")
from collections import Counter
class SimpleTokenizer:
"""
簡単なトークナイザ:スペースと句読点で分割
"""
def __init__(self):
# 句読点マッピング
self.punctuation = str.maketrans('', '', '.,!?;:"\'-()[]{}')
def tokenize(self, text):
# 小文字に変換
text = text.lower()
# 句読点を除去
text = text.translate(self.punctuation)
# トークナイズ
tokens = text.split()
return tokens
class Vocabulary:
"""
語彙構築
"""
def __init__(self, min_freq=2, max_size=10000):
self.min_freq = min_freq
self.max_size = max_size
self.word2idx = {'<PAD>': 0, '<UNK>': 1}
self.idx2word = {0: '<PAD>', 1: '<UNK>'}
self.word_count = Counter()
def build_vocab(self, texts):
"""テキストリストから語彙を構築"""
tokenizer = SimpleTokenizer()
# 単語頻度を集計
for text in texts:
tokens = tokenizer.tokenize(text)
self.word_count.update(tokens)
# 語彙を構築
for word, count in self.word_count.most_common(self.max_size):
if count < self.min_freq:
break
if word not in self.word2idx:
idx = len(self.word2idx)
self.word2idx[word] = idx
self.idx2word[idx] = word
print(f"語彙サイズ: {len(self.word2idx)}")
def encode(self, text, max_len=50):
"""テキストをインデックス系列にエンコード"""
tokenizer = SimpleTokenizer()
tokens = tokenizer.tokenize(text)[:max_len]
# エンコード
indices = [
self.word2idx.get(token, self.word2idx['<UNK>'])
for token in tokens
]
# ゼロパディング
if len(indices) < max_len:
indices += [self.word2idx['<PAD>']] * (max_len - len(indices))
return indices
def decode(self, indices):
"""インデックス系列をテキストにデコード"""
tokens = [self.idx2word.get(idx, '<UNK>') for idx in indices]
return ' '.join(tokens)
# 使用例
texts = [
"Hello world",
"This is a test",
"PyTorch is great for deep learning",
"Natural language processing is fun",
"Deep learning enables many applications",
]
vocab = Vocabulary(min_freq=1, max_size=100)
vocab.build_vocab(texts)
# エンコード
encoded = vocab.encode("Hello deep learning world!", max_len=10)
print(f"エンコード結果: {encoded}")
# デコード
decoded = vocab.decode(encoded)
print(f"デコード結果: {decoded}")
2. torchtext (Legacy) の使用
torchtext がインストールされている場合は、legacy モジュールを使用してテキスト処理できます。
2.1 インストールとインポート
例
# torchtext をインストール
# pip install torchtext
# legacy モジュールをインポート
try:
import torchtext
from torchtext.legacy import data
from torchtext.legacy import datasets
print(f"torchtext バージョン: {torchtext.__version__}")
TORCHTEXT_AVAILABLE = True
except ImportError:
print("torchtext がインストールされていないため、カスタム実装を使用")
TORCHTEXT_AVAILABLE = False
# または新バージョンを試す
try:
from torchtext import transforms
from torchtext.datasets import AG_NEWS
print("新版 torchtext が利用可能")
except ImportError:
print("新版 torchtext が利用不可")
# pip install torchtext
# legacy モジュールをインポート
try:
import torchtext
from torchtext.legacy import data
from torchtext.legacy import datasets
print(f"torchtext バージョン: {torchtext.__version__}")
TORCHTEXT_AVAILABLE = True
except ImportError:
print("torchtext がインストールされていないため、カスタム実装を使用")
TORCHTEXT_AVAILABLE = False
# または新バージョンを試す
try:
from torchtext import transforms
from torchtext.datasets import AG_NEWS
print("新版 torchtext が利用可能")
except ImportError:
print("新版 torchtext が利用不可")
2.2 Field と Dataset
例
# torchtext.legacy を使用
from torchtext.legacy import data
from torchtext.legacy import datasets
from torchtext.legacy.data import Field, TabularDataset, BucketIterator
# フィールドを定義
TEXT = Field(
tokenize='spacy', # spacy でトークナイズ
tokenizer_language='en_core_web_sm',
lower=True, # 小文字に変換
include_lengths=True, # 系列の長さを返す
batch_first=True # batch 次元を先頭に
)
LABEL = Field(
sequential=False,
use_vocab=False,
dtype=torch.long
)
# データセットを定義
# CSV ファイル形式を仮定: label,text
# 1,This is a positive review
# 0,This is a negative review
# または組み込みデータセット(IMDB など)を使用
# train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
print("Field と Dataset の設定が完了しました")
from torchtext.legacy import data
from torchtext.legacy import datasets
from torchtext.legacy.data import Field, TabularDataset, BucketIterator
# フィールドを定義
TEXT = Field(
tokenize='spacy', # spacy でトークナイズ
tokenizer_language='en_core_web_sm',
lower=True, # 小文字に変換
include_lengths=True, # 系列の長さを返す
batch_first=True # batch 次元を先頭に
)
LABEL = Field(
sequential=False,
use_vocab=False,
dtype=torch.long
)
# データセットを定義
# CSV ファイル形式を仮定: label,text
# 1,This is a positive review
# 0,This is a negative review
# または組み込みデータセット(IMDB など)を使用
# train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
print("Field と Dataset の設定が完了しました")
2.3 語彙構築とイテレータ
例
# 語彙を構築
# TEXT.build_vocab(train_data, vectors="glove.6B.100d", max_size=10000)
# イテレータを作成
# train_iterator, test_iterator = BucketIterator.splits(
# (train_data, test_data),
# batch_size=32,
# sort_within_batch=True,
# device=torch.device('cuda')
# )
# 反復トレーニング
# for batch in train_iterator:
# text, lengths = batch.text
# labels = batch.label
# # トレーニングコード
print("語彙とイテレータの設定が完了しました")
# TEXT.build_vocab(train_data, vectors="glove.6B.100d", max_size=10000)
# イテレータを作成
# train_iterator, test_iterator = BucketIterator.splits(
# (train_data, test_data),
# batch_size=32,
# sort_within_batch=True,
# device=torch.device('cuda')
# )
# 反復トレーニング
# for batch in train_iterator:
# text, lengths = batch.text
# labels = batch.label
# # トレーニングコード
print("語彙とイテレータの設定が完了しました")
3. カスタムNLPデータパイプライン
torchtext に依存しない、より柔軟なカスタムデータ処理方法の使用を推奨します。
3.1 データセットクラスの実装
例
import torch
from torch.utils.data import Dataset, DataLoader
from collections import Counter
import re
class TextDataset(Dataset):
"""
テキストデータセット
"""
def __init__(self, texts, labels, vocab=None, max_len=128, min_freq=2):
self.texts = texts
self.labels = labels
self.max_len = max_len
# 既存の語彙を構築または使用
if vocab is None:
self.vocab = self._build_vocab(texts, min_freq)
else:
self.vocab = vocab
def _build_vocab(self, texts, min_freq):
"""語彙を構築"""
word_counts = Counter()
for text in texts:
tokens = self._tokenize(text)
word_counts.update(tokens)
# 語彙を作成
word2idx = {'<PAD>': 0, '<UNK>': 1}
for word, count in word_counts.items():
if count >= min_freq:
word2idx[word] = len(word2idx)
return word2idx
def _tokenize(self, text):
"""簡単なトークナイズ"""
# 小文字に変換
text = text.lower()
# 特殊文字を除去し、英数字とスペースを保持
text = re.sub(r'[^a-z0-9\s]', ' ', text)
# トークナイズ
tokens = text.split()
return tokens
def _encode(self, text):
"""テキストをエンコード"""
tokens = self._tokenize(text)[:self.max_len]
indices = [
self.vocab.get(token, self.vocab['<UNK>'])
for token in tokens
]
# ゼロパディング
if len(indices) < self.max_len:
indices += [self.vocab['<PAD>']] * (self.max_len - len(indices))
return indices
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
encoded = self._encode(text)
return torch.tensor(encoded, dtype=torch.long), torch.tensor(label, dtype=torch.long)
# 使用例
texts = [
"This is a great movie",
"I hated this film",
"Amazing performance",
"Terrible acting",
"Highly recommend",
]
labels = [1, 0, 1, 0, 1]
dataset = TextDataset(texts, labels, max_len=10)
print(f"データセットサイズ: {len(dataset)}")
print(f"語彙サイズ: {len(dataset.vocab)}")
# サンプルを取得
text, label = dataset[0]
print(f"テキストエンコード: {text[:5]}...")
print(f"ラベル: {label}")
from torch.utils.data import Dataset, DataLoader
from collections import Counter
import re
class TextDataset(Dataset):
"""
テキストデータセット
"""
def __init__(self, texts, labels, vocab=None, max_len=128, min_freq=2):
self.texts = texts
self.labels = labels
self.max_len = max_len
# 既存の語彙を構築または使用
if vocab is None:
self.vocab = self._build_vocab(texts, min_freq)
else:
self.vocab = vocab
def _build_vocab(self, texts, min_freq):
"""語彙を構築"""
word_counts = Counter()
for text in texts:
tokens = self._tokenize(text)
word_counts.update(tokens)
# 語彙を作成
word2idx = {'<PAD>': 0, '<UNK>': 1}
for word, count in word_counts.items():
if count >= min_freq:
word2idx[word] = len(word2idx)
return word2idx
def _tokenize(self, text):
"""簡単なトークナイズ"""
# 小文字に変換
text = text.lower()
# 特殊文字を除去し、英数字とスペースを保持
text = re.sub(r'[^a-z0-9\s]', ' ', text)
# トークナイズ
tokens = text.split()
return tokens
def _encode(self, text):
"""テキストをエンコード"""
tokens = self._tokenize(text)[:self.max_len]
indices = [
self.vocab.get(token, self.vocab['<UNK>'])
for token in tokens
]
# ゼロパディング
if len(indices) < self.max_len:
indices += [self.vocab['<PAD>']] * (self.max_len - len(indices))
return indices
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
encoded = self._encode(text)
return torch.tensor(encoded, dtype=torch.long), torch.tensor(label, dtype=torch.long)
# 使用例
texts = [
"This is a great movie",
"I hated this film",
"Amazing performance",
"Terrible acting",
"Highly recommend",
]
labels = [1, 0, 1, 0, 1]
dataset = TextDataset(texts, labels, max_len=10)
print(f"データセットサイズ: {len(dataset)}")
print(f"語彙サイズ: {len(dataset.vocab)}")
# サンプルを取得
text, label = dataset[0]
print(f"テキストエンコード: {text[:5]}...")
print(f"ラベル: {label}")
3.2 高度なトークナイザ
例
# spacy を使用した高度なトークナイズ
def tokenize_with_spacy(text):
"""spacy を使用してトークナイズ"""
try:
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp(text)
return [token.text for token in doc]
except ImportError:
print("spacy がインストールされていないため、簡単なトークナイズを使用")
return text.lower().split()
# nltk を使用したトークナイズとステミング
def tokenize_with_nltk(text):
"""nltk を使用してトークナイズ"""
try:
import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
# トークナイズ
tokens = word_tokenize(text.lower())
# オプション:ステミング
stemmer = PorterStemmer()
tokens = [stemmer.stem(token) for token in tokens if token.isalnum()]
return tokens
except ImportError:
return text.lower().split()
# SentencePiece を使用したサブワードトークナイズ
class SentencePieceTokenizer:
"""
SentencePiece を使用したサブワードトークナイズ
"""
def __init__(self, model_path=None):
self.model_path = model_path
self.sp = None
def train(self, texts, vocab_size=10000):
"""SentencePiece モデルをトレーニング"""
try:
import sentencepiece as spm
import tempfile
# 一時ファイルに書き込み
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
for text in texts:
f.write(text + '\n')
temp_file = f.name
# トレーニング
spm.SentencePieceTrainer.train(
input=temp_file,
model_prefix='spm_model',
vocab_size=vocab_size,
character_coverage=1.0,
model_type='unigram',
)
self.sp = spm.SentencePieceProcessor()
self.sp.load('spm_model.model')
except ImportError:
print("sentencepiece がインストールされていません")
def encode(self, text):
if self.sp:
return self.sp.encode(text, out_type=str)
return text.split()
def decode(self, ids):
if self.sp:
return self.sp.decode(ids)
return ' '.join(ids)
def tokenize_with_spacy(text):
"""spacy を使用してトークナイズ"""
try:
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp(text)
return [token.text for token in doc]
except ImportError:
print("spacy がインストールされていないため、簡単なトークナイズを使用")
return text.lower().split()
# nltk を使用したトークナイズとステミング
def tokenize_with_nltk(text):
"""nltk を使用してトークナイズ"""
try:
import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
# トークナイズ
tokens = word_tokenize(text.lower())
# オプション:ステミング
stemmer = PorterStemmer()
tokens = [stemmer.stem(token) for token in tokens if token.isalnum()]
return tokens
except ImportError:
return text.lower().split()
# SentencePiece を使用したサブワードトークナイズ
class SentencePieceTokenizer:
"""
SentencePiece を使用したサブワードトークナイズ
"""
def __init__(self, model_path=None):
self.model_path = model_path
self.sp = None
def train(self, texts, vocab_size=10000):
"""SentencePiece モデルをトレーニング"""
try:
import sentencepiece as spm
import tempfile
# 一時ファイルに書き込み
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
for text in texts:
f.write(text + '\n')
temp_file = f.name
# トレーニング
spm.SentencePieceTrainer.train(
input=temp_file,
model_prefix='spm_model',
vocab_size=vocab_size,
character_coverage=1.0,
model_type='unigram',
)
self.sp = spm.SentencePieceProcessor()
self.sp.load('spm_model.model')
except ImportError:
print("sentencepiece がインストールされていません")
def encode(self, text):
if self.sp:
return self.sp.encode(text, out_type=str)
return text.split()
def decode(self, ids):
if self.sp:
return self.sp.decode(ids)
return ' '.join(ids)
3.3 完全なデータローダ
例
import torch
from torch.utils.data import Dataset, DataLoader
from collections import Counter
class NLPDataset(Dataset):
"""
完全な NLP データセットクラス
可変長系列、語彙構築、バッチパディングをサポート
"""
def __init__(self, texts, labels, min_freq=2, max_vocab=30000):
self.texts = texts
self.labels = labels
self.min_freq = min_freq
# 語彙を構築
self.word2idx, self.idx2word = self._build_vocab(texts, max_vocab)
self.pad_idx = self.word2idx['<PAD>']
self.unk_idx = self.word2idx['<UNK>']
def _tokenize(self, text):
text = text.lower()
text = re.sub(r'[^a-z0-9\s]', ' ', text)
return text.split()
def _build_vocab(self, texts, max_vocab):
"""語彙を構築"""
counter = Counter()
for text in texts:
tokens = self._tokenize(text)
counter.update(tokens)
# 語彙を構築
word2idx = {'<PAD>': 0, '<UNK>': 1}
idx2word = {0: '<PAD>', 1: '<UNK>'}
for word, count in counter.most_common(max_vocab):
if count >= self.min_freq and word not in word2idx:
idx = len(word2idx)
word2idx[word] = idx
idx2word[idx] = word
return word2idx, idx2word
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
tokens = self._tokenize(text)
indices = [self.word2idx.get(t, self.unk_idx) for t in tokens]
return {
'input': indices,
'label': self.labels[idx],
'length': len(indices)
}
def collate_fn(batch, pad_idx=0):
"""
カスタム collate 関数:可変長系列を処理
"""
# 長さの降順でソート
batch.sort(key=lambda x: x['length'], reverse=True)
texts = [item['input'] for item in batch]
labels = [item['label'] for item in batch]
lengths = [item['length'] for item in batch]
# 同じ長さにパディング
max_len = max(lengths)
padded = [text + [pad_idx] * (max_len - len(text)) for text in texts]
return {
'input': torch.tensor(padded, dtype=torch.long),
'labels': torch.tensor(labels, dtype=torch.long),
'lengths': torch.tensor(lengths, dtype=torch.long)
}
# DataLoader を使用
def create_dataloader(texts, labels, batch_size=32, shuffle=True):
"""データローダを作成"""
dataset = NLPDataset(texts, labels)
pad_idx = dataset.pad_idx
dataloader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=shuffle,
collate_fn=lambda b: collate_fn(b, pad_idx)
)
return dataloader, dataset
# 模擬データ
texts = [
"I love this movie",
"This is a bad movie",
"Great film",
"Terrible acting",
"I recommend this",
"Not worth watching",
]
labels = [1, 0, 1, 0, 1, 0]
dataloader, dataset = create_dataloader(texts, labels, batch_size=2)
for batch in dataloader:
print("Input shape:", batch['input'].shape)
print("Labels:", batch['labels'])
print("Lengths:", batch['lengths'])
print("---")
from torch.utils.data import Dataset, DataLoader
from collections import Counter
class NLPDataset(Dataset):
"""
完全な NLP データセットクラス
可変長系列、語彙構築、バッチパディングをサポート
"""
def __init__(self, texts, labels, min_freq=2, max_vocab=30000):
self.texts = texts
self.labels = labels
self.min_freq = min_freq
# 語彙を構築
self.word2idx, self.idx2word = self._build_vocab(texts, max_vocab)
self.pad_idx = self.word2idx['<PAD>']
self.unk_idx = self.word2idx['<UNK>']
def _tokenize(self, text):
text = text.lower()
text = re.sub(r'[^a-z0-9\s]', ' ', text)
return text.split()
def _build_vocab(self, texts, max_vocab):
"""語彙を構築"""
counter = Counter()
for text in texts:
tokens = self._tokenize(text)
counter.update(tokens)
# 語彙を構築
word2idx = {'<PAD>': 0, '<UNK>': 1}
idx2word = {0: '<PAD>', 1: '<UNK>'}
for word, count in counter.most_common(max_vocab):
if count >= self.min_freq and word not in word2idx:
idx = len(word2idx)
word2idx[word] = idx
idx2word[idx] = word
return word2idx, idx2word
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
tokens = self._tokenize(text)
indices = [self.word2idx.get(t, self.unk_idx) for t in tokens]
return {
'input': indices,
'label': self.labels[idx],
'length': len(indices)
}
def collate_fn(batch, pad_idx=0):
"""
カスタム collate 関数:可変長系列を処理
"""
# 長さの降順でソート
batch.sort(key=lambda x: x['length'], reverse=True)
texts = [item['input'] for item in batch]
labels = [item['label'] for item in batch]
lengths = [item['length'] for item in batch]
# 同じ長さにパディング
max_len = max(lengths)
padded = [text + [pad_idx] * (max_len - len(text)) for text in texts]
return {
'input': torch.tensor(padded, dtype=torch.long),
'labels': torch.tensor(labels, dtype=torch.long),
'lengths': torch.tensor(lengths, dtype=torch.long)
}
# DataLoader を使用
def create_dataloader(texts, labels, batch_size=32, shuffle=True):
"""データローダを作成"""
dataset = NLPDataset(texts, labels)
pad_idx = dataset.pad_idx
dataloader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=shuffle,
collate_fn=lambda b: collate_fn(b, pad_idx)
)
return dataloader, dataset
# 模擬データ
texts = [
"I love this movie",
"This is a bad movie",
"Great film",
"Terrible acting",
"I recommend this",
"Not worth watching",
]
labels = [1, 0, 1, 0, 1, 0]
dataloader, dataset = create_dataloader(texts, labels, batch_size=2)
for batch in dataloader:
print("Input shape:", batch['input'].shape)
print("Labels:", batch['labels'])
print("Lengths:", batch['lengths'])
print("---")
4. 事前学習済み単語ベクトルの読み込み
事前学習済み単語ベクトルを使用すると、モデルの性能を向上できます。
4.1 GloVe 単語ベクトル
例
import torch
import numpy as np
def load_glove_vectors(filepath, word2idx, embedding_dim=300):
"""
GloVe 事前学習済み単語ベクトルの読み込み
パラメータ:
filepath: GloVe ファイルパス
word2idx: 語彙辞書
embedding_dim: 単語ベクトルの次元
"""
print("GloVe 単語ベクトルを読み込み中...")
# 埋め込み行列を初期化
num_words = len(word2idx)
embeddings = np.random.randn(num_words, embedding_dim).astype(np.float32)
embeddings[word2idx['<PAD>']] = np.zeros(embedding_dim) # PAD ベクトルをゼロに設定
words_loaded = 0
with open(filepath, 'r', encoding='utf-8') as f:
for line in f:
values = line.strip().split()
word = values[0]
if word in word2idx:
idx = word2idx[word]
vector = np.asarray(values[1:], dtype=np.float32)
if len(vector) == embedding_dim:
embeddings[idx] = vector
words_loaded += 1
print(f"{words_loaded}/{num_words} 個の単語ベクトルを読み込みました")
return torch.from_numpy(embeddings)
# 模擬読み込み
def create_pretrained_embedding(word2idx, embedding_dim=300, pretrained_path=None):
"""
事前学習済み埋め込み層の作成
"""
if pretrained_path and False: # True に設定し、有効なパスを指定
weights = load_glove_vectors(pretrained_path, word2idx, embedding_dim)
else:
# ランダム初期化を使用
num_words = len(word2idx)
weights = torch.randn(num_words, embedding_dim) * 0.1
embedding = torch.nn.Embedding.from_pretrained(weights, padding_idx=0)
return embedding
# 例
word2idx = {'<PAD>': 0, '<UNK>': 1, 'hello': 2, 'world': 3, 'test': 4}
embedding = create_pretrained_embedding(word2idx, embedding_dim=100)
print(f"埋め込み層の形状: {embedding.weight.shape}")
import numpy as np
def load_glove_vectors(filepath, word2idx, embedding_dim=300):
"""
GloVe 事前学習済み単語ベクトルの読み込み
パラメータ:
filepath: GloVe ファイルパス
word2idx: 語彙辞書
embedding_dim: 単語ベクトルの次元
"""
print("GloVe 単語ベクトルを読み込み中...")
# 埋め込み行列を初期化
num_words = len(word2idx)
embeddings = np.random.randn(num_words, embedding_dim).astype(np.float32)
embeddings[word2idx['<PAD>']] = np.zeros(embedding_dim) # PAD ベクトルをゼロに設定
words_loaded = 0
with open(filepath, 'r', encoding='utf-8') as f:
for line in f:
values = line.strip().split()
word = values[0]
if word in word2idx:
idx = word2idx[word]
vector = np.asarray(values[1:], dtype=np.float32)
if len(vector) == embedding_dim:
embeddings[idx] = vector
words_loaded += 1
print(f"{words_loaded}/{num_words} 個の単語ベクトルを読み込みました")
return torch.from_numpy(embeddings)
# 模擬読み込み
def create_pretrained_embedding(word2idx, embedding_dim=300, pretrained_path=None):
"""
事前学習済み埋め込み層の作成
"""
if pretrained_path and False: # True に設定し、有効なパスを指定
weights = load_glove_vectors(pretrained_path, word2idx, embedding_dim)
else:
# ランダム初期化を使用
num_words = len(word2idx)
weights = torch.randn(num_words, embedding_dim) * 0.1
embedding = torch.nn.Embedding.from_pretrained(weights, padding_idx=0)
return embedding
# 例
word2idx = {'<PAD>': 0, '<UNK>': 1, 'hello': 2, 'world': 3, 'test': 4}
embedding = create_pretrained_embedding(word2idx, embedding_dim=100)
print(f"埋め込み層の形状: {embedding.weight.shape}")
4.2 gensim を使用した Word2Vec の読み込み
例
def load_word2vec(word2idx, model_path=None):
"""
gensimを使用してWord2Vecを読み込む
"""
try:
from gensim.models import KeyedVectors
# モデルを読み込む
# model = KeyedVectors.load_word2vec_format(model_path, binary=True)
# 埋め込み行列を作成する
embedding_dim = 300
num_words = len(word2idx)
embeddings = np.random.randn(num_words, embedding_dim).astype(np.float32)
# 単語ベクトルを埋める
embeddings[word2idx['<PAD>']] = np.zeros(embedding_dim)
# 単語ベクトルを読み込む
# for word, idx in word2idx.items():
# if word in model:
# embeddings[idx] = model[word]
return torch.from_numpy(embeddings)
except ImportError:
print("gensimがインストールされていません")
return None
"""
gensimを使用してWord2Vecを読み込む
"""
try:
from gensim.models import KeyedVectors
# モデルを読み込む
# model = KeyedVectors.load_word2vec_format(model_path, binary=True)
# 埋め込み行列を作成する
embedding_dim = 300
num_words = len(word2idx)
embeddings = np.random.randn(num_words, embedding_dim).astype(np.float32)
# 単語ベクトルを埋める
embeddings[word2idx['<PAD>']] = np.zeros(embedding_dim)
# 単語ベクトルを読み込む
# for word, idx in word2idx.items():
# if word in model:
# embeddings[idx] = model[word]
return torch.from_numpy(embeddings)
except ImportError:
print("gensimがインストールされていません")
return None
4.3 カスタム事前学習済み埋め込み
例
import torch
import torch.nn as nn
class PretrainedEmbedding(nn.Module):
"""
事前学習済み単語ベクトルを読み込める埋め込み層
"""
def __init__(self, vocab_size, embed_dim, pretrained_weights=None,
padding_idx=0, freeze=False):
super().__init__()
self.embedding = nn.Embedding(
vocab_size,
embed_dim,
padding_idx=padding_idx
)
# 事前学習済みの重みを読み込む
if pretrained_weights is not None:
self.embedding.weight.data.copy_(pretrained_weights)
# 凍結するかどうか
if freeze:
self.embedding.weight.requires_grad = False
def forward(self, x):
return self.embedding(x)
# 使用例
vocab_size = 10000
embed_dim = 300
pretrained = torch.randn(vocab_size, embed_dim) * 0.1
embedding_layer = PretrainedEmbedding(
vocab_size,
embed_dim,
pretrained_weights=pretrained,
padding_idx=0,
freeze=False # Trueに設定して埋め込み層を凍結する
)
# テスト
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
output = embedding_layer(x)
print(f"入力形状: {x.shape}")
print(f"出力形状: {output.shape}")
import torch.nn as nn
class PretrainedEmbedding(nn.Module):
"""
事前学習済み単語ベクトルを読み込める埋め込み層
"""
def __init__(self, vocab_size, embed_dim, pretrained_weights=None,
padding_idx=0, freeze=False):
super().__init__()
self.embedding = nn.Embedding(
vocab_size,
embed_dim,
padding_idx=padding_idx
)
# 事前学習済みの重みを読み込む
if pretrained_weights is not None:
self.embedding.weight.data.copy_(pretrained_weights)
# 凍結するかどうか
if freeze:
self.embedding.weight.requires_grad = False
def forward(self, x):
return self.embedding(x)
# 使用例
vocab_size = 10000
embed_dim = 300
pretrained = torch.randn(vocab_size, embed_dim) * 0.1
embedding_layer = PretrainedEmbedding(
vocab_size,
embed_dim,
pretrained_weights=pretrained,
padding_idx=0,
freeze=False # Trueに設定して埋め込み層を凍結する
)
# テスト
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
output = embedding_layer(x)
print(f"入力形状: {x.shape}")
print(f"出力形状: {output.shape}")
5. テキストデータ拡張
データ拡張はモデルの汎化能力を向上させることができます。
5.1 バックトランスレーション拡張
例
# 逆翻訳拡張には翻訳APIが必要です。以下は概念的な例です
def back_translation_augment(text, translator):
"""
逆翻訳拡張:テキストを別の言語に翻訳してから、さらに元の言語に翻訳し直す
"""
# ターゲット言語に翻訳する
translated = translator.translate(text, dest='fr')
# ソース言語に翻訳し直す
back_translated = translator.translate(translated.text, dest='en')
return back_translated.text
# 使用例
# from googletrans import Translator
# translator = Translator()
# augmented_text = back_translation_augment("I love this movie", translator)
def back_translation_augment(text, translator):
"""
逆翻訳拡張:テキストを別の言語に翻訳してから、さらに元の言語に翻訳し直す
"""
# ターゲット言語に翻訳する
translated = translator.translate(text, dest='fr')
# ソース言語に翻訳し直す
back_translated = translator.translate(translated.text, dest='en')
return back_translated.text
# 使用例
# from googletrans import Translator
# translator = Translator()
# augmented_text = back_translation_augment("I love this movie", translator)
5.2 類義語置換
例
import random
def synonym_replacement(text, n=1, stop_words=None):
"""
同義語置換
"""
if stop_words is None:
stop_words = {'a', 'an', 'the', 'is', 'are', 'was', 'were'}
words = text.lower().split()
replaceable = [i for i, w in enumerate(words) if w not in stop_words]
if not replaceable:
return text
n = min(n, len(replaceable))
replace_idx = random.sample(replaceable, n)
# 簡略化した同義語マッピング(実際にはWordNetを使用すべき)
synonym_map = {
'good': ['great', 'excellent', 'nice'],
'bad': ['poor', 'terrible', 'awful'],
'movie': ['film', 'cinema'],
'loved': ['adored', 'enjoyed'],
}
for idx in replace_idx:
word = words[idx]
if word in synonym_map:
words[idx] = random.choice(synonym_map[word])
return ' '.join(words)
# 使用例
text = "I loved this good movie"
augmented = synonym_replacement(text, n=2)
print(f"元の文: {text}")
print(f"拡張: {augmented}")
def synonym_replacement(text, n=1, stop_words=None):
"""
同義語置換
"""
if stop_words is None:
stop_words = {'a', 'an', 'the', 'is', 'are', 'was', 'were'}
words = text.lower().split()
replaceable = [i for i, w in enumerate(words) if w not in stop_words]
if not replaceable:
return text
n = min(n, len(replaceable))
replace_idx = random.sample(replaceable, n)
# 簡略化した同義語マッピング(実際にはWordNetを使用すべき)
synonym_map = {
'good': ['great', 'excellent', 'nice'],
'bad': ['poor', 'terrible', 'awful'],
'movie': ['film', 'cinema'],
'loved': ['adored', 'enjoyed'],
}
for idx in replace_idx:
word = words[idx]
if word in synonym_map:
words[idx] = random.choice(synonym_map[word])
return ' '.join(words)
# 使用例
text = "I loved this good movie"
augmented = synonym_replacement(text, n=2)
print(f"元の文: {text}")
print(f"拡張: {augmented}")
5.3 ランダム挿入と削除
例
import random
def random_insertion(text, n=1):
"""
ランダム挿入:テキスト内にランダムに単語を挿入する
"""
words = text.lower().split()
for _ in range(n):
if len(words) > 1:
idx = random.randint(0, len(words) - 1)
# 簡略化した挿入用の単語
insert_words = ['really', 'very', 'quite', 'actually']
words.insert(idx, random.choice(insert_words))
return ' '.join(words)
def random_deletion(text, p=0.1):
"""
ランダム削除:確率pで単語を削除する
"""
words = text.lower().split()
if len(words) == 1:
return text
remaining = [w for w in words if random.random() > p]
if len(remaining) == 0:
return random.choice(words)
return ' '.join(remaining)
def random_swap(text, n=1):
"""
ランダム交換:ランダムに2つの単語の位置を入れ替える
"""
words = text.lower().split()
if len(words) < 2:
return text
for _ in range(n):
idx1, idx2 = random.sample(range(len(words)), 2)
words[idx1], words[idx2] = words[idx2], words[idx1]
return ' '.join(words)
# 使用例
text = "This is a great movie about love and happiness"
print("元のテキスト:", text)
print("挿入:", random_insertion(text, n=2))
print("削除:", random_deletion(text, p=0.2))
print("交換:", random_swap(text, n=2))
def random_insertion(text, n=1):
"""
ランダム挿入:テキスト内にランダムに単語を挿入する
"""
words = text.lower().split()
for _ in range(n):
if len(words) > 1:
idx = random.randint(0, len(words) - 1)
# 簡略化した挿入用の単語
insert_words = ['really', 'very', 'quite', 'actually']
words.insert(idx, random.choice(insert_words))
return ' '.join(words)
def random_deletion(text, p=0.1):
"""
ランダム削除:確率pで単語を削除する
"""
words = text.lower().split()
if len(words) == 1:
return text
remaining = [w for w in words if random.random() > p]
if len(remaining) == 0:
return random.choice(words)
return ' '.join(remaining)
def random_swap(text, n=1):
"""
ランダム交換:ランダムに2つの単語の位置を入れ替える
"""
words = text.lower().split()
if len(words) < 2:
return text
for _ in range(n):
idx1, idx2 = random.sample(range(len(words)), 2)
words[idx1], words[idx2] = words[idx2], words[idx1]
return ' '.join(words)
# 使用例
text = "This is a great movie about love and happiness"
print("元のテキスト:", text)
print("挿入:", random_insertion(text, n=2))
print("削除:", random_deletion(text, p=0.2))
print("交換:", random_swap(text, n=2))
6. 一般的なNLPタスクの例
6.1 テキスト分類の完全なフロー
例
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
# 1. データ準備
texts = [
"I love this product, it is amazing!",
"Terrible quality, waste of money.",
"Great value for the price.",
"Not satisfied with the purchase.",
"Best purchase I have ever made!",
"Very disappointed with this item.",
]
labels = [1, 0, 1, 0, 1, 0] # 1: ポジティブ, 0: ネガティブ
# 2. データセット
class TextClassificationDataset(Dataset):
def __init__(self, texts, labels, max_len=50):
self.texts = texts
self.labels = labels
self.max_len = max_len
self.vocab = self._build_vocab(texts)
def _build_vocab(self, texts):
vocab = {'<PAD>': 0, '<UNK>': 1}
for text in texts:
for word in text.lower().split():
if word not in vocab:
vocab[word] = len(vocab)
return vocab
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
# シンプルなエンコーディング
tokens = text.lower().split()[:self.max_len]
indices = [self.vocab.get(t, 1) for t in tokens]
# パディング
if len(indices) < self.max_len:
indices += [0] * (self.max_len - len(indices))
return torch.tensor(indices, dtype=torch.long), torch.tensor(label, dtype=torch.long)
# 3. モデル
class TextClassifier(nn.Module):
def __init__(self, vocab_size, embed_dim=128, hidden_dim=64, num_classes=2):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
self.fc = nn.Linear(hidden_dim, num_classes)
def forward(self, x):
embedded = self.embedding(x)
_, (hidden, _) = self.lstm(embedded)
output = self.fc(hidden.squeeze(0))
return output
# 4. トレーニング
dataset = TextClassificationDataset(texts, labels)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
model = TextClassifier(vocab_size=len(dataset.vocab))
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 数エポック学習する
model.train()
for epoch in range(10):
total_loss = 0
for texts_batch, labels_batch in dataloader:
optimizer.zero_grad()
outputs = model(texts_batch)
loss = criterion(outputs, labels_batch)
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f}")
print(トレーニング完了!)
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
# 1. データ準備
texts = [
"I love this product, it is amazing!",
"Terrible quality, waste of money.",
"Great value for the price.",
"Not satisfied with the purchase.",
"Best purchase I have ever made!",
"Very disappointed with this item.",
]
labels = [1, 0, 1, 0, 1, 0] # 1: ポジティブ, 0: ネガティブ
# 2. データセット
class TextClassificationDataset(Dataset):
def __init__(self, texts, labels, max_len=50):
self.texts = texts
self.labels = labels
self.max_len = max_len
self.vocab = self._build_vocab(texts)
def _build_vocab(self, texts):
vocab = {'<PAD>': 0, '<UNK>': 1}
for text in texts:
for word in text.lower().split():
if word not in vocab:
vocab[word] = len(vocab)
return vocab
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
# シンプルなエンコーディング
tokens = text.lower().split()[:self.max_len]
indices = [self.vocab.get(t, 1) for t in tokens]
# パディング
if len(indices) < self.max_len:
indices += [0] * (self.max_len - len(indices))
return torch.tensor(indices, dtype=torch.long), torch.tensor(label, dtype=torch.long)
# 3. モデル
class TextClassifier(nn.Module):
def __init__(self, vocab_size, embed_dim=128, hidden_dim=64, num_classes=2):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
self.fc = nn.Linear(hidden_dim, num_classes)
def forward(self, x):
embedded = self.embedding(x)
_, (hidden, _) = self.lstm(embedded)
output = self.fc(hidden.squeeze(0))
return output
# 4. トレーニング
dataset = TextClassificationDataset(texts, labels)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
model = TextClassifier(vocab_size=len(dataset.vocab))
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 数エポック学習する
model.train()
for epoch in range(10):
total_loss = 0
for texts_batch, labels_batch in dataloader:
optimizer.zero_grad()
outputs = model(texts_batch)
loss = criterion(outputs, labels_batch)
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f}")
print(トレーニング完了!)
6.2 系列ラベリング(NER)の例
例
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
# 系列ラベリング用データセット
class NERDataset(Dataset):
"""
固有表現認識データセット
形式: [(word, tag), ...]
"""
def __init__(self, sentences_tags, word2idx, tag2idx, max_len=50):
self.sentences_tags = sentences_tags
self.word2idx = word2idx
self.tag2idx = tag2idx
self.max_len = max_len
def __len__(self):
return len(self.sentences_tags)
def __getitem__(self, idx):
sentence_tags = self.sentences_tags[idx]
words = [wt[0] for wt in sentence_tags]
tags = [wt[1] for wt in sentence_tags]
# エンコーディング
word_ids = [self.word2idx.get(w.lower(), 1) for w in words[:self.max_len]]
tag_ids = [self.tag2idx[t] for t in tags[:self.max_len]]
# パディング
if len(word_ids) < self.max_len:
word_ids += [0] * (self.max_len - len(word_ids))
tag_ids += [0] * (self.max_len - len(tag_ids))
return {
'words': torch.tensor(word_ids, dtype=torch.long),
'tags': torch.tensor(tag_ids, dtype=torch.long)
}
# NERモデル
class NERModel(nn.Module):
def __init__(self, vocab_size, tag_size, embed_dim=128, hidden_dim=256):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
self.fc = nn.Linear(hidden_dim * 2, tag_size)
def forward(self, x):
embedded = self.embedding(x)
lstm_out, _ = self.lstm(embedded)
logits = self.fc(lstm_out)
return logits
# サンプルデータ
data = [
[("John", "B-PER"), ("lives", "O"), ("in", "O"), ("New", "B-LOC"), ("York", "I-LOC"), (".", "O")],
[("Apple", "B-ORG"), ("is", "O"), ("a", "O"), ("company", "O"), (".", "O")],
]
# 語彙表とラベル表を構築する
word2idx = {'<PAD>': 0, '<UNK>': 1}
tag2idx = {'O': 0, 'B-PER': 1, 'I-PER': 2, 'B-LOC': 3, 'I-LOC': 4, 'B-ORG': 5, 'I-ORG': 6}
for sent in data:
for word, tag in sent:
if word.lower() not in word2idx:
word2idx[word.lower()] = len(word2idx)
print(f"語彙サイズ: {len(word2idx)}")
print(f"ラベル数: {len(tag2idx)}")
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
# 系列ラベリング用データセット
class NERDataset(Dataset):
"""
固有表現認識データセット
形式: [(word, tag), ...]
"""
def __init__(self, sentences_tags, word2idx, tag2idx, max_len=50):
self.sentences_tags = sentences_tags
self.word2idx = word2idx
self.tag2idx = tag2idx
self.max_len = max_len
def __len__(self):
return len(self.sentences_tags)
def __getitem__(self, idx):
sentence_tags = self.sentences_tags[idx]
words = [wt[0] for wt in sentence_tags]
tags = [wt[1] for wt in sentence_tags]
# エンコーディング
word_ids = [self.word2idx.get(w.lower(), 1) for w in words[:self.max_len]]
tag_ids = [self.tag2idx[t] for t in tags[:self.max_len]]
# パディング
if len(word_ids) < self.max_len:
word_ids += [0] * (self.max_len - len(word_ids))
tag_ids += [0] * (self.max_len - len(tag_ids))
return {
'words': torch.tensor(word_ids, dtype=torch.long),
'tags': torch.tensor(tag_ids, dtype=torch.long)
}
# NERモデル
class NERModel(nn.Module):
def __init__(self, vocab_size, tag_size, embed_dim=128, hidden_dim=256):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
self.fc = nn.Linear(hidden_dim * 2, tag_size)
def forward(self, x):
embedded = self.embedding(x)
lstm_out, _ = self.lstm(embedded)
logits = self.fc(lstm_out)
return logits
# サンプルデータ
data = [
[("John", "B-PER"), ("lives", "O"), ("in", "O"), ("New", "B-LOC"), ("York", "I-LOC"), (".", "O")],
[("Apple", "B-ORG"), ("is", "O"), ("a", "O"), ("company", "O"), (".", "O")],
]
# 語彙表とラベル表を構築する
word2idx = {'<PAD>': 0, '<UNK>': 1}
tag2idx = {'O': 0, 'B-PER': 1, 'I-PER': 2, 'B-LOC': 3, 'I-LOC': 4, 'B-ORG': 5, 'I-ORG': 6}
for sent in data:
for word, tag in sent:
if word.lower() not in word2idx:
word2idx[word.lower()] = len(word2idx)
print(f"語彙サイズ: {len(word2idx)}")
print(f"ラベル数: {len(tag2idx)}")
7. 代替案の推奨
7.1 他のテキスト処理ライブラリ
| ライブラリ名 | 特徴 | 適用シーン |
|---|---|---|
| HuggingFace Datasets | データの読み込みと処理 | 一般的なNLPタスク |
| spacy | 高度なNLPツール | トークン化、NER、依存関係解析 |
| NLTK | 古典的なNLPツール | 教育、プロトタイプ開発 |
| textblob | シンプルで使いやすい | 高速なテキスト処理 |
7.2 HuggingFace Datasets の使用
例
# HuggingFace Datasetsライブラリを使用する
# pip install datasets
from datasets import load_dataset
# データセットを読み込む
# dataset = load_dataset("imdb")
# dataset = load_dataset("squad")
# データの前処理
# def preprocess_function(examples):
# return tokenizer(examples['text'], truncation=True, padding='max_length')
# tokenized_dataset = dataset.map(preprocess_function, batched=True)
print("HuggingFace Datasets使用例:")
print("from datasets import load_dataset")
print("dataset = load_dataset('imdb')")
# pip install datasets
from datasets import load_dataset
# データセットを読み込む
# dataset = load_dataset("imdb")
# dataset = load_dataset("squad")
# データの前処理
# def preprocess_function(examples):
# return tokenizer(examples['text'], truncation=True, padding='max_length')
# tokenized_dataset = dataset.map(preprocess_function, batched=True)
print("HuggingFace Datasets使用例:")
print("from datasets import load_dataset")
print("dataset = load_dataset('imdb')")
8. API クイックリファレンス
8.1 テキスト処理の一般的な操作
| 操作 | 方法 |
|---|---|
| トークン化 | text.split(), spacy, nltk, jieba |
| 語彙表の構築 | Counter, vocab.build_vocab() |
| エンコーディング | vocab.encode(), tokenizer.encode() |
| デコーディング | vocab.decode(), tokenizer.decode() |
| パディング | pad_sequence, collate_fn |
| 単語ベクトルの読み込み | Gensim、GloVeで直接読み込む |
8.2 データ拡張の方法
| 方法 | 説明 |
|---|---|
| 同義語置換 | 単語をランダムに同義語へ置換する |
| ランダム挿入 | 単語をランダムに挿入する |
| ランダム削除 | 単語をランダムに削除する |
| ランダム交換 | 単語の位置をランダムに入れ替える |
| 逆翻訳 | 翻訳してからもう一度翻訳し直す |
8.3 推奨されるデータ処理フロー
1. 数据清洗 - 去除 HTML 标签、特殊字符 - 统一编码、大小写 2. 分词 - 英文: spaCy / NLTK - 中文: jieba / pkuseg 3. 词表构建 - 过滤低频词 - 设定最大词表大小 4. 序列化 - 编码为索引 - 统一长度(填充/截断) 5. 数据增强(可选) - 同义词替换、回译 6. 批量加载 - DataLoader + 自定义 collate_fnその他の拡張