请用pytorch实现BERT并完成IMDB数据集的文本分类。

很抱歉，作为AI语言模型，我并不能执行代码，但我可以提供一些实现BERT和完成IMDB数据集文本分类的建议：

1. 首先，需要下载BERT预训练模型以及IMDB数据集。可以在Hugging Face的网站上找到BERT的预训练模型，IMDB数据集可以在官网上下载。

2. 使用PyTorch中的transformers库加载BERT预训练模型，将其fine-tuning为文本分类器。可以使用BertForSequenceClassification类完成这一过程。

3. 将IMDB数据集转换为PyTorch的Dataset和DataLoader格式，以便进行训练和验证。

4. 使用AdamW优化器和学习率调度器对模型进行训练。在每个epoch结束时，计算模型在验证集上的准确率，并保存最佳的模型参数。

5. 使用训练好的模型对测试集进行预测，并计算模型在测试集上的准确率和其他评估指标。

下面是一个简单的BERT文本分类的代码示例：

import torch
from transformers import BertForSequenceClassification, BertTokenizer
from torch.utils.data import DataLoader, Dataset
from sklearn.metrics import classification_report

# 加载BERT预训练模型和tokenizer
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# 加载IMDB数据集
class IMDBDataset(Dataset):
    def __init__(self, file_path):
        self.data = []
        with open(file_path, 'r') as f:
            for line in f:
                text, label = line.strip().split('\t')
                self.data.append((text, int(label)))
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        text, label = self.data[idx]
        input_ids = tokenizer.encode(text, add_special_tokens=True)
        attention_mask = [1] * len(input_ids)
        return torch.tensor(input_ids), torch.tensor(attention_mask), torch.tensor(label)
        
train_dataset = IMDBDataset('train.tsv')
val_dataset = IMDBDataset('val.tsv')
test_dataset = IMDBDataset('test.tsv')

# 转换为DataLoader格式
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False)

# 定义优化器和学习率调度器
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.1)

# 训练模型
best_val_acc = 0
for epoch in range(5):
    model.train()
    for input_ids, attention_mask, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
    scheduler.step()
    
    # 在验证集上评估模型
    model.eval()
    val_preds = []
    val_labels = []
    with torch.no_grad():
        for input_ids, attention_mask, labels in val_loader:
            outputs = model(input_ids, attention_mask=attention_mask)
            logits = outputs.logits
            preds = torch.argmax(logits, dim=1).tolist()
            val_preds.extend(preds)
            val_labels.extend(labels.tolist())
    val_acc = sum([1 if p==l else 0 for p, l in zip(val_preds, val_labels)]) / len(val_labels)
    print(f'Epoch {epoch+1}, val_acc: {val_acc}')
    
    # 保存最佳模型参数
    if val_acc > best_val_acc:
        torch.save(model.state_dict(), 'best_model.pt')
        best_val_acc = val_acc

# 在测试集上评估模型
model.load_state_dict(torch.load('best_model.pt'))
model.eval()
test_preds = []
test_labels = []
with torch.no_grad():
    for input_ids, attention_mask, labels in test_loader:
        outputs = model(input_ids, attention_mask=attention_mask)
        logits = outputs.logits
        preds = torch.argmax(logits, dim=1).tolist()
        test_preds.extend(preds)
        test_labels.extend(labels.tolist())
test_acc = sum([1 if p==l else 0 for p, l in zip(test_preds, test_labels)]) / len(test_labels)
print(f'Test_acc: {test_acc}')
print(classification_report(test_labels, test_preds))