学术讲座: 多标签主动学习之 MASP

闵帆

已于 2022-06-11 09:59:00 修改

阅读量604

点赞数

分类专栏：学术报告文章标签：学习机器学习人工智能

于 2022-06-09 15:44:28 首次发布

本文链接：https://blog.csdn.net/minfanphd/article/details/125199420

版权

学术报告专栏收录该内容

12 篇文章 2 订阅

订阅专栏

摘要: 本贴解读我们的刚录用的论文 Xue-Yang Min, Kun Qian, Ben-Wen Zhang, Guojie Song, and Fan Min, Multi-label active learning through serial-parallel neural networks, Knowledge-Based Systems (2022) pp. xxx. doi: yyy.

1. 问题描述

从简单到复杂, 为多标签学习、多标签主动学习.

1.1 多标签学习

这里是多标签学习专题讲座.
定义1. 多标签数据为一个二元组:
$(\mathbf{X}, \mathbf{Y}), \tag{1}$
其中

$\mathbf{X} = (\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_N)^{\mathrm{T}} = (x_{ij})_{N \times M}$ 为条件属性矩阵;
$\mathbf{Y} = (\mathbf{y}_1, \mathbf{y}_2, \dots, \mathbf{y}_N)^{\mathrm{T}} = (y_{ij})_{N \times L}$ 为标签矩阵;
$N$ 为对象数;
$M$ 为条件属性数;
$L$ 为标签数;
$y_{ij} = 1$ 表示 $\mathbf{x}_i$ 具有标签 $j$ , $y_{ij} = -1$ 表示不具有.

多标签学习就是根据 $S$ 建立一个分类器, 并用于未知实例的预测.

1.2 带缺失标签的多标签学习

$y_{ij} = 0$ 表示 $\mathbf{x}_i$ 是否具有标签 $j$ .
实际数据多半具有标签缺失的特点, 在很多情况下缺失还非常严重.

1.3 多标签主动学习

允许学习器进行标签的查询. 作为一种最简单的场景, , 需要进行一定轮次的查询才能构建良好的学习器.

问题 1. 有限预算的冷启动多标签学习。
输入: $\mathbf{X}$ , $\mathbf{Y}$ (仅专家知道), 查询上限 $Q$ ;
输出: 预测模型 $\Theta: \mathbb{R}^M \to \{-1, +1\}^L$ , 查询的实例-标签对集合 $\mathbf{Q}$ .
优化目标: $\Theta$ 的预测精度.

说明:

初始状态下所有标签都缺失. 这样利于不同算法的比较.
基于池的查询, 即实例-标签对的查询没有顺序限制. 这与 在线主动学习 不同.
批量查询. 可以节约时间.
查询量 $Q$ 预先指定. 这是专家工作量.
在未见实例上测试. 不同于直推机.

2. 学习模型

图 1. 学习模型

串行部分用于属性提取.
- 也用于应对标签相关性.
并行部分用于预测.
- 成对的预测提供更稳定的结果.
- 对于缺失标签, 就不进行相应的惩罚.
- 预测的时候既可以直接获得标签, 又可以通过 softmax 转换为一个概率值.
简单起见, 未画出偏移量.
为适应 GPU, 每层节点数为 64, 128 等. GPU 真香呀!
定制一个网络很方便. Python 也香呀！

如果需要实型的预测, 就使用 softmax 函数:
$\hat{y}'_{ik} = \frac{\exp g_k^+(f(\mathbf{x}_i))}{\exp g_k^+(f(\mathbf{x}_i)) + \exp g_k^-(f(\mathbf{x}_i))}.$

class ParallelAnn(nn.Module):
    """
    Parallel ANN.

    This class handles the parallel part.
    """

    def __init__(self, para_parallel_layer_num_nodes: list = None, para_activators: str = "s" * 100):
        super().__init__()

        temp_model = []
        for i in range(len(para_parallel_layer_num_nodes) - 1):
            temp_input = para_parallel_layer_num_nodes[i]
            temp_output = para_parallel_layer_num_nodes[i + 1]
            temp_linear = nn.Linear(temp_input, temp_output)
            temp_model.append(temp_linear)
            temp_model.append(get_activator(para_activators[i]))
        self.model = nn.Sequential(*temp_model)

    def forward(self, para_input: torch.tensor = None):
        temp_output = self.model(para_input)
        return temp_output


