如何用序列分类方式进行法律要素与当事人关联性分析

class ErnieForElementClassification(ErnieModel):
    def __init__(self, cfg, name=None):
        super(ErnieForElementClassification, self).__init__(cfg, name=name)
        initializer = F.initializer.TruncatedNormal(scale=cfg[initializer_range])
        self.classifier = _build_linear(cfg[hidden_size], cfg[num_labels], append_name(name, cls), initializer)  
        prob = cfg.get(classifier_dropout_prob, cfg[hidden_dropout_prob])
        self.dropout = lambda i: L.dropout(i, dropout_prob=prob,   dropout_implementation="upscale_in_train",) if self.training else i

    @add_docstring(ErnieModel.forward.__doc__)
    def forward(self, *args, **kwargs):
        labels = kwargs.pop(labels, None)
        pooled, encoded = super(ErnieForElementClassification, self).forward(*args, **kwargs)
        hidden = self.dropout(pooled)
        logits = self.classifier(hidden)
        logits = L.sigmoid(logits)
        sqz_logits = L.squeeze(logits, axes=[1])
        if labels is not None:
            if len(labels.shape) == 1:
                labels = L.reshape(labels, [-1, 1])
            part1 = L.elementwise_mul(labels, L.log(logits))
            part2 = L.elementwise_mul(1-labels, L.log(1-logits))
            loss = - L.elementwise_add(part1, part2)
            loss = L.reduce_mean(loss)
            return loss, sqz_logits
        else:
            return sqz_logits

def pad_data(file_name, tokenizer, max_len):
    """
        This function is used as the Dataset Class in PyTorch
    """
    # configuration:
    file_content = json.load(open(file_name, encoding=utf-8))
    data = []

    for line in file_content:
        paragraph = line[paragraph]
        person = line[person]
        element = line[element_name]
        sentence = line[sentence]
        ovalue = line["ovalue"]
        label = line[label]

        sentence_a = add_dollar2person(person) + element
        sentence_b = add_star2sentence(sentence, ovalue)

        src_id, sent_id = tokenizer.encode(sentence_a, sentence_b, truncate_to=max_len-3)      # 3 special tokens

        # pad src_id and sent_id (with 0 and 1 respectively)
        src_id = np.pad(src_id, [0, max_len-len(src_id)], constant, constant_values=0)
        sent_id = np.pad(sent_id, [0, max_len-len(sent_id)], constant, constant_values=1)

        data.append((src_id, sent_id, label))
    return data


def make_batches(data, batch_size, shuffle=True):
    """
        This function is used as the DataLoader Class in PyTorch
    """
    if shuffle:
        np.random.shuffle(data)
    loader = []
    for j in range(len(data)//batch_size):
        one_batch_data = data[j * batch_size:(j + 1) * batch_size]
        src_id, sent_id, label = zip(*one_batch_data)

        src_id = np.stack(src_id)
        sent_id = np.stack(sent_id)
        label = np.stack(label).astype(np.float32)  # change the data type to compute BCELoss conveniently

        loader.append((src_id, sent_id, label))
    return loader

def train(model, dataset, lr=1e-5, batch_size=1, epochs=10):

    max_steps = epochs * (len(dataset) // batch_size)
    # max_train_steps = args.epoch * num_train_examples // args.batch_size  // dev_count
    optimizer = AdamW(
        # learning_rate=LinearDecay(lr, int(0), max_steps),
        learning_rate=lr,
        parameter_list=model.parameters(),
        weight_decay=0)

    model.train()
    logging.info(start training process!)
    for epoch in range(epochs):
        # shuffle the dataset every epoch by reloading it
        data_loader = make_batches(dataset, batch_size=batch_size, shuffle=True)

        running_loss = 0.0
        for i, data in enumerate(data_loader):
            # prepare inputs for the model
            src_ids, sent_ids, labels = data

            # convert numpy variables to paddle variables
            src_ids = D.to_variable(src_ids)
            sent_ids = D.to_variable(sent_ids)
            labels = D.to_variable(labels)

            # feed into the model
            outs = model(src_ids, sent_ids, labels=labels)

            loss = outs[0]
            loss.backward()
            optimizer.minimize(loss)
            model.clear_gradients()

            running_loss += loss.numpy()[0]
            if i % 10 == 9:
                print(epoch: , epoch + 1, 	step: , i + 1, 	running_loss: , running_loss)
                running_loss = 0.0

        state_dict = model.state_dict()
        F.save_dygraph(state_dict, ./saved/plan3_all/model_+str(epoch+1)+epoch)
        print(model_+str(epoch+1)+epoch saved)

    logging.info(all model parameters saved!)