一次热编码期间的 RunTimeError
RunTimeError during one hot encoding
我有一个数据集，其中 class 值从 -2 到 2 一步 (i.e., -2,-1,0,1,2) 并且 9 标识未标记的数据。
使用一个热编码
self._one_hot_encode(labels)
我收到以下错误：RuntimeError: index 1 is out of bounds for dimension 1 with size 1
由于
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
错误应该从 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1] 开始，我在映射设置中有 9 等于索引 9 到 1。我不清楚如何修复它，即使在经历了过去的类似问题和答案之后问题（例如 ）。
涉及错误的部分代码如下：
def _one_hot_encode(self, labels):
# Get the number of classes
classes = torch.unique(labels)
classes = classes[classes != 9] # unlabelled
self.n_classes = classes.size(0)
# One-hot encode labeled data instances and zero rows corresponding to unlabeled instances
unlabeled_mask = (labels == 9)
labels = labels.clone() # defensive copying
labels[unlabeled_mask] = 0
self.one_hot_labels = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
self.one_hot_labels[unlabeled_mask, 0] = 0
self.labeled_mask = ~unlabeled_mask
def fit(self, labels, max_iter, tol):
self._one_hot_encode(labels)
self.predictions = self.one_hot_labels.clone()
prev_predictions = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
for i in range(max_iter):
# Stop iterations if the system is considered at a steady state
variation = torch.abs(self.predictions - prev_predictions).sum().item()
prev_predictions = self.predictions
self._propagate()
数据集示例：
ID Target Weight Label Score Scale_Cat Scale_num
0 A D 65.1 1 87 Up 1
1 A X 35.8 1 87 Up 1
2 B C 34.7 1 37.5 Down -2
3 B P 33.4 1 37.5 Down -2
4 C B 33.1 1 37.5 Down -2
5 S X 21.4 0 12.5 NA 9
我用作参考的源代码在这里：https://mybinder.org/v2/gh/thibaudmartinez/label-propagation/master?filepath=notebook.ipynb
错误的完整轨迹：
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-126-792a234f63dd> in <module>
4 label_propagation = LabelPropagation(adj_matrix_t)
----> 6 label_propagation.fit(labels_t) # causing error
7 label_propagation_output_labels = label_propagation.predict_classes()
8
<ipython-input-115-54a7dbc30bd1> in fit(self, labels, max_iter, tol)
100
101 def fit(self, labels, max_iter=1000, tol=1e-3):
--> 102 super().fit(labels, max_iter, tol)
103
104 ## Label spreading
<ipython-input-115-54a7dbc30bd1> in fit(self, labels, max_iter, tol)
58 Convergence tolerance: threshold to consider the system at steady state.
59 """
---> 60 self._one_hot_encode(labels)
61
62 self.predictions = self.one_hot_labels.clone()
<ipython-input-115-54a7dbc30bd1> in _one_hot_encode(self, labels)
42 labels[unlabeled_mask] = 0
43 self.one_hot_labels = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
---> 44 self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
45 self.one_hot_labels[unlabeled_mask, 0] = 0
46
RuntimeError: index 1 is out of bounds for dimension 1 with size 1
我 运行 通过你的笔记本（我认为你将 9 更改为 -1 以 运行 ）并看到了这部分代码：
# Learn with Label Propagation
label_propagation = LabelPropagation(adj_matrix_t)
print("Label Propagation: ", end="")
label_propagation.fit(labels_t)
label_propagation_output_labels = label_propagation.predict_classes()
最终调用：
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
哪里出了问题。
在此处花点时间阅读关于散点的 pytorch 手册：torch Scatter 我们了解到，对于散点，了解 dim、index、src 和 self 矩阵很重要。对于一种热编码，dim=1 或 0 并不重要，我们的 src 矩阵是 1（我们稍后会对此进行更多研究）。您现在使用索引矩阵 [40,1] 和结果（自身）矩阵 [40,5].
在维度 1 上调用散点图
我在这里看到两个问题：
- 您正在使用文字类别虚拟变量 (-2,-1,0,1,2) 作为索引矩阵中的编码索引。这将导致分散在 src 矩阵中搜索这些索引。 这是索引越界的来源
- 你提到有 6 classes 的 -2,-1,0,1,2 和 9 用于未标记，但你是 5 classes 上的一个热编码。 （是的，我知道你希望未标记的 class 全部为零，但这有点难以用散点图实现。我稍后会解释）。
那么我们该如何解决这个问题？
问题 1：让我们从一个小例子开始：
index = torch.tensor([[5],[0],[3],[5],[1],[4]]); print(index.shape); print(index)
result = torch.zeros(6, 6, dtype=src.dtype).scatter_(1, index, src); print(result.shape); print(result)
这会给我们
torch.Size([6, 1])
tensor([[5],
[0],
[3],
[5],
[1],
[4]])
torch.Size([6, 6])
tensor([[0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]])
索引矩阵是 6 个观测值和 1 个观测值（类别）
自矩阵是 6 个观察值，具有 6 个类别的一个热编码向量
scatter(dim=1) 创建自矩阵的方式是 torch 首先检查行（观察），然后将该行的值更改为存储在 src 矩阵中同一行但在列的值的值存储在索引中的值。
self[i][index[i][j][k]][k] = src[i][j][k]
因此，在您的情况下，您试图将值 1 应用到 self[40,1] 中索引 [0] 列（等于 1）的一行中。给你问题中的错误。虽然我检查了你的笔记本，但错误是
索引 -1 超出尺寸为 5 的维度 1 的范围。它们都是相同的根本原因。
问题 2：单热编码
在这种情况下，使用冷编码进行完整的单热比单热更容易。原因是对于带有冷编码的单热，您需要在 src 矩阵中为每个未标记的观察创建一个 0 值。这比仅将 1 用于 src 更痛苦。另请参阅此 link：Is it valid to have full zeros for OHE? 我认为对每个类别使用 one-hot 更有意义。
因此，对于第二个问题，我们只需要简单地将类别映射到 result/self 矩阵的索引中。由于我们有 6 个类别，我们只需要将它们映射到 0、1、2、3、4、5。一个简单的 lambda 函数就可以解决问题。我使用 运行dom 采样器从 class 列表中获取我的数据标签，如下所示：（我 运行domly 从 6 classes 中创建了 40 个观察值）
classes = list([-2,-1,0,1,2,9])
labels = list()
for i in range(0,40):
labels.append(list([(lambda x: x+2 if x !=9 else 5)(random.sample(classes,1)[0])]))
index_aka_labels = torch.tensor(labels)
print(index_aka_labels)
print(index_aka_labels.shape)
torch.zeros(40, 6, dtype=src.dtype).scatter_(1, index_aka_labels, 1)
终于，我们达到了我们想要的OHE结果：
tensor([[0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
... (40 observations)
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1],
我有一个数据集，其中 class 值从 -2 到 2 一步 (i.e., -2,-1,0,1,2) 并且 9 标识未标记的数据。
使用一个热编码
self._one_hot_encode(labels)
我收到以下错误：RuntimeError: index 1 is out of bounds for dimension 1 with size 1
由于
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
错误应该从 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1] 开始，我在映射设置中有 9 等于索引 9 到 1。我不清楚如何修复它，即使在经历了过去的类似问题和答案之后问题（例如
def _one_hot_encode(self, labels):
# Get the number of classes
classes = torch.unique(labels)
classes = classes[classes != 9] # unlabelled
self.n_classes = classes.size(0)
# One-hot encode labeled data instances and zero rows corresponding to unlabeled instances
unlabeled_mask = (labels == 9)
labels = labels.clone() # defensive copying
labels[unlabeled_mask] = 0
self.one_hot_labels = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
self.one_hot_labels[unlabeled_mask, 0] = 0
self.labeled_mask = ~unlabeled_mask
def fit(self, labels, max_iter, tol):
self._one_hot_encode(labels)
self.predictions = self.one_hot_labels.clone()
prev_predictions = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
for i in range(max_iter):
# Stop iterations if the system is considered at a steady state
variation = torch.abs(self.predictions - prev_predictions).sum().item()
prev_predictions = self.predictions
self._propagate()
数据集示例：
ID Target Weight Label Score Scale_Cat Scale_num
0 A D 65.1 1 87 Up 1
1 A X 35.8 1 87 Up 1
2 B C 34.7 1 37.5 Down -2
3 B P 33.4 1 37.5 Down -2
4 C B 33.1 1 37.5 Down -2
5 S X 21.4 0 12.5 NA 9
我用作参考的源代码在这里：https://mybinder.org/v2/gh/thibaudmartinez/label-propagation/master?filepath=notebook.ipynb
错误的完整轨迹：
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-126-792a234f63dd> in <module>
4 label_propagation = LabelPropagation(adj_matrix_t)
----> 6 label_propagation.fit(labels_t) # causing error
7 label_propagation_output_labels = label_propagation.predict_classes()
8
<ipython-input-115-54a7dbc30bd1> in fit(self, labels, max_iter, tol)
100
101 def fit(self, labels, max_iter=1000, tol=1e-3):
--> 102 super().fit(labels, max_iter, tol)
103
104 ## Label spreading
<ipython-input-115-54a7dbc30bd1> in fit(self, labels, max_iter, tol)
58 Convergence tolerance: threshold to consider the system at steady state.
59 """
---> 60 self._one_hot_encode(labels)
61
62 self.predictions = self.one_hot_labels.clone()
<ipython-input-115-54a7dbc30bd1> in _one_hot_encode(self, labels)
42 labels[unlabeled_mask] = 0
43 self.one_hot_labels = torch.zeros((self.n_nodes, self.n_classes), dtype=torch.float)
---> 44 self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
45 self.one_hot_labels[unlabeled_mask, 0] = 0
46
RuntimeError: index 1 is out of bounds for dimension 1 with size 1
我 运行 通过你的笔记本（我认为你将 9 更改为 -1 以 运行 ）并看到了这部分代码：
# Learn with Label Propagation
label_propagation = LabelPropagation(adj_matrix_t)
print("Label Propagation: ", end="")
label_propagation.fit(labels_t)
label_propagation_output_labels = label_propagation.predict_classes()
最终调用：
self.one_hot_labels = self.one_hot_labels.scatter(1, labels.unsqueeze(1), 1)
哪里出了问题。
在此处花点时间阅读关于散点的 pytorch 手册：torch Scatter 我们了解到，对于散点，了解 dim、index、src 和 self 矩阵很重要。对于一种热编码，dim=1 或 0 并不重要，我们的 src 矩阵是 1（我们稍后会对此进行更多研究）。您现在使用索引矩阵 [40,1] 和结果（自身）矩阵 [40,5].
在维度 1 上调用散点图我在这里看到两个问题：
- 您正在使用文字类别虚拟变量 (-2,-1,0,1,2) 作为索引矩阵中的编码索引。这将导致分散在 src 矩阵中搜索这些索引。 这是索引越界的来源
- 你提到有 6 classes 的 -2,-1,0,1,2 和 9 用于未标记，但你是 5 classes 上的一个热编码。 （是的，我知道你希望未标记的 class 全部为零，但这有点难以用散点图实现。我稍后会解释）。
那么我们该如何解决这个问题？
问题 1：让我们从一个小例子开始：
index = torch.tensor([[5],[0],[3],[5],[1],[4]]); print(index.shape); print(index)
result = torch.zeros(6, 6, dtype=src.dtype).scatter_(1, index, src); print(result.shape); print(result)
这会给我们
torch.Size([6, 1])
tensor([[5],
[0],
[3],
[5],
[1],
[4]])
torch.Size([6, 6])
tensor([[0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]])
索引矩阵是 6 个观测值和 1 个观测值（类别）
自矩阵是 6 个观察值，具有 6 个类别的一个热编码向量
scatter(dim=1) 创建自矩阵的方式是 torch 首先检查行（观察），然后将该行的值更改为存储在 src 矩阵中同一行但在列的值的值存储在索引中的值。
self[i][index[i][j][k]][k] = src[i][j][k]
因此，在您的情况下，您试图将值 1 应用到 self[40,1] 中索引 [0] 列（等于 1）的一行中。给你问题中的错误。虽然我检查了你的笔记本，但错误是 索引 -1 超出尺寸为 5 的维度 1 的范围。它们都是相同的根本原因。
问题 2：单热编码
在这种情况下，使用冷编码进行完整的单热比单热更容易。原因是对于带有冷编码的单热，您需要在 src 矩阵中为每个未标记的观察创建一个 0 值。这比仅将 1 用于 src 更痛苦。另请参阅此 link：Is it valid to have full zeros for OHE? 我认为对每个类别使用 one-hot 更有意义。
因此，对于第二个问题，我们只需要简单地将类别映射到 result/self 矩阵的索引中。由于我们有 6 个类别，我们只需要将它们映射到 0、1、2、3、4、5。一个简单的 lambda 函数就可以解决问题。我使用 运行dom 采样器从 class 列表中获取我的数据标签，如下所示：（我 运行domly 从 6 classes 中创建了 40 个观察值）
classes = list([-2,-1,0,1,2,9])
labels = list()
for i in range(0,40):
labels.append(list([(lambda x: x+2 if x !=9 else 5)(random.sample(classes,1)[0])]))
index_aka_labels = torch.tensor(labels)
print(index_aka_labels)
print(index_aka_labels.shape)
torch.zeros(40, 6, dtype=src.dtype).scatter_(1, index_aka_labels, 1)
终于，我们达到了我们想要的OHE结果：
tensor([[0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 1, 0],
... (40 observations)
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1],