class MultiLabelAnn(nn.Module):
    """
    Multi-label ANN.

    This class handles the whole network.
    """

    def __init__(self, para_dataset: MultiLabelData = None, para_full_connect_layer_num_nodes: list = None,
                 para_parallel_layer_num_nodes: list = None, para_learning_rate: float = 0.01,
                 para_mobp: float = 0.6, para_activators: str = "s" * 100, para_device=None):
        super().__init__()
        self.dataset = para_dataset
        self.num_parts = self.dataset.num_labels
        self.num_layers = len(para_full_connect_layer_num_nodes) + len(para_parallel_layer_num_nodes)
        self.learning_rate = para_learning_rate
        self.mobp = para_mobp
        self.device = para_device
        self.skip_count = 0  # For cost-sensitive learning.

        temp_model = []
        for i in range(len(para_full_connect_layer_num_nodes) - 1):
            temp_input = para_full_connect_layer_num_nodes[i]
            temp_output = para_full_connect_layer_num_nodes[i + 1]
            temp_linear = nn.Linear(temp_input, temp_output)
            temp_model.append(temp_linear)
            temp_model.append(get_activator(para_activators[i]))

        self.full_connect_model = nn.Sequential(*temp_model)

        temp_parallel_activators = para_activators[len(para_full_connect_layer_num_nodes) - 1:]
        self.parallel_model = [ParallelAnn(para_parallel_layer_num_nodes, temp_parallel_activators).to(self.device)
                               for _ in range(self.dataset.num_labels)]

        self.my_optimizer = torch.optim.Adam(itertools.chain(self.full_connect_model.parameters(),
                                                             *[model.parameters() for model in self.parallel_model]),
                                             lr=para_learning_rate)
        self.my_loss_function = nn.MSELoss().to(para_device)

    def forward(self, para_input: np.ndarray = None):
        temp_input = torch.tensor(para_input, dtype=torch.float).to(self.device)
        temp_inner_output = self.full_connect_model(temp_input)
        temp_inner_output = [model(temp_inner_output) for model in self.parallel_model]
        temp_output = temp_inner_output[0]
        for i in range(len(temp_inner_output) - 1):
            temp_output = torch.cat((temp_output, temp_inner_output[i + 1]), -1)
        return temp_output

3. 学习场景

图 2. 学习场景

$\mathbf{X}$ 已知.
$\mathbf{Y}'$ 通过查询 $\mathbf{Y}$ 获得. 简化起见未画出人类专家.
使用 $\mathbf{X}$ 和 $\mathbf{Y}'$ 训练网络.

4. 实例-标签对选择方案

主动学习的核心就是进行实例-标签对选择.

4.1 实例代表性 (根据 $\mathbf{X}$ 计算).

参见日撸 Java 三百行第 66 天
实例密度:
$\rho_i = \sum_{j \neq i} e^{- \left(\frac{d_{ij}}{d_c}\right)^2},$
其中 $d_{ij}$ 是 $\mathbf{x}_i$ 与 $\mathbf{x}_j$ 之间的距离, $d_c$ 为一个用户设置的阈值. 如果数据已经归一化, 可设置 $d_c = 0.1$ .
实例到父节点的距离:
$\delta_i = \min_{\rho_j > \rho_i} d_{ij}.$
实例代表性:
$\gamma_i = \rho_i \delta_i.$

4.2 标签稀疏性 (根据 $\mathbf{Y}'$ 计算).

$\psi_k = 1 - \frac{\vert \mathbf{Q} \cap \{1, 2, \dots, N\} \times \{k\} \vert}{N}.$

4.3 标签不确定性 (根据成对的预测值计算).

$\eta(i, k) = \left\{\begin{array}{ll} 0, & \textrm{ if } y_{ik} \textrm{ is queried;}\\ 1 - \left\vert g_k^-(f(\mathbf{x}_i)) - g_k^+(f(\mathbf{x}_i)) \right\vert, & \textrm{ otherwise.}\end{array}\right.$