代码编织梦想

一、前言

本文将回顾第四届“中国法研杯”司法人工智能挑战赛-刑期预测算法赛道比赛。使用多任务预训练、然后进行微调的形式最终在比赛中取得了三等奖的成绩。

二、任务介绍

主办方在第一届“中国法研杯”比赛上提出了刑期预测任务,本届将针对往届刑期预测准确率不高的罪名进行专项研究,并提供更多维度信息(如省份、年份)进行帮助提升。

三、数据集与分析

3.1、数据集介绍

本任务技术评测使用的训练集、验证集、测试集由中国司法大数据院提供,包含大约40余万篇裁判文书的犯罪事实、本院认为、刑期、年份、省份信息。

3.2、数据分析

  • 长文本:从图中可见,数据文本序列较长,需考虑长文本输入问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sqiICQN0-1684392501970)(F:\weixin\imgs\image-20230518121449610.png)]

  • 刑期分布:在给出的数据集中,刑期分布在1~234个月区间内,且不是连续的,因此在建模时本文没有使用回归预测的方法,而是使用文本分类的方法。

  • 案由分布:从下图可见,案由分布极不均衡。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DDrh08vh-1684392501971)(F:\weixin\imgs\image-20230518122030651.png)]

  • 数据样例

    在比赛过程中,本文收集了往年的法研杯比赛数据集,通过正则等手段清洗获得了与本次比赛案由相同的数据,进行多任务预训练。

    往年数据清洗过滤后的数据样例,该数据用于多任务预训练:

{
    "caseCause": "故意伤害罪", 
    "justice": "贵州省平坝县人民检察院指控:2014年4月9日下午,被告人王某丁与其堂哥王4某(另案处理)假释驾驶大货车(贵×××××)准备到乐某镇大屯村拉砂,行至大屯村时与被害人王某乙相遇,王4某与王某乙因琐事发生矛盾,准备打架时被路人劝开,双方离开现场。之后,王4某打电话邀约王某乙打架,接着又打电话召集郑3某、艾1某雷、邱某(均另案处理)、。王3某王6某、王某丁与艾1某雷、邱某、郑3某等人聚集后,行至乐某商务宾馆门前大街上时,与被害人高某乙、王某乙、王某甲、李某等人相遇,王4某、王某丁等人就从郑3某驾驶的面包车上拿出杀高某乙系创伤性、失血性休克死亡;王某甲所受之伤为轻伤一级;王某乙所受之伤为轻伤二级;李某所受之伤为轻微伤。公诉机关认为,被告人王某丁伙同王4某等人××他人身体,致一人死亡,二人受轻伤,一人受轻微伤,其行为触犯了《中华人民共和国刑法》××××,犯罪事实清楚,证据确实、充分,应当以××罪追究其刑事责任。王某丁在共同犯罪中其次起次要作用,是从犯,依法应当从轻、减轻或者免除处罚;其到案后如实公式供述自己的罪行,是坦白,依法可从轻处罚。根据《中华人民共和国刑事诉讼法》××的规定,特对被告人王某丁提起公诉。请依法判处。", 
    "opinion": "", 
    "judge": 42
}

​ 本次比赛的数据样例,该数据用于微调阶段:

{
    "caseCause": "走私普通货物、物品罪", 
    "justice": "经审理查明,2015年4月8日15时许,被告人刘某经拱北口岸旅检现场无申报通道进境,无书面向海关申报,被海关关员截查。关员从其携带的手提袋内查获“ ”牌酵素液2瓶、“”牌面霜1瓶、“”牌沐浴乳1瓶、“”牌洗碗精1瓶、“”牌果味软糖3瓶、“”牌花洒1个。被告人刘某自述其为赚取带工费人携带上列货物过关。经闸口海关核定,上述货物偷逃应缴税额共计人民币。 另查明,被告人刘某因走私分别于2014年8月17日、10月7日被闸口海关给予行政处罚。", 
    "opinion": "本院认为,被告人刘某一年内曾因走私被给予二次行政处罚后,又逃避海关监管,走私普通货物入境,其行为已构成走私普通货物罪。公诉机关指控的事实、罪名成立,应予支持。被告人刘某归案后如实供述自己的罪行,可从轻处罚。根据被告人刘某的犯罪情节和悔罪表现,适用缓刑确实不致再危害社会,可以宣告缓刑。依照《中华人民共和国刑法》第一百五十三条第一款第(一)项、第六十七条第三款、第七十二条第一款、第三款、第七十三条第一款、第三款、第五十二条、第六十四条的规定,", 
    "province": "广东省", 
    "judge": 1
}

