IndexError：索引 0 处的掩码 [...] 的形状与索引 0 处的索引张量 [...] 的形状不匹配

Question

我正在尝试将 Torch 用于 Label 传播。 我有一个 dataframe 看起来像

ID   Target   Weight   Label
1      12       0.4      1
2      24       0.1      0
4      13       0.5      1
4      12       0.3      1
12     1        0.1      1
12     4        0.4      1
13     4        0.2      1
17     1        0.1      0

等等。

我构建的网络如下：

G = nx.from_pandas_edgelist(df, source='ID', target='Target', edge_attr=['Weight']) 

和邻接矩阵

adj_matrix = nx.adjacency_matrix(G).toarray()

我只有两个标签，0 和 1，还有一些没有标签的数据。 我按如下方式创建了输入张量：

# Create input tensors
adj_matrix_t = torch.FloatTensor(adj_matrix)
labels_t = torch.LongTensor(df['Labels'].tolist())

尝试运行以下代码

# Learn with Label Propagation
label_propagation = LabelPropagation(adj_matrix_t)
label_propagation.fit(labels_t) # this is causing the error

我收到了错误： IndexError: The shape of the mask [196] at index 0 does not match the shape of the indexed tensor [207] at index 0 。 我检查了adj_matrix_t.shape的大小，当前是 (207,207)，而标签是 196。你知道我该如何解决这种不一致吗？

请看下面的错误轨迹：

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-42-cf4f88a4bb12> in <module>
      2 label_propagation = LabelPropagation(adj_matrix_t)
      3 print("Label Propagation: ", end="")
----> 4 label_propagation.fit(labels_t)
      5 label_propagation_output_labels = label_propagation.predict_classes()
      6 

<ipython-input-1-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-1-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-1-54a7dbc30bd1> in _one_hot_encode(self, labels)
     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 
     47         self.labeled_mask = ~unlabeled_mask

下面的代码是我想用于 label 传播的示例。 似乎错误是由于标签造成的。 我的数据集中的节点没有标签（尽管在上面的示例中，我为所有标签都写了）。 这可能是导致错误消息的情况吗？

原代码（供参考： https://mybinder.org/v2/gh/thibaudmartinez/label-propagation/master?filepath=notebook.ipynb ）：

## Testing models on synthetic data

import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

# Create caveman graph
n_cliques = 4
size_cliques = 5
caveman_graph = nx.connected_caveman_graph(n_cliques, size_cliques)
adj_matrix = nx.adjacency_matrix(caveman_graph).toarray()


# Create labels
labels = np.full(n_cliques * size_cliques, -1.)

# Only one node per clique is labeled. Each clique belongs to a different class.
labels[0] = 0
labels[size_cliques] = 1
labels[size_cliques * 2] = 2
labels[size_cliques * 3] = 3

# Create input tensors
adj_matrix_t = torch.FloatTensor(adj_matrix)
labels_t = torch.LongTensor(labels)

# 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()

# Learn with Label Spreading
label_spreading = LabelSpreading(adj_matrix_t)
print("Label Spreading: ", end="")
label_spreading.fit(labels_t, alpha=0.8)
label_spreading_output_labels = label_spreading.predict_classes()

# Plot graphs
color_map = {-1: "orange", 0: "blue", 1: "green", 2: "red", 3: "cyan"}
input_labels_colors = [color_map[l] for l in labels]
lprop_labels_colors = [color_map[l] for l in label_propagation_output_labels.numpy()]
lspread_labels_colors = [color_map[l] for l in label_spreading_output_labels.numpy()]

plt.figure(figsize=(14, 6))
ax1 = plt.subplot(1, 4, 1)
ax2 = plt.subplot(1, 4, 2)
ax3 = plt.subplot(1, 4, 3)

ax1.title.set_text("Raw data (4 classes)")
ax2.title.set_text("Label Propagation")
ax3.title.set_text("Label Spreading")

pos = nx.spring_layout(G)
nx.draw(G, ax=ax1, pos=pos, node_color=input_labels_colors, node_size=50)
nx.draw(G, ax=ax2, pos=pos, node_color=lprop_labels_colors, node_size=50)
nx.draw(G, ax=ax3, pos=pos, node_color=lspread_labels_colors, node_size=50)

# Legend
ax4 = plt.subplot(1, 4, 4)
ax4.axis("off")
legend_colors = ["orange", "blue", "green", "red", "cyan"]
legend_labels = ["unlabeled", "class 0", "class 1", "class 2", "class 3"]
dummy_legend = [ax4.plot([], [], ls='-', c=c)[0] for c in legend_colors]
plt.legend(dummy_legend, legend_labels)

plt.show()

当然，如果我在这篇文章顶部的数据集示例由于标签不适合原始代码，如果您可以再给我一个示例以了解数据集中的标签（确定节点的类别）应该如何看起来像（即使缺少要预测的值），它会非常感激。

Answer 1

对于这里的其他读者来说，这似乎是这个问题中被问到的实现。

您用于尝试预测标签的方法适用于节点的标签，而不是边。 To visualize this, I plotted your example data and colored the plot by your Weight and Label columns (code to produce plot appended below) where Weight is the line thickness of the edge and Label is the color:

为了使用此方法，您需要生成如下所示的数据，其中每个节点（由ID表示）恰好有一个node_label ：

ID    node_label
1         1
2         0
4         1
12        1
13        1
17        0

需要明确的是，您仍然需要上面的原始数据来构建网络和邻接矩阵，但是您必须确定一些逻辑规则来将边缘标签转换为节点标签。 然后，一旦您预测了未标记的节点，您可以在必要时反转您的规则以获取边缘标签。

这不是一种严格严格的方法，但如果您的数据不仅仅是随机噪声，它是实用的并且可能会产生一些合理的结果。

---

代码附录：

# Sample data network plot

import networkx as nx
import pandas as pd

data = {'ID': {0: 1, 1: 2, 2: 4, 3: 4, 4: 12, 5: 12, 6: 13, 7: 17},
        'Target': {0: 12, 1: 24, 2: 13, 3: 12, 4: 1, 5: 4, 6: 4, 7: 1},
        'Weight': {0: 0.4, 1: 0.1, 2: 0.5, 3: 0.3, 4: 0.1, 5: 0.4, 6: 0.2, 7: 0.1},
        'Label': {0: 1, 1: 0, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 0}}

df = pd.DataFrame.from_dict(data)

G = nx.from_pandas_edgelist(df, source='ID', target='Target', edge_attr=['Weight', 'Label']) 

width = [20 * d['Weight'] for (u, v, d) in G.edges(data=True)]
edge_color = [d['Label'] for (u, v, d) in G.edges(data=True)]
nx.draw_networkx(G, width=width, edge_color=edge_color)