Apakah kaedah menggunakan model BERT untuk klasifikasi sentimen?

BERT ialah teknologi untuk pemprosesan bahasa semula jadi, yang boleh digunakan secara meluas dalam pelbagai tugas, termasuk klasifikasi sentimen. Klasifikasi sentimen ialah bentuk khas klasifikasi teks di mana matlamatnya adalah untuk menentukan sentimen yang dinyatakan oleh teks, seperti positif, negatif atau neutral. Model BERT adalah berdasarkan seni bina Transformer dan menggunakan sejumlah besar data teks tidak berlabel untuk pra-latihan untuk meningkatkan prestasi model. Melalui pra-latihan, BERT boleh mempelajari pengetahuan bahasa yang kaya, termasuk perbendaharaan kata, sintaksis dan semantik, dsb., membolehkan model mencapai prestasi yang baik dalam pelbagai tugas. Oleh itu, BERT telah menjadi alat penting dalam bidang pemprosesan bahasa semula jadi, memberikan sokongan yang kuat untuk tugas seperti klasifikasi sentimen.

Proses pra-latihan model BERT boleh dibahagikan kepada dua peringkat: Model Bahasa Bertopeng dan Ramalan Ayat Seterusnya. Dalam peringkat Model Bahasa Bertopeng, model BERT secara rawak memilih beberapa perkataan daripada teks input dan menggantikannya dengan tag [MASK] khas. Matlamat model adalah untuk meramalkan perkataan yang dikaburkan ini. Melalui proses ini, model BERT boleh mempelajari hubungan kontekstual antara perkataan untuk lebih memahami dan menjana teks. Dalam peringkat Ramalan Ayat Seterusnya, model BERT menerima dua ayat sebagai input, dan matlamatnya adalah untuk menentukan sama ada kedua-dua ayat itu berkaitan secara semantik antara satu sama lain. Melalui tugasan ini, model BERT dapat mempelajari perkaitan antara ayat untuk lebih memahami semantik dan konteks ayat tersebut. Melalui dua peringkat pra-latihan ini, model BERT boleh memperoleh maklumat semantik dan kontekstual yang kaya. Ini menjadikan model BERT berprestasi baik dalam pelbagai tugas pemprosesan bahasa semula jadi, seperti klasifikasi teks, pengecaman entiti bernama, sistem menjawab soalan, dsb. Pada masa yang sama, proses pra-latihan BERT juga menggunakan data teks tidak berlabel berskala besar, membolehkan model mempelajari pengetahuan bahasa am daripada data berskala besar, meningkatkan lagi prestasinya. Secara ringkasnya, proses pra-latihan model BERT termasuk

Selepas pra-latihan, model BERT boleh digunakan untuk tugas klasifikasi emosi. BERT boleh digunakan sebagai pengekstrak ciri dan digabungkan dengan algoritma pembelajaran mesin lain (seperti regresi logistik, mesin vektor sokongan, dll.) untuk pengelasan. Selain itu, BERT juga boleh diperhalusi untuk meningkatkan lagi prestasi klasifikasi melalui latihan hujung ke hujung mengenai set data klasifikasi emosi tertentu.

Untuk kaedah pengekstrak ciri, vektor output model BERT boleh digunakan sebagai vektor ciri input. Pengelas kemudiannya boleh dilatih dalam kombinasi dengan algoritma pembelajaran mesin yang lain. Sebelum pengelasan, teks perlu dipraproses, seperti pembahagian perkataan, penyingkiran perkataan berhenti, pengekstrakan batang perkataan, dsb. Menggunakan model pra-latihan BERT boleh menghasilkan benam perkataan dan menggunakan benam ini sebagai vektor ciri. Ini boleh mengekstrak maklumat semantik teks dengan berkesan dan membantu pengelas lebih memahami dan membezakan sampel teks yang berbeza.

Untuk kaedah penalaan halus, model BERT boleh diperhalusi dengan melakukan latihan hujung ke hujung pada set data klasifikasi sentimen. Dalam pendekatan ini, semua lapisan model BERT boleh dilatih semula untuk memenuhi keperluan tugas tertentu. Semasa penalaan halus, model boleh dioptimumkan menggunakan kadar pembelajaran yang berbeza, saiz kelompok dan bilangan zaman latihan mengikut keperluan. Dengan memperhalusi model BERT, prestasi model boleh dipertingkatkan kerana ia melaraskan pemberat mengikut keperluan tugasan tertentu. Keupayaan untuk memperibadikan ini menjadikan model BERT berprestasi baik dalam pelbagai tugas pemprosesan bahasa semula jadi.