四、评价指标

给定样本的预测刑期 y i ′ y_i^{\prime} yi和真实刑期 y i y_i yi,当前样本的分数为:
score ⁡ i = { 1 , ∣ y i − y i ′ ∣ ⩽ 0.25 y i 0 , ∣ y i − y i ′ ∣ > 0.25 y i \operatorname{score}_i=\left\{\begin{array}{l} 1,\left|y_i-y_i^{\prime}\right| \leqslant 0.25 y_i \\ 0,\left|y_i-y_i^{\prime}\right|>0.25 y_i \end{array}\right. scorei={1,yiyi0.25yi0,yiyi>0.25yi
即预测刑期和真实刑期的偏离程度≤25%视为正确,否则视为错误。测试集最终准确率为所有样本分数的均值。

五、解决方案

5.1、多任务预训练

所谓多任务预训练指的是在预训练阶段不仅仅是做了MLM任务,还利用往年数据做了一个有监督的分类任务,这种做法的动机是让预训练任务尽可能的贴近下游的微调任务,具体多任务损失函数设计如下:
L o s s 总 = l o s s m l m + l o s s c l s Loss_总=loss_{mlm}+loss_{cls} Loss=lossmlm+losscls

5.2、多任务预训练代码实现:

考虑到文本序列较长,本文在预训练基模型选型上选用了Nezha模型。

代码:

class NezhaPreTraining(NeZhaPreTrainedModel):
    _keys_to_ignore_on_load_unexpected = [r"seq_relationship"]

    def __init__(self, config):
        super().__init__(config)

        self.bert = NeZhaModel(config)
        self.cls = BertOnlyMLMHead(config)

        # 增加分类模块
        self.legal_cls = nn.Linear(config.hidden_size, config.num_labels)

        self.init_weights()

    def get_output_embeddings(self):
        return self.cls.predictions.decoder

    def set_output_embeddings(self, new_embeddings):
        self.cls.predictions.decoder = new_embeddings

    def forward(
            self,
            input_ids=None,
            attention_mask=None,
            token_type_ids=None,
            head_mask=None,
            position_ids=None,
            inputs_embeds=None,
            labels=None,
            next_sentence_label=None,
    ):
        outputs = self.bert(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
        )

        sequence_output, pooled_output = outputs[:2]
        prediction_scores = self.cls(sequence_output)
        seq_relationship_score = self.legal_cls(pooled_output)

        outputs = (prediction_scores, seq_relationship_score,) + outputs[2:]

        total_loss = None
        if labels is not None and next_sentence_label is not None:
            loss_fct = nn.CrossEntropyLoss()
            # MLM损失
            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
            # 分类损失
            next_sentence_loss = loss_fct(seq_relationship_score.view(-1, self.config.num_labels),
                                          next_sentence_label.view(-1))
            # 总损失
            total_loss = masked_lm_loss + next_sentence_loss
            outputs = (total_loss,) + outputs

        return outputs

5.3、微调

在比赛过程中,主要采用了两种模型结构实现微调,分别为Nezha+CNN、Nezha+LSTM和Nezha+Linear,下面直接上模型代码。

  • Nezha+CNN

    class NeZhaCNN(NeZhaPreTrainedModel):
        def __init__(self, config):
            super().__init__(config)
            self.num_labels = config.num_labels
            self.bert = NeZhaModel(config)
            self.dropout = nn.Dropout(config.hidden_dropout_prob)
            self.filter_num = 256
            self.filter_sizes = [3, 4, 5]
            self.convs = nn.ModuleList([nn.Conv2d(1, self.filter_num, (k, config.hidden_size)) for k in self.filter_sizes])
            self.fc_cnn = nn.Linear(self.filter_num * len(self.filter_sizes), self.config.num_labels)
            self.classifier = nn.Linear(config.hidden_size, self.config.num_labels)
            self.init_weights()
    
        @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
        def forward(
                self,
                input_ids=None,
                attention_mask=None,
                token_type_ids=None,
                position_ids=None,
                head_mask=None,
                inputs_embeds=None,
                labels=None,
        ):
    
            outputs = self.bert(
                input_ids,
                attention_mask=attention_mask,
                token_type_ids=token_type_ids,
                head_mask=head_mask,
                inputs_embeds=inputs_embeds,
            )
    
            last_hidden_state = outputs[0]
            x = last_hidden_state.unsqueeze(1)
            x = [F.relu(conv(x)).squeeze(3) for conv in self.convs]
            x = [F.max_pool1d(item, item.size(2)).squeeze(2) for item in x]
            x = torch.cat(x, 1)
            x = self.dropout(x)
            logits = self.fc_cnn(x)
            outputs = (logits,) + outputs[2:]
    
            if labels is not None:
                if self.num_labels == 1:
                    loss_fct = MSELoss()
                    loss = loss_fct(logits.view(-1), labels.view(-1))
                else:
                    loss_fct = CrossEntropyLoss()
                    loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
                outputs = (loss,) + outputs
    
            return outputs  # (loss), logits, (hidden_states), (attentions)
    
  • Nezha+LSTM

    class NeZhaLSTM(NeZhaPreTrainedModel):
        def __init__(self, config):
            super(NeZhaLSTM, self).__init__(config)
            self.num_labels = config.num_labels
            self.bert = NeZhaModel(config)
            self.dropout = nn.Dropout(config.hidden_dropout_prob)
            self.lstm = []
            self.lstm_hidden_size = 512
            self.lstm_layers = 1
            self.lstm_dropout = 0.1
            for i in range(self.lstm_layers):
                self.lstm.append(nn.LSTM(config.hidden_size if i == 0 else self.lstm_hidden_size * 4, self.lstm_hidden_size,
                                         num_layers=1, bidirectional=True, batch_first=True).cuda())
            self.lstm = nn.ModuleList(self.lstm)
    
            self.classifier = nn.Linear(self.lstm_hidden_size * 2, self.config.num_labels)
    
            self.init_weights()
    
        @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
        def forward(
                self,
                input_ids=None,
                attention_mask=None,
                token_type_ids=None,
                position_ids=None,
                head_mask=None,
                inputs_embeds=None,
                labels=None,
        ):
    
            outputs = self.bert(
                input_ids,
                attention_mask=attention_mask,
                token_type_ids=token_type_ids,
                head_mask=head_mask,
                inputs_embeds=inputs_embeds,
            )
    
            last_hidden_state = outputs[0]
            for lstm in self.lstm:
                try:
                    lstm.flatten_parameters()
                except:
                    pass
                output, (h_n, c_n) = lstm(last_hidden_state)
            x = h_n.permute(1, 0, 2).reshape(input_ids.size(0), -1).contiguous()
            x = self.dropout(x)
            logits = self.classifier(x)
            outputs = (logits,) + outputs[2:]  # add hidden states and attention if they are here
            if labels is not None:
                if self.num_labels == 1:
                    #  We are doing regression
                    loss_fct = MSELoss()
                    loss = loss_fct(logits.view(-1), labels.view(-1))
                else:
                    loss_fct = CrossEntropyLoss()
                    loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
                outputs = (loss,) + outputs
    
            return outputs  # (loss), logits, (hidden_states), (attentions)
    
  • Nezha+Linear

    class NeZhaForSequenceClassification(NeZhaPreTrainedModel):
        def __init__(self, config):
            super().__init__(config)
            self.num_labels = config.num_labels
            self.bert = NeZhaModel(config)
            self.dropout = nn.Dropout(config.hidden_dropout_prob)
            self.classifier = nn.Linear(config.hidden_size, config.num_labels)
            self.init_weights()
    
        @add_start_docstrings_to_model_forward(BERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
        def forward(
                self,
                input_ids=None,
                attention_mask=None,
                token_type_ids=None,
                position_ids=None,
                head_mask=None,
                inputs_embeds=None,
                labels=None,
        ):
    
            outputs = self.bert(
                input_ids,
                attention_mask=attention_mask,
                token_type_ids=token_type_ids,
                head_mask=head_mask,
                inputs_embeds=inputs_embeds,
            )
    
            pooled_output = outputs[1]
    
            pooled_output = self.dropout(pooled_output)
            logits = self.classifier(pooled_output)
    
            outputs = (logits,) + outputs[2:]  # add hidden states and attention if they are here
    
            if labels is not None:
                if self.num_labels == 1:
                    #  We are doing regression
                    loss_fct = MSELoss()
                    loss = loss_fct(logits.view(-1), labels.view(-1))
                else:
                    loss_fct = CrossEntropyLoss()
                    loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
                outputs = (loss,) + outputs
    
            return outputs  # (loss), logits, (hidden_states), (attentions)
    
    

5.4、Trick

  • FGM对抗训练

  • 模型融合

  • Focal Loss

六、评测性能

阶段性能
复赛阶段69.59
评审阶段74.22

六、总结

本文回顾了第四届“中国法研杯”司法人工智能挑战赛-刑期预测算法赛道比赛中的三等奖方案,使用多任务预训练和微调范式,并结合相关文本分类的上分trick优化nezha+CNN、nezha+LSTM和nezha+Linear三种结构模型,最终获得了不错的性能。

参考文献

比赛链接:http://data.court.gov.cn/pages/laic2021.html

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/yjh_SE007/article/details/130747027

文本分类(朴素贝叶斯算法)-爱代码爱编程

一、贝叶斯定理引入 1、朴素贝叶斯:   朴素贝叶斯中的朴素一词的来源就是假设各特征之间相互独立。这一假设使得朴素贝叶斯算法变得简单,但有时会牺牲一定的分类准确率。 2、贝叶斯公式: 3、换成分类任务的表达式   那么我们最终求的p(类别|特征)即可!就相当于完成了我们的任务。   分母的计算用到全概率公式(其实就是分子之和): 二、数

正向最大匹配算法(中文分词)-爱代码爱编程

一、最大匹配法   最大匹配是指以词典为依据,取词典中最长单词为第一个次取字数量的扫描串,在词典中进行扫描(为提升扫描效率,还可以跟据字数多少设计多个字典,然后根据字数分别从不同字典中进行扫描)。 最大匹配算法有三种:   1、正向最大匹配   2、逆向最大匹配   3、双向匹配   三种算法原理都一样,以正向为例,是从前向后扫描的过程。 如下: 二

TF-IDF算法和余弦相似度算法计算文本相似度(纯手撕)-爱代码爱编程

一、TF-IDF算法   TF-IDF(term frequency–inverse document frequency,词频-逆向文件频率)是一种用于信息检索(information retrieval)与文本挖掘(text mining)的常用加权技术。   TF-IDF是一种统计方法,用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要

HMM(隐马尔可夫)中文分词-爱代码爱编程

一、隐马尔可夫模型   隐马尔可夫模型(Hidden Markov Model,HMM)是用来描述一个含有隐含未知参数的马尔可夫过程。 1、举例理解   假设我手里有三个不同的骰子。第一个骰子是我们平常见的骰子(称这个骰子为D6),6个面,每个面(1,2,3,4,5,6)出现的概率是1/6。第二个骰子是个四面体(称这个骰子为D4),每个面(1,2,3

基于深度学习的kbqa方法(pipline)的一些思考(一)_nlp野指针的博客-爱代码爱编程

1、单跳问句回答思路 1.1 问句解析 1.1.1 实体抽取(识别) 序列标注模型:BERT+CRF 例子:姚明的老婆是谁? 获得问句中的实体:姚明 1.1.2 属性和关系抽取(识别) 分类模型:BERT+Lin

kbqa的主要流程及部分top竞赛方案总结_nlp野指针的博客-爱代码爱编程

一、KBQA的主要流程 1.1 什么是KBQA 给定自然语言问题,通过对问题进行语义理解和解析,进而利用知识库进行查询、推理得出答案 1.2 KBQA的实现范式 KBQA在技术上可以分成两种方案,分别是一种是语义

ccf大数据与计算智能大赛-基于人工智能的漏洞数据分类冠军方案-爱代码爱编程

基于人工智能的漏洞数据分类 前言 为及时跟踪国际信息安全趋势,需对国际公开的漏洞数据内容进行及时统计和梳理,例如CVE漏洞平台。CVE平台的漏洞信息包含有CVE编号、漏洞评分、漏洞描述等内容,其中漏洞描述含有对漏洞的利用

浅尝prompt咒语设计:one-爱代码爱编程

前言 近期以chatgpt等文生成LLMS爆火,国内也逐渐开源了中文版的chatgpt,本文以清华大学开源的6b的chatglm为例,实践one-shot微调,设计prompt咒语在信息抽取领域的实验效果。 1、场景描述

bigbird:大鸟模型中文生成式长文本摘要实践_bigbird模型-爱代码爱编程

1、介绍 BigBird 是一种基于稀疏注意力的Transformer,可将基于Transformer的模型(例如 BERT)扩展到更长的序列。 论文:https://arxiv.org/abs/2007.14062