分类

节点分类算法。

属性 labels_ 给出图中每个节点的标签。

扩散

class sknetwork.classification.DiffusionClassifier(n_iter: int = 10, centering: bool = True, scale: float = 5)

通过热扩散进行节点分类。

对于每个标签，节点的温度对应于它具有该标签的概率。

参数：

• n_iter (int) – 扩散的迭代次数（离散时间）。

• centering (bool) – 如果为 True，则在分类之前将每个标签的温度居中到其平均值（默认）。

• scale (float) – 在 softmax 之前应用于温度的乘法因子（默认值为 5）。仅在居中为 True 时使用。

变量：

• labels (np.ndarray, shape (n_labels,)) – 节点的标签。

• probs (sparse.csr_matrix, shape (n_row, n_labels)) – 标签上的概率分布。

• labels_row (np.ndarray) – 行的标签，用于二部图。

• labels_col (np.ndarray) – 列的标签，用于二部图。

• probs_row (sparse.csr_matrix, shape (n_row, n_labels)) – 行的标签上的概率分布，用于二部图。

• probs_col (sparse.csr_matrix, shape (n_col, n_labels)) – 列的标签上的概率分布，用于二部图。

示例

>>> from sknetwork.data import karate_club
>>> diffusion = DiffusionClassifier()
>>> graph = karate_club(metadata=True)
>>> adjacency = graph.adjacency
>>> labels_true = graph.labels
>>> labels = {0: labels_true[0], 33: labels_true[33]}
>>> labels_pred = diffusion.fit_predict(adjacency, labels)
>>> round(np.mean(labels_pred == labels_true), 2)
0.97

参考文献

Zhu, X., Lafferty, J., & Rosenfeld, R. (2005). Semi-supervised learning with graphs (Doctoral dissertation, Carnegie Mellon University, language technologies institute, school of computer science).

fit(input_matrix: csr_matrix | ndarray, labels: ndarray | list | dict | None = None, labels_row: ndarray | list | dict | None = None, labels_col: ndarray | list | dict | None = None, force_bipartite: bool = False) → DiffusionClassifier

计算狄利克雷问题的解（平衡时的温度）。

参数：

• input_matrix (sparse.csr_matrix, np.ndarray) – 图的邻接矩阵或二部邻接矩阵。

• labels (dict, np.ndarray) – 已知标签（字典或整数向量）。负值将被忽略。

• labels_row (dict, np.ndarray) – 二部图中行的标签。负值将被忽略。

• labels_col (dict, np.ndarray) – 二部图中列的标签。负值将被忽略。

• force_bipartite (bool) – 如果为 True，则将输入矩阵视为二部邻接矩阵（默认值为 False）。

返回值：

self

返回类型：

DiffusionClassifier

