LayerDropout方法

最新推荐文章于 2023-12-29 20:16:31 发布

Sy丶

最新推荐文章于 2023-12-29 20:16:31 发布

阅读量1.2k

点赞数 2

分类专栏： NLP 文章标签：人工智能深度学习

本文链接：https://blog.csdn.net/ShineY_7/article/details/127509354

版权

NLP 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

简介：

一种结构化的dropout形式，它在训练过程中具有正则化效果，并允许在推理时有效地剪枝。

方法的核心是在训练过程中，通过随机丢弃模型权重，从大模型中抽取小的子网络，如Dropout或Dropconnect，这具有使网络对后续剪枝具有鲁棒性的优点。

贡献：

•LayerDrop使非常深的transformer正则化并稳定其训练，从而在各种基准测试中获得最先进的性能。

•可以在测试时从一个预先训练的大模型中自动提取任何深度的小而有效的模型，而不需要进行精细调整。

•LayerDrop易于实现。

在BART模型上实现的代码：

        for idx, decoder_layer in enumerate(self.layers):
            # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
            if output_hidden_states:
                all_hidden_states += (hidden_states,)
            dropout_probability = random.uniform(0, 1)
            if self.training and (dropout_probability < self.layerdrop):
                continue

            past_key_value = past_key_values[idx] if past_key_values is not None else None

            if getattr(self.config, "gradient_checkpointing", False) and self.training:

                if use_cache:
                    logger.warning(
                        "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
                        "`use_cache=False`..."
                    )
                    use_cache = False

                def create_custom_forward(module):
                    def custom_forward(*inputs):
                        # None for past_key_value
                        return module(*inputs, output_attentions, use_cache)

                    return custom_forward

                layer_outputs = torch.utils.checkpoint.checkpoint(
                    create_custom_forward(decoder_layer),
                    hidden_states,
                    attention_mask,
                    encoder_hidden_states,
                    encoder_attention_mask,
                    head_mask[idx] if head_mask is not None else None,
                    cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None,
                    None,
                )
            else:

                layer_outputs = decoder_layer(
                    hidden_states,
                    attention_mask=attention_mask,
                    encoder_hidden_states=encoder_hidden_states,
                    encoder_attention_mask=encoder_attention_mask,
                    layer_head_mask=(head_mask[idx] if head_mask is not None else None),
                    cross_attn_layer_head_mask=(
                        cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None
                    ),
                    past_key_value=past_key_value,
                    output_attentions=output_attentions,
                    use_cache=use_cache,
                )
            hidden_states = layer_outputs[0]

            if use_cache:
                next_decoder_cache += (layer_outputs[3 if output_attentions else 1],)

            if output_attentions:
                all_self_attns += (layer_outputs[1],)

                if encoder_hidden_states is not None:
                    all_cross_attentions += (layer_outputs[2],)