用pytorch完成这样的任务：给你一个txt文件，内容是英文的文本。让你使用双向LSTM的方法完成词向量的训练。

首先，我们需要将文本转换为数字序列，可以使用torchtext库来完成这个任务。

import torchtext

# 定义数据的处理方式
text = torchtext.data.Field(sequential=True, lower=True, tokenize='spacy')

# 加载数据
train_data, valid_data, test_data = torchtext.datasets.LanguageModelingDataset.splits(
    path='data', train='train.txt', validation='valid.txt', test='test.txt', text_field=text)

# 构建词汇表
text.build_vocab(train_data, min_freq=3)

# 定义batch的大小
batch_size = 32

# 构建迭代器
train_iter, valid_iter, test_iter = torchtext.data.BPTTIterator.splits(
    (train_data, valid_data, test_data), batch_size=batch_size, bptt_len=30, device='cuda')

接下来，我们可以定义双向LSTM模型：

import torch.nn as nn

class BiLSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, dropout):
        super(BiLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, 
                            bidirectional=True, dropout=dropout)
        self.fc = nn.Linear(hidden_dim * 2, vocab_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, text):
        embedded = self.dropout(self.embedding(text))
        output, _ = self.lstm(embedded)
        output = self.dropout(output)
        output = self.fc(output)
        return output

然后，我们可以编写训练的代码：

import torch.optim as optim

# 定义模型
vocab_size = len(text.vocab)
embedding_dim = 300
hidden_dim = 256
num_layers = 2
dropout = 0.5
model = BiLSTM(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).cuda()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 训练模型
num_epochs = 10
best_valid_loss = float('inf')
for epoch in range(num_epochs):
    train_loss = 0.0
    model.train()
    for batch in train_iter:
        text = batch.text
        target = batch.target.view(-1)
        optimizer.zero_grad()
        output = model(text)
        loss = criterion(output.view(-1, vocab_size), target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()

    valid_loss = 0.0
    model.eval()
    with torch.no_grad():
        for batch in valid_iter:
            text = batch.text
            target = batch.target.view(-1)
            output = model(text)
            loss = criterion(output.view(-1, vocab_size), target)
            valid_loss += loss.item()

    train_loss /= len(train_iter)
    valid_loss /= len(valid_iter)

    print('Epoch: {}, Train Loss: {:.4f}, Valid Loss: {:.4f}'.format(epoch+1, train_loss, valid_loss))

    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'model.pt')

最后，我们可以使用训练好的双向LSTM模型来得到词向量：

import torch

# 加载训练好的模型
model.load_state_dict(torch.load('model.pt'))

# 得到词向量
embedding = model.embedding.weight.data.cpu().numpy()