Apabila menggunakan model BERT untuk klasifikasi sentimen, anda perlu memberi perhatian kepada perkara berikut:

1 Prapemprosesan data: Sebelum menggunakan model BERT, anda perlu mempraproses teks, seperti pembahagian perkataan, penyingkiran kata henti, Stemming, dsb.

2. Anotasi data: Klasifikasi sentimen teks perlu diberi anotasi dengan tepat. Data beranotasi harus mempunyai liputan yang mencukupi untuk memastikan model boleh mempelajari klasifikasi pelbagai emosi.

3. Pemilihan model: Anda boleh memilih untuk menggunakan model BERT yang telah dilatih atau model BERT yang diperhalusi untuk klasifikasi sentimen. Penalaan halus model BERT boleh meningkatkan prestasi model, tetapi ia juga memerlukan lebih banyak sumber dan masa pengkomputeran.

4. Pelarasan hiperparameter: Hiperparameter model perlu dilaraskan, seperti kadar pembelajaran, saiz kelompok dan bilangan pusingan latihan, dsb., untuk mengoptimumkan prestasi model.

5 Penilaian model: Model perlu dinilai untuk menentukan sama ada prestasi model memenuhi jangkaan. Metrik seperti ketepatan, ingat semula, skor F1, dsb. boleh digunakan untuk menilai prestasi model.

Kod Python menunjukkan penalaan halus model BERT untuk klasifikasi emosi

Model BERT boleh mencapai klasifikasi emosi melalui dua kaedah: pengekstrakan ciri dan penalaan halus. Artikel ini akan mengambil penalaan halus model BERT untuk klasifikasi sentimen sebagai contoh, dan juga menyediakan kod Python untuk menunjukkan cara melaksanakannya.

1) Set Data

Kami akan menggunakan dataset klasifikasi sentimen IMDB untuk demonstrasi. Set data ini mengandungi 50,000 teks daripada ulasan filem IMDB, 25,000 daripadanya digunakan untuk latihan dan 25,000 lagi untuk ujian. Setiap sampel mempunyai label binari yang menunjukkan sentimen positif (1) atau negatif (0).

2) Dapatkan set data

Pertama, kita perlu memuat turun set data IMDB. Set data boleh dimuat turun menggunakan kod berikut:

!wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
!tar -xf aclImdb_v1.tar.gz

3) Import perpustakaan yang diperlukan

接下来，我们需要导入必要的Python库，包括PyTorch、Transformers和NumPy。可以使用以下代码导入这些库：

import torch
import transformers as ppb
import numpy as np

4）加载BERT模型和标记器

我们将使用Pretrained BERT模型（ppb）库中的BERT模型和标记器。可以使用以下代码加载模型和标记器：

<code>model_class, tokenizer_class, pretrained_weights = (ppb.BertModel, ppb.BertTokenizer, &#x27;bert-base-uncased&#x27;)<br/>tokenizer = tokenizer_class.from_pretrained(pretrained_weights)<br/>model = model_class.from_pretrained(pretrained_weights)</code>

5）加载数据集

接下来，我们需要加载IMDB数据集。可以使用以下代码加载数据集：

import pandas as pd
import io

# Load data
train = pd.read_csv('aclImdb/train.tsv', delimiter='\t', header=None)
test = pd.read_csv('aclImdb/test.tsv', delimiter='\t', header=None)

# Split data into input and labels
train_sentences = train[0].values
train_labels = train[1].values
test_sentences = test[0].values
test_labels = test[1].values

6）预处理数据

在微调BERT模型之前，我们需要对数据进行预处理。这包括对文本进行标记化、截断和填充。可以使用以下代码对数据进行预处理：

# Tokenize the input texts
train_tokenized = np.array([tokenizer.encode(sent, add_special_tokens=True) for sent in train_sentences])
test_tokenized = np.array([tokenizer.encode(sent, add_special_tokens=True) for sent in test_sentences])

# Truncate and pad the input texts
max_len = 128
train_padded = np.array([i[:max_len] + [0]*(max_len-len(i)) for i in train_tokenized])
test_padded = np.array([i[:max_len] + [0]*(max_len-len(i)) for i in test_tokenized])

# Create attention masks
train_attention_mask = np.where(train_padded != 0, 1, 0)
test_attention_mask = np.where(test_padded != 0, 1, 0)

# Convert the input texts to PyTorch tensors
train_input_ids = torch.tensor(train_padded)
train_attention_mask = torch.tensor(train_attention_mask)
train_labels = torch.tensor(train_labels)
test_input_ids = torch.tensor(test_padded)
test_attention_mask = torch.tensor(test_attention_mask)
test_labels = torch.tensor(test_labels)

7）微调BERT模型

我们将使用PyTorch框架对BERT模型进行微调。可以使用以下代码对模型进行微调：

from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
from transformers import AdamW, get_linear_schedule_with_warmup

#Create a data loader for training data
batch_size = 32
train_data = TensorDataset(train_input_ids, train_attention_mask, train_labels)
train_sampler = RandomSampler(train_data)
train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)

