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

Question

我试图使用火炬的标签传播。 我有一个看起来像

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的大小，它当前是（207207207），而标签是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

下面的代码是我希望用于标签传播的示例。似乎错误是由标签引起的。我的数据集中有些节点没有标签（尽管在上面的示例中，我编写了所有标签）。这可能是导致错误消息的原因吗

原始代码（供参考：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()

当然，如果由于标签的原因，我在本文顶部的dataset示例不适合原始代码，如果您能给我另一个示例，以了解dataset中的标签（确定节点类）应该是什么样子的（即使缺少预测值），我将不胜感激

Answer 1

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

用于尝试预测标签的方法适用于节点的标签，而不是边。为了可视化这一点，我绘制了示例数据，并用Weight和Label列（下面附加了生成绘图的代码）给绘图上色，其中Weight是边缘的线条厚度，Label是颜色：

为了使用此方法，您需要生成如下所示的数据，其中每个节点（由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)