train_sequences = torch.LongTensor([sequence + [0] * (100 - len(sequence))[:100] for sequence in train_sequences]) test_sequences = torch.LongTensor([sequence + [0] * (100 - len(sequence))[:100] for sequence in test_sequences])报错'int' object is not subscriptable怎么改

这个错误通常是因为你尝试对一个整数对象进行切片操作。根据你提供的代码，我猜测错误发生在这一行：

train_sequences = torch.LongTensor([sequence + [0] * (100 - len(sequence))[:100] for sequence in train_sequences])

这个错误可能是由于 `len(sequence)` 返回了一个整数对象，而你尝试对这个整数对象进行切片操作 `[:100]`，所以出现了这个错误。

你可以修改代码如下：

train_sequences = torch.LongTensor([sequence + [0] * (100 - len(sequence) if len(sequence) < 100 else 0) for sequence in train_sequences])
test_sequences = torch.LongTensor([sequence + [0] * (100 - len(sequence) if len(sequence) < 100 else 0) for sequence in test_sequences])

这里使用了 `if` 语句来判断 `sequence` 的长度是否小于 100。如果长度小于 100，则补充相应数量的 0。如果长度大于等于 100，则不需要补充。

相关问题

def build_sequences(text, window_size): #text:list of capacity x, y = [],[] for i in range(len(text) - window_size): sequence = text[i:i+window_size] target = text[i+1:i+1+window_size] x.append(sequence) y.append(target) return np.array(x), np.array(y) # 留一评估：一组数据为测试集，其他所有数据全部拿来训练 def get_train_test(data_dict, name, window_size=8): data_sequence=data_dict[name][1] train_data, test_data = data_sequence[:window_size+1], data_sequence[window_size+1:] train_x, train_y = build_sequences(text=train_data, window_size=window_size) for k, v in data_dict.items(): if k != name: data_x, data_y = build_sequences(text=v[1], window_size=window_size) train_x, train_y = np.r_[train_x, data_x], np.r_[train_y, data_y] return train_x, train_y, list(train_data), list(test_data) def relative_error(y_test, y_predict, threshold): true_re, pred_re = len(y_test), 0 for i in range(len(y_test)-1): if y_test[i] <= threshold >= y_test[i+1]: true_re = i - 1 break for i in range(len(y_predict)-1): if y_predict[i] <= threshold: pred_re = i - 1 break return abs(true_re - pred_re)/true_re def evaluation(y_test, y_predict): mae = mean_absolute_error(y_test, y_predict) mse = mean_squared_error(y_test, y_predict) rmse = sqrt(mean_squared_error(y_test, y_predict)) return mae, rmse def setup_seed(seed): np.random.seed(seed) # Numpy module. random.seed(seed) # Python random module. os.environ['PYTHONHASHSEED'] = str(seed) # 为了禁止hash随机化，使得实验可复现。 torch.manual_seed(seed) # 为CPU设置随机种子 if torch.cuda.is_available(): torch.cuda.manual_seed(seed) # 为当前GPU设置随机种子 torch.cuda.manual_seed_all(seed) # if you are using multi-GPU，为所有GPU设置随机种子 torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True

这段代码主要是用来进行数据预处理和模型评估的。其中，`build_sequences`函数用来将数据转化为序列数据，`get_train_test`函数用来获取训练集和测试集，`relative_error`函数用来计算相对误差，`evaluation`函数用来计算模型的MAE、MSE和RMSE指标。另外，`setup_seed`函数用来设置随机种子，以保证实验的可复现性。整个代码涉及到了numpy、random、os和torch等库的使用，可以用来进行深度学习相关的实验和研究。

def forward(self, source: List[List[str]], target: List[List[str]]) -> torch.Tensor: # Compute sentence lengths source_lengths = [len(s) for s in source] # Convert list of lists into tensors source_padded = self.vocab.src

以下是 forward 函数的代码：

def forward(self, source: List[List[str]], target: List[List[str]]) -> torch.Tensor:
    # Compute sentence lengths
    source_lengths = [len(s) for s in source]

    # Convert list of lists into tensors
    source_padded = self.vocab.src.to_input_tensor(source, device=self.device)   # shape: (src_len, batch_size)

    target_padded = self.vocab.tgt.to_input_tensor(target, device=self.device)  # shape: (tgt_len, batch_size)

    # Embed the source and target sequences
    source_embedded = self.model_embeddings_source(source_padded)  # shape: (src_len, batch_size, embed_size)
    target_embedded = self.model_embeddings_target(target_padded)  # shape: (tgt_len, batch_size, embed_size)

    # Encode the source sequence
    enc_hiddens, dec_init_state = self.encoder(source_embedded, source_lengths)  # enc_hiddens shape: (src_len, batch_size, hidden_size)

    # Decode the target sequence
    combined_outputs = self.decoder(target_embedded, dec_init_state, enc_hiddens)  # shape: (tgt_len, batch_size, hidden_size)

    # Compute scores
    P = F.log_softmax(self.target_vocab_projection(combined_outputs), dim=-1)  # shape: (tgt_len, batch_size, tgt_vocab_size)

    return P

该函数的目标是将源语言和目标语言的句子分别转换为嵌入表示，并使用编码器-解码器模型对目标语言进行解码，最后计算得分。

函数的输入参数包括源语言句子列表 source 和目标语言句子列表 target。函数返回一个 torch.Tensor 类型的得分矩阵 P，其形状为 (tgt_len, batch_size, tgt_vocab_size)。

在函数中，首先计算了源语言句子的长度 source_lengths。然后，使用 vocab 中的 to_input_tensor 函数将源语言和目标语言的句子列表转换为张量。其中，source_padded 张量的形状为 (src_len, batch_size)，target_padded 张量的形状为 (tgt_len, batch_size)。

接下来，将源语言和目标语言的张量输入到嵌入层模型中，得到源语言和目标语言的嵌入表示 source_embedded 和 target_embedded。其中，source_embedded 的形状为 (src_len, batch_size, embed_size)，target_embedded 的形状为 (tgt_len, batch_size, embed_size)。

然后，将 source_embedded 和 source_lengths 作为输入传递给编码器，得到编码器的输出 enc_hiddens 和解码器的初始状态 dec_init_state。其中，enc_hiddens 的形状为 (src_len, batch_size, hidden_size)。

最后，将 target_embedded、dec_init_state 和 enc_hiddens 作为输入传递给解码器，得到 combined_outputs。然后，将 combined_outputs 输入到目标语言词汇表投影层中，得到得分矩阵 P。最后，使用 F.log_softmax 函数对 P 进行 log-softmax 处理，将最终结果返回。