#Create a data loader for test data
test_data = TensorDataset(test_input_ids, test_attention_mask, test_labels)
test_sampler = SequentialSampler(test_data)
test_dataloader = DataLoader(test_data, sampler=test_sampler, batch_size=batch_size)

#Set up the optimizer and scheduler
epochs = 3
optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8)
total_steps = len(train_dataloader) * epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=total_steps)

#Train the model
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
for epoch in range(epochs):
    print(f'Epoch {epoch + 1}/{epochs}')
    print('-' * 10)
    total_loss = 0
    model.train()
    for step, batch in enumerate(train_dataloader):
        # Get batch input data
        batch_input_ids = batch[0].to(device)
        batch_attention_mask = batch[1].to(device)
        batch_labels = batch[2].to(device)

    # Clear gradients
    model.zero_grad()

    # Forward pass
    outputs = model(batch_input_ids, attention_mask=batch_attention_mask, labels=batch_labels)
    loss = outputs[0]

    # Backward pass
    loss.backward()

    # Update parameters
    optimizer.step()

    # Update learning rate schedule
    scheduler.step()

    # Accumulate total loss
    total_loss += loss.item()

    # Print progress every 100 steps
    if (step + 1) % 100 == 0:
        print(f'Step {step + 1}/{len(train_dataloader)}: Loss = {total_loss / (step + 1):.4f}')

# Evaluate the model on test data
model.eval()
with torch.no_grad():
    total_correct = 0
    total_samples = 0
    for batch in test_dataloader:
        # Get batch input data
        batch_input_ids = batch[0].to(device)
        batch_attention_mask = batch[1].to(device)
        batch_labels = batch[2].to(device)

        # Forward pass
        outputs = model(batch_input_ids, attention_mask=batch_attention_mask)
        logits = outputs[0]
        predictions = torch.argmax(logits, dim=1)

        # Accumulate total correct predictions and samples
        total_correct += torch.sum(predictions == batch_labels).item()
        total_samples += len(batch_labels)

    # Print evaluation results
    accuracy = total_correct / total_samples
    print(f'Test accuracy: {accuracy:.4f}')

代码解析：

首先，我们使用PyTorch的数据加载器加载数据。我们将训练数据和测试数据分别放入train_data和test_data张量中，并使用RandomSampler和SequentialSampler对它们进行采样。然后，我们将train_data和test_data输入到DataLoader中，并设置batch_size为32。

接下来，我们设置优化器和学习率调度器。我们使用AdamW优化器和get_linear_schedule_with_warmup学习率调度器。我们将epochs设置为3，并使用total_steps计算总的训练步数。

然后，我们将模型移动到GPU设备上（如果可用）。在每个epoch中，我们将模型设置为训练模式，并遍历train_dataloader以进行训练。对于每个批次，我们将批次输入数据传递给模型，并计算损失。然后，我们使用反向传播更新模型参数，并使用scheduler更新学习率。我们还累计了总损失，并在每100个步骤后打印进度。

在每个epoch结束时，我们将模型设置为评估模式，并使用torch.no_grad()上下文计算在测试数据上的准确度。我们对test_dataloader进行遍历，并对每个批次进行预测。我们将预测结果与真实标签进行比较，并累计总正确预测数和样本数。最后，我们计算测试准确度并打印结果。

Atas ialah kandungan terperinci Apakah kaedah menggunakan model BERT untuk klasifikasi sentimen?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!