fit_predict(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签。与 fit 方法相同的参数。

返回值：

labels – 标签。

返回类型：

np.ndarray

fit_predict_proba(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 每个标签的概率。

返回类型：

np.ndarray

fit_transform(*args, **kwargs) → csr_matrix

将算法拟合到数据并以稀疏格式返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

get_params()

将参数作为字典获取。

返回值：

params – 算法的参数。

返回类型：

dict

predict(columns: bool = False) → ndarray

返回算法预测的标签。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

labels – 标签。

返回类型：

np.ndarray

predict_proba(columns=False) → ndarray

返回算法预测的标签上的概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

np.ndarray

set_params(params: dict) → Algorithm

设置算法的参数。

参数：

params (dict) – 算法的参数。

返回值：

self

返回类型：

算法

transform(columns=False) → csr_matrix

返回稀疏格式的标签概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

最近邻

class sknetwork.classification.NNClassifier(n_neighbors: int = 3, embedding_method: BaseEmbedding | None = None, normalize: bool = True)

在嵌入空间中通过 K 近邻进行节点分类。

参数：

• n_neighbors (int) – 最近邻的数量。

• embedding_method (BaseEmbedding) – 用于在向量空间中表示节点的嵌入方法。如果为 None（默认），则使用身份。

• normalize (bool) – 如果为 True，则应用归一化，以便所有向量在嵌入空间中具有范数 1。

变量：

• labels (np.ndarray, shape (n_labels,)) – 节点的标签。

• probs (sparse.csr_matrix, shape (n_row, n_labels)) – 标签上的概率分布。

• labels_row (np.ndarray) – 行的标签，用于二部图。

• labels_col (np.ndarray) – 列的标签，用于二部图。

• probs_row (sparse.csr_matrix, shape (n_row, n_labels)) – 行的标签上的概率分布，用于二部图。

• probs_col (sparse.csr_matrix, shape (n_col, n_labels)) – 列的标签上的概率分布，用于二部图。

示例

>>> from sknetwork.classification import NNClassifier
>>> from sknetwork.data import karate_club
>>> classifier = NNClassifier(n_neighbors=1)
>>> graph = karate_club(metadata=True)
>>> adjacency = graph.adjacency
>>> labels_true = graph.labels
>>> labels = {0: labels_true[0], 33: labels_true[33]}
>>> labels_pred = classifier.fit_predict(adjacency, labels)
>>> round(np.mean(labels_pred == labels_true), 2)
0.82

fit(input_matrix: csr_matrix | ndarray, labels: ndarray | list | dict | None = None, labels_row: ndarray | list | dict | None = None, labels_col: ndarray | list | dict | None = None) → NNClassifier

在嵌入空间中通过 k 近邻进行节点分类。

参数：

• input_matrix (sparse.csr_matrix, np.ndarray) – 图的邻接矩阵或二部邻接矩阵。

• labels (np.ndarray, dict) – 已知标签。忽略负值。

• labels_row (np.ndarray, dict) – 行的已知标签，适用于二部图。

• labels_col (np.ndarray, dict) – 列的已知标签，适用于二部图。

返回值：

self

返回类型：

KNN

fit_predict(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签。与 fit 方法相同的参数。

返回值：

labels – 标签。

返回类型：

np.ndarray

fit_predict_proba(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 每个标签的概率。

返回类型：

np.ndarray

fit_transform(*args, **kwargs) → csr_matrix

将算法拟合到数据并以稀疏格式返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

get_params()

将参数作为字典获取。

返回值：

params – 算法的参数。

返回类型：

dict

predict(columns: bool = False) → ndarray

返回算法预测的标签。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

labels – 标签。

返回类型：

np.ndarray

predict_proba(columns=False) → ndarray

返回算法预测的标签上的概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

np.ndarray

set_params(params: dict) → Algorithm

设置算法的参数。

参数：

params (dict) – 算法的参数。

返回值：

self

返回类型：

算法

transform(columns=False) → csr_matrix

返回稀疏格式的标签概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

传播

class sknetwork.classification.Propagation(n_iter: float = -1, node_order: str | None = None, weighted: bool = True)

通过标签传播进行节点分类。

参数：

• n_iter (float) – 最大迭代次数（-1 表示无穷大）。

• node_order (str) –

  • 'random': 节点标签以随机顺序更新。

  • 'increasing': 节点标签按（入/出）权重的升序更新。

  • 'decreasing': 节点标签按（入/出）权重的降序更新。

  • 否则，节点标签按索引顺序更新。

• weighted (bool) – 如果为 True，则每个邻居的投票与其边权重成正比。否则，所有投票的权重均为 1。

变量：

• labels (np.ndarray, shape (n_labels,)) – 节点的标签。

• probs (sparse.csr_matrix, shape (n_row, n_labels)) – 标签上的概率分布。

• labels_row (np.ndarray) – 行的标签，用于二部图。

• labels_col (np.ndarray) – 列的标签，用于二部图。

• probs_row (sparse.csr_matrix, shape (n_row, n_labels)) – 行的标签上的概率分布，用于二部图。

• probs_col (sparse.csr_matrix, shape (n_col, n_labels)) – 列的标签上的概率分布，用于二部图。

示例

>>> from sknetwork.classification import Propagation
>>> from sknetwork.data import karate_club
>>> propagation = Propagation()
>>> graph = karate_club(metadata=True)
>>> adjacency = graph.adjacency
>>> labels_true = graph.labels
>>> labels = {0: labels_true[0], 33: labels_true[33]}
>>> labels_pred = propagation.fit_predict(adjacency, labels)
>>> np.round(np.mean(labels_pred == labels_true), 2)
0.94

参考文献

Raghavan, U. N., Albert, R., & Kumara, S. (2007). Near linear time algorithm to detect community structures in large-scale networks. Physical review E, 76(3), 036106.

fit(input_matrix: csr_matrix | ndarray, labels: ndarray | list | dict | None = None, labels_row: ndarray | list | dict | None = None, labels_col: ndarray | list | dict | None = None) → Propagation

通过标签传播进行节点分类。

参数：

• input_matrix (sparse.csr_matrix, np.ndarray) – 图的邻接矩阵或二部邻接矩阵。

• labels (数组, 列表 或 字典) – 已知标签。负值将被忽略。

• labels_row (数组, 列表 或 字典) – 行的已知标签，用于二部图。

• labels_col (数组, 列表 或 字典) – 列的已知标签，用于二部图。

返回值：

self

返回类型：

传播

fit_predict(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签。与 fit 方法相同的参数。

返回值：

labels – 标签。

返回类型：

np.ndarray

fit_predict_proba(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 每个标签的概率。

返回类型：

np.ndarray

fit_transform(*args, **kwargs) → csr_matrix

将算法拟合到数据并以稀疏格式返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

get_params()

将参数作为字典获取。

返回值：

params – 算法的参数。

返回类型：

dict

predict(columns: bool = False) → ndarray

返回算法预测的标签。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

labels – 标签。

返回类型：

np.ndarray

predict_proba(columns=False) → ndarray

返回算法预测的标签上的概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

np.ndarray

set_params(params: dict) → Algorithm

设置算法的参数。

参数：

params (dict) – 算法的参数。

返回值：

self

返回类型：

算法

transform(columns=False) → csr_matrix

返回稀疏格式的标签概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

PageRank

class sknetwork.classification.PageRankClassifier(damping_factor: float = 0.85, solver: str = 'piteration', n_iter: int = 10, tol: float = 0.0, n_jobs: int | None = None, verbose: bool = False)

通过多个个性化 PageRank 进行节点分类。

参数：

• damping_factor (浮点数) – 继续随机游走的概率。

• solver (字符串) – 要使用的求解器：‘piteration’，‘diteration’，‘bicgstab’，‘lanczos’。

• n_iter (整数) – 某些求解器的迭代次数，例如 'piteration' 或 'diteration'。

• tol (浮点数) – 某些求解器收敛的容差，例如 'bicgstab' 或 'lanczos'。

变量：

• labels (np.ndarray, shape (n_labels,)) – 节点的标签。

• probs (sparse.csr_matrix, shape (n_row, n_labels)) – 标签上的概率分布。

• labels_row (np.ndarray) – 行的标签，用于二部图。

• labels_col (np.ndarray) – 列的标签，用于二部图。

• probs_row (sparse.csr_matrix, shape (n_row, n_labels)) – 行的标签上的概率分布，用于二部图。

• probs_col (sparse.csr_matrix, shape (n_col, n_labels)) – 列的标签上的概率分布，用于二部图。

示例

>>> from sknetwork.classification import PageRankClassifier
>>> from sknetwork.data import karate_club
>>> pagerank = PageRankClassifier()
>>> graph = karate_club(metadata=True)
>>> adjacency = graph.adjacency
>>> labels_true = graph.labels
>>> labels = {0: labels_true[0], 33: labels_true[33]}
>>> labels_pred = pagerank.fit_predict(adjacency, labels)
>>> np.round(np.mean(labels_pred == labels_true), 2)
0.97

参考文献

Lin, F., & Cohen, W. W. (2010). 使用极少标签的网络数据半监督分类。 在 IEEE 社会网络分析与挖掘进展国际会议上。

fit(input_matrix: csr_matrix | ndarray, labels: ndarray | dict | None = None, labels_row: ndarray | dict | None = None, labels_col: ndarray | dict | None = None) → RankClassifier

将算法拟合到数据。

参数：

• input_matrix – 图的邻接矩阵或二部邻接矩阵。

• labels – 已知标签（字典或数组；负值将被忽略）。

• labels_row – 行和列上的已知标签（用于二部图）。

• labels_col – 行和列上的已知标签（用于二部图）。

返回值：

self

返回类型：

RankClassifier

fit_predict(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签。与 fit 方法相同的参数。

返回值：

labels – 标签。

返回类型：

np.ndarray

fit_predict_proba(*args, **kwargs) → ndarray

将算法拟合到数据并返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 每个标签的概率。

返回类型：

np.ndarray

fit_transform(*args, **kwargs) → csr_matrix

将算法拟合到数据并以稀疏格式返回标签上的概率分布。与 fit 方法相同的参数。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

get_params()

将参数作为字典获取。

返回值：

params – 算法的参数。

返回类型：

dict

predict(columns: bool = False) → ndarray

返回算法预测的标签。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

labels – 标签。

返回类型：

np.ndarray

predict_proba(columns=False) → ndarray

返回算法预测的标签上的概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

np.ndarray

set_params(params: dict) → Algorithm

设置算法的参数。

参数：

params (dict) – 算法的参数。

返回值：

self

返回类型：

算法

transform(columns=False) → csr_matrix

返回稀疏格式的标签概率分布。

参数：

columns (bool) – 如果为 True，则返回对列的预测。

返回值：

probs – 标签上的概率分布。

返回类型：

sparse.csr_matrix

指标

sknetwork.classification.get_accuracy_score(labels_true: ndarray, labels_pred: ndarray) → float

返回正确标记样本的比例。忽略负标签。

参数：

• labels_true (np.ndarray) – 真实标签。

• labels_pred (np.ndarray) – 预测标签

返回值：

accuracy – 介于 0 和 1 之间的得分。

返回类型：

float

示例

>>> import numpy as np
>>> labels_true = np.array([0, 0, 1, 1])
>>> labels_pred = np.array([0, 0, 0, 1])
>>> round(get_accuracy_score(labels_true, labels_pred), 2)
0.75

sknetwork.classification.get_f1_score(labels_true: ndarray, labels_pred: ndarray, return_precision_recall: bool = False) → float | Tuple[float, float, float]

返回二元分类的 F1 分数。忽略负标签。

参数：

• labels_true (np.ndarray) – 真实标签。

• labels_pred (np.ndarray) – 预测标签

• return_precision_recall (bool) – 如果为 True，也返回精度和召回率。

返回值：

score, [precision, recall] – F1 分数（介于 0 和 1 之间）。可以选择，也返回精度和召回率。

返回类型：

np.ndarray

示例

>>> import numpy as np
>>> labels_true = np.array([0, 0, 1, 1])
>>> labels_pred = np.array([0, 0, 0, 1])
>>> round(get_f1_score(labels_true, labels_pred), 2)
0.67

sknetwork.classification.get_f1_scores(labels_true: ndarray, labels_pred: ndarray, return_precision_recall: bool = False) → ndarray | Tuple[ndarray, ndarray, ndarray]

返回多标签分类的 F1 分数（每个标签一个）。忽略负标签。

参数：

• labels_true (np.ndarray) – 真实标签。

• labels_pred (np.ndarray) – 预测标签

• return_precision_recall (bool) – 如果为 True，也返回精度和召回率。

返回值：

scores, [precisions, recalls] – F1 分数（介于 0 和 1 之间）。可以选择，也返回 F1 精度和召回率。

返回类型：

np.ndarray

示例

>>> import numpy as np
>>> labels_true = np.array([0, 0, 1, 1])
>>> labels_pred = np.array([0, 0, 0, 1])
>>> np.round(get_f1_scores(labels_true, labels_pred), 2)
array([0.8 , 0.67])

sknetwork.classification.get_average_f1_score(labels_true: ndarray, labels_pred: ndarray, average: str = 'macro') → float

返回多标签分类的平均 F1 分数。忽略负标签。

参数：

• labels_true (np.ndarray) – 真实标签。

• labels_pred (np.ndarray) – 预测标签

• average (str) – 平均方法。可以是 'macro'（默认）、'micro' 或 'weighted'。

返回值：

score – 平均 F1 分数（介于 0 和 1 之间）。

返回类型：

float

示例

>>> import numpy as np
>>> labels_true = np.array([0, 0, 1, 1])
>>> labels_pred = np.array([0, 0, 0, 1])
>>> round(get_average_f1_score(labels_true, labels_pred), 2)
0.73

sknetwork.classification.get_confusion_matrix(labels_true: ndarray, labels_pred: ndarray) → csr_matrix

以稀疏格式返回混淆矩阵（真实标签在行中，预测标签在列中）。忽略负标签。

参数：

• labels_true (np.ndarray) – 真实标签。

• labels_pred (np.ndarray) – 预测标签

返回值：

confusion matrix – 混淆矩阵。

返回类型：

sparse.csr_matrix

示例

>>> import numpy as np
>>> labels_true = np.array([0, 0, 1, 1])
>>> labels_pred = np.array([0, 0, 0, 1])
>>> get_confusion_matrix(labels_true, labels_pred).toarray()
array([[2, 0],
       [1, 1]])