南有芙蕖

PaddleNLP实战——LIC2021关系抽取任务基线（附代码）

PaddleNLP实战——LIC2021关系抽取任务基线

PaddleNLP实战——LIC2021关系抽取任务基线
- 一、关系抽取基线
- - 评价方法
  - 1.1 快速复现基线Step1：构建模型
  - 1.2 快速复现基线Step2：加载并处理数据
  - 1.3 快速复现基线Step3：定义损失函数和优化器，开始训练
  - 1.4 快速复现基线Step4：提交预测结果
- 二、Tricks
- - 2.1 尝试更多的预训练模型
  - 2.2 模型集成
- 参考资料

一、关系抽取基线

针对 DuIE2.0 任务中多条、交叠SPO这一抽取目标，比赛对标准的 ‘BIO’ 标注进行了扩展。 对于每个 token，根据其在实体span中的位置（包括B、I、O三种），我们为其打上三类标签，并且根据其所参与构建的predicate种类，将 B 标签进一步区分。给定 schema 集合，对于 N 种不同 predicate，以及头实体/尾实体两种情况，我们设计对应的共 2N 种 B 标签，再合并 I 和 O 标签，故每个 token 一共有 (2N+2) 个标签，如下图所示。

评价方法

对测试集上参评系统输出的SPO结果和人工标注的SPO结果进行精准匹配，采用F1值作为评价指标。注意，对于复杂O值类型的SPO，必须所有槽位都精确匹配才认为该SPO抽取正确。针对部分文本中存在实体别名的问题，使用百度知识图谱的别名词典来辅助评测。F1值的计算方式如下：

F1 = (2 * P * R) / (P + R)，其中

• P = 测试集所有句子中预测正确的SPO个数 / 测试集所有句子中预测出的SPO个数
• R = 测试集所有句子中预测正确的SPO个数 / 测试集所有句子中人工标注的SPO个数

1.1 快速复现基线Step1：构建模型

该任务可以看作一个序列标注任务，所以基线模型采用的是ERNIE序列标注模型。

PaddleNLP提供了ERNIE预训练模型常用序列标注模型，可以通过指定模型名字完成一键加载。PaddleNLP为了方便用户处理数据，内置了对于各个预训练模型对应的Tokenizer，可以完成文本token化，转token ID，文本长度截断等操作。

文本数据处理直接调用tokenizer即可输出模型所需输入数据。

import os
import json
from paddlenlp.transformers import ErnieForTokenClassification, ErnieTokenizer

label_map_path = os.path.join('data', "predicate2id.json")
if not (os.path.exists(label_map_path) and os.path.isfile(label_map_path)):
    sys.exit("{} dose not exists or is not a file.".format(label_map_path))
with open(label_map_path, 'r', encoding='utf8') as fp:
    label_map = json.load(fp)
num_classes = (len(label_map.keys()) - 2) * 2 + 2

model = ErnieForTokenClassification.from_pretrained("ernie-1.0", num_classes=(len(label_map) - 2) * 2 + 2)
tokenizer = ErnieTokenizer.from_pretrained("ernie-1.0")

inputs = tokenizer(text="请输入测试样例", max_seq_len=20)

[2021-04-12 08:24:15,835] [    INFO] - Downloading https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams and saved to /home/aistudio/.paddlenlp/models/ernie-1.0
[2021-04-12 08:24:15,838] [    INFO] - Downloading ernie_v1_chn_base.pdparams from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams
100%|██████████| 390123/390123 [00:05<00:00, 68401.29it/s]
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for classifier.weight. classifier.weight is not found in the provided dict.
  warnings.warn(("Skip loading for {}. ".format(key) + str(err)))
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for classifier.bias. classifier.bias is not found in the provided dict.
  warnings.warn(("Skip loading for {}. ".format(key) + str(err)))
[2021-04-12 08:24:26,844] [    INFO] - Downloading vocab.txt from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/vocab.txt
100%|██████████| 89/89 [00:00<00:00, 4123.60it/s]

1.2 快速复现基线Step2：加载并处理数据

从比赛官网下载数据集，解压存放于data/目录下并重命名为train_data.json, dev_data.json, test_data.json.

我们可以加载自定义数据集。通过继承paddle.io.Dataset，自定义实现__getitem__ 和 __len__两个方法。

from typing import Optional, List, Union, Dict

import numpy as np
import paddle
from tqdm import tqdm
from paddlenlp.utils.log import logger

from data_loader import parse_label, DataCollator, convert_example_to_feature
from extract_chinese_and_punct import ChineseAndPunctuationExtractor


class DuIEDataset(paddle.io.Dataset):
    """
    Dataset of DuIE.
    """

    def __init__(
            self,
            input_ids: List[Union[List[int], np.ndarray]],
            seq_lens: List[Union[List[int], np.ndarray]],
            tok_to_orig_start_index: List[Union[List[int], np.ndarray]],
            tok_to_orig_end_index: List[Union[List[int], np.ndarray]],
            labels: List[Union[List[int], np.ndarray, List[str], List[Dict]]]):
        super(DuIEDataset, self).__init__()

        self.input_ids = input_ids
        self.seq_lens = seq_lens
        self.tok_to_orig_start_index = tok_to_orig_start_index
        self.tok_to_orig_end_index = tok_to_orig_end_index
        self.labels = labels

    def __len__(self):
        if isinstance(self.input_ids, np.ndarray):
            return self.input_ids.shape[0]
        else:
            return len(self.input_ids)

    def __getitem__(self, item):
        return {
     
            "input_ids": np.array(self.input_ids[item]),
            "seq_lens": np.array(self.seq_lens[item]),
            "tok_to_orig_start_index":
            np.array(self.tok_to_orig_start_index[item]),
            "tok_to_orig_end_index": np.array(self.tok_to_orig_end_index[item]),
            # If model inputs is generated in `collate_fn`, delete the data type casting.
            "labels": np.array(
                self.labels[item], dtype=np.float32),
        }

    @classmethod
    def from_file(cls,
                  file_path: Union[str, os.PathLike],
                  tokenizer: ErnieTokenizer,
                  max_length: Optional[int]=512,
                  pad_to_max_length: Optional[bool]=None):
        assert os.path.exists(file_path) and os.path.isfile(
            file_path), f"{file_path} dose not exists or is not a file."
        label_map_path = os.path.join(
            os.path.dirname(file_path), "predicate2id.json")
        assert os.path.exists(label_map_path) and os.path.isfile(
            label_map_path
        ), f"{label_map_path} dose not exists or is not a file."
        with open(label_map_path, 'r', encoding='utf8') as fp:
            label_map = json.load(fp)
        chineseandpunctuationextractor = ChineseAndPunctuationExtractor()

        input_ids, seq_lens, tok_to_orig_start_index, tok_to_orig_end_index, labels = (
            [] for _ in range(5))
        dataset_scale = sum(1 for line in open(file_path, 'r'))
        logger.info("Preprocessing data, loaded from %s" % file_path)
        with open(file_path, "r", encoding="utf-8") as fp:
            lines = fp.readlines()
            for line in tqdm(lines):
                example = json.loads(line)
                input_feature = convert_example_to_feature(
                    example, tokenizer, chineseandpunctuationextractor,
                    label_map, max_length, pad_to_max_length)
                input_ids.append(input_feature.input_ids)
                seq_lens.append(input_feature.seq_len)
                tok_to_orig_start_index.append(
                    input_feature.tok_to_orig_start_index)
                tok_to_orig_end_index.append(
                    input_feature.tok_to_orig_end_index)
                labels.append(input_feature.labels)

        return cls(input_ids, seq_lens, tok_to_orig_start_index,
                   tok_to_orig_end_index, labels)

data_path = 'data'
batch_size = 32
max_seq_length = 128

train_file_path = os.path.join(data_path, 'train_data.json')
train_dataset = DuIEDataset.from_file(
    train_file_path, tokenizer, max_seq_length, True)
train_batch_sampler = paddle.io.BatchSampler(
    train_dataset, batch_size=batch_size, shuffle=True, drop_last=True)
collator = DataCollator()
train_data_loader = paddle.io.DataLoader(
    dataset=train_dataset,
    batch_sampler=train_batch_sampler,
    collate_fn=collator)

eval_file_path = os.path.join(data_path, 'dev_data.json')
test_dataset = DuIEDataset.from_file(
    eval_file_path, tokenizer, max_seq_length, True)
test_batch_sampler = paddle.io.BatchSampler(
    test_dataset, batch_size=batch_size, shuffle=False, drop_last=True)
test_data_loader = paddle.io.DataLoader(
    dataset=test_dataset,
    batch_sampler=test_batch_sampler,
    collate_fn=collator)

[2021-04-12 08:27:21,552] [    INFO] - Preprocessing data, loaded from data/train_data.json
100%|██████████| 171293/171293 [05:17<00:00, 538.88it/s]
[2021-04-12 08:32:39,914] [    INFO] - Preprocessing data, loaded from data/dev_data.json
100%|██████████| 20674/20674 [00:38<00:00, 543.74it/s]

1.3 快速复现基线Step3：定义损失函数和优化器，开始训练

在该基线上，我们选择均方误差作为损失函数，使用paddle.optimizer.AdamW作为优化器。

在训练过程中，模型保存在当前目录checkpoints文件夹下。同时在训练的同时使用官方评测脚本进行评估，输出P/R/F1指标。在验证集上F1可以达到69.42。

import paddle.nn as nn

class BCELossForDuIE(nn.Layer):
    def __init__(self, ):
        super(BCELossForDuIE, self).__init__()
        self.criterion = nn.BCEWithLogitsLoss(reduction='none')

    def forward(self, logits, labels, mask):
        loss = self.criterion(logits, labels)
        mask = paddle.cast(mask, 'float32')
        loss = loss * mask.unsqueeze(-1)
        loss = paddle.sum(loss.mean(axis=2), axis=1) / paddle.sum(mask, axis=1)
        loss = loss.mean()
        return loss

from utils import write_prediction_results, get_precision_recall_f1, decoding

@paddle.no_grad()
def evaluate(model, criterion, data_loader, file_path, mode):
    """
    mode eval:
    eval on development set and compute P/R/F1, called between training.
    mode predict:
    eval on development / test set, then write predictions to \
        predict_test.json and predict_test.json.zip \
        under args.data_path dir for later submission or evaluation.
    """
    model.eval()
    probs_all = None
    seq_len_all = None
    tok_to_orig_start_index_all = None
    tok_to_orig_end_index_all = None
    loss_all = 0
    eval_steps = 0
    for batch in tqdm(data_loader, total=len(data_loader)):
        eval_steps += 1
        input_ids, seq_len, tok_to_orig_start_index, tok_to_orig_end_index, labels = batch
        logits = model(input_ids=input_ids)
        mask = (input_ids != 0).logical_and((input_ids != 1)).logical_and(
            (input_ids != 2))
        loss = criterion(logits, labels, mask)
        loss_all += loss.numpy().item()
        probs = F.sigmoid(logits)
        if probs_all is None:
            probs_all = probs.numpy()
            seq_len_all = seq_len.numpy()
            tok_to_orig_start_index_all = tok_to_orig_start_index.numpy()
            tok_to_orig_end_index_all = tok_to_orig_end_index.numpy()
        else:
            probs_all = np.append(probs_all, probs.numpy(), axis=0)
            seq_len_all = np.append(seq_len_all, seq_len.numpy(), axis=0)
            tok_to_orig_start_index_all = np.append(
                tok_to_orig_start_index_all,
                tok_to_orig_start_index.numpy(),
                axis=0)
            tok_to_orig_end_index_all = np.append(
                tok_to_orig_end_index_all,
                tok_to_orig_end_index.numpy(),
                axis=0)
    loss_avg = loss_all / eval_steps
    print("eval loss: %f" % (loss_avg))

    id2spo_path = os.path.join(os.path.dirname(file_path), "id2spo.json")
    with open(id2spo_path, 'r', encoding='utf8') as fp:
        id2spo = json.load(fp)
    formatted_outputs = decoding(file_path, id2spo, probs_all, seq_len_all,
                                 tok_to_orig_start_index_all,
                                 tok_to_orig_end_index_all)
    if mode == "predict":
        predict_file_path = os.path.join(data_path, 'predictions.json')
    else:
        predict_file_path = os.path.join(data_path, 'predict_eval.json')

    predict_zipfile_path = write_prediction_results(formatted_outputs,
                                                    predict_file_path)

    if mode == "eval":
        precision, recall, f1 = get_precision_recall_f1(file_path,
                                                        predict_zipfile_path)
        os.system('rm {} {}'.format(predict_file_path, predict_zipfile_path))
        return precision, recall, f1
    elif mode != "predict":
        raise Exception("wrong mode for eval func")

from paddlenlp.transformers import LinearDecayWithWarmup

learning_rate = 2e-5
num_train_epochs = 5
warmup_ratio = 0.06

criterion = BCELossForDuIE()
# Defines learning rate strategy.
steps_by_epoch = len(train_data_loader)
num_training_steps = steps_by_epoch * num_train_epochs
lr_scheduler = LinearDecayWithWarmup(learning_rate, num_training_steps, warmup_ratio)
optimizer = paddle.optimizer.AdamW(
    learning_rate=lr_scheduler,
    parameters=model.parameters(),
    apply_decay_param_fun=lambda x: x in [
        p.name for n, p in model.named_parameters()
        if not any(nd in n for nd in ["bias", "norm"])])

# 模型参数保存路径
!mkdir checkpoints

import time
import paddle.nn.functional as F

# Starts training.
global_step = 0
logging_steps = 50
save_steps = 10000
num_train_epochs = 2
output_dir = 'checkpoints'
tic_train = time.time()
model.train()
for epoch in range(num_train_epochs):
    print("\n=====start training of %d epochs=====" % epoch)
    tic_epoch = time.time()
    for step, batch in enumerate(train_data_loader):
        input_ids, seq_lens, tok_to_orig_start_index, tok_to_orig_end_index, labels = batch
        logits = model(input_ids=input_ids)
        mask = (input_ids != 0).logical_and((input_ids != 1)).logical_and(
            (input_ids != 2))
        loss = criterion(logits, labels, mask)
        loss.backward()
        optimizer.step()
        lr_scheduler.step()
        optimizer.clear_gradients()
        loss_item = loss.numpy().item()

        if global_step % logging_steps == 0:
            print(
                "epoch: %d / %d, steps: %d / %d, loss: %f, speed: %.2f step/s"
                % (epoch, num_train_epochs, step, steps_by_epoch,
                    loss_item, logging_steps / (time.time() - tic_train)))
            tic_train = time.time()

        if global_step % save_steps == 0 and global_step != 0:
            print("\n=====start evaluating ckpt of %d steps=====" %
                    global_step)
            precision, recall, f1 = evaluate(
                model, criterion, test_data_loader, eval_file_path, "eval")
            print("precision: %.2f\t recall: %.2f\t f1: %.2f\t" %
                    (100 * precision, 100 * recall, 100 * f1))
            print("saving checkpoing model_%d.pdparams to %s " %
                    (global_step, output_dir))
            paddle.save(model.state_dict(),
                        os.path.join(output_dir, 
                                        "model_%d.pdparams" % global_step))
            model.train()

        global_step += 1
    tic_epoch = time.time() - tic_epoch
    print("epoch time footprint: %d hour %d min %d sec" %
            (tic_epoch // 3600, (tic_epoch % 3600) // 60, tic_epoch % 60))

# Does final evaluation.
print("\n=====start evaluating last ckpt of %d steps=====" %
        global_step)
precision, recall, f1 = evaluate(model, criterion, test_data_loader,
                                    eval_file_path, "eval")
print("precision: %.2f\t recall: %.2f\t f1: %.2f\t" %
        (100 * precision, 100 * recall, 100 * f1))
paddle.save(model.state_dict(),
            os.path.join(output_dir,
                            "model_%d.pdparams" % global_step))
print("\n=====training complete=====")


=====start training of 0 epochs=====
epoch: 0 / 2, steps: 0 / 5352, loss: 0.721817, speed: 100.65 step/s
epoch: 0 / 2, steps: 50 / 5352, loss: 0.710706, speed: 4.35 step/s
epoch: 0 / 2, steps: 100 / 5352, loss: 0.681220, speed: 4.33 step/s
epoch: 0 / 2, steps: 150 / 5352, loss: 0.608591, speed: 4.17 step/s
epoch: 0 / 2, steps: 200 / 5352, loss: 0.418718, speed: 4.30 step/s
epoch: 0 / 2, steps: 250 / 5352, loss: 0.307587, speed: 4.31 step/s
epoch: 0 / 2, steps: 300 / 5352, loss: 0.260866, speed: 4.29 step/s
epoch: 0 / 2, steps: 350 / 5352, loss: 0.229669, speed: 4.28 step/s
epoch: 0 / 2, steps: 400 / 5352, loss: 0.205042, speed: 4.28 step/s
epoch: 0 / 2, steps: 450 / 5352, loss: 0.180981, speed: 4.29 step/s
epoch: 0 / 2, steps: 500 / 5352, loss: 0.161323, speed: 4.29 step/s
epoch: 0 / 2, steps: 550 / 5352, loss: 0.143654, speed: 4.29 step/s
epoch: 0 / 2, steps: 600 / 5352, loss: 0.126170, speed: 4.29 step/s
epoch: 0 / 2, steps: 650 / 5352, loss: 0.110170, speed: 4.28 step/s
epoch: 0 / 2, steps: 700 / 5352, loss: 0.098008, speed: 4.13 step/s
epoch: 0 / 2, steps: 750 / 5352, loss: 0.086216, speed: 4.28 step/s
epoch: 0 / 2, steps: 800 / 5352, loss: 0.076197, speed: 4.29 step/s
epoch: 0 / 2, steps: 850 / 5352, loss: 0.067776, speed: 4.27 step/s
epoch: 0 / 2, steps: 900 / 5352, loss: 0.060580, speed: 4.29 step/s
epoch: 0 / 2, steps: 950 / 5352, loss: 0.053458, speed: 4.29 step/s
epoch: 0 / 2, steps: 1000 / 5352, loss: 0.049620, speed: 4.28 step/s
epoch: 0 / 2, steps: 1050 / 5352, loss: 0.045512, speed: 4.30 step/s
epoch: 0 / 2, steps: 1100 / 5352, loss: 0.041225, speed: 4.26 step/s
epoch: 0 / 2, steps: 1150 / 5352, loss: 0.038455, speed: 4.28 step/s
epoch: 0 / 2, steps: 1200 / 5352, loss: 0.033661, speed: 4.20 step/s
epoch: 0 / 2, steps: 1250 / 5352, loss: 0.031614, speed: 4.31 step/s
epoch: 0 / 2, steps: 1300 / 5352, loss: 0.030919, speed: 4.32 step/s
epoch: 0 / 2, steps: 1350 / 5352, loss: 0.028184, speed: 4.15 step/s
epoch: 0 / 2, steps: 1400 / 5352, loss: 0.022967, speed: 4.30 step/s
epoch: 0 / 2, steps: 1450 / 5352, loss: 0.022758, speed: 4.27 step/s
epoch: 0 / 2, steps: 1500 / 5352, loss: 0.020432, speed: 4.25 step/s
epoch: 0 / 2, steps: 1550 / 5352, loss: 0.019004, speed: 4.27 step/s
epoch: 0 / 2, steps: 1600 / 5352, loss: 0.017774, speed: 4.23 step/s
epoch: 0 / 2, steps: 1650 / 5352, loss: 0.016835, speed: 4.25 step/s
epoch: 0 / 2, steps: 1700 / 5352, loss: 0.016313, speed: 4.27 step/s
epoch: 0 / 2, steps: 1750 / 5352, loss: 0.014991, speed: 4.26 step/s
epoch: 0 / 2, steps: 1800 / 5352, loss: 0.013867, speed: 4.24 step/s
epoch: 0 / 2, steps: 1850 / 5352, loss: 0.013067, speed: 4.30 step/s
epoch: 0 / 2, steps: 1900 / 5352, loss: 0.012588, speed: 4.28 step/s
epoch: 0 / 2, steps: 1950 / 5352, loss: 0.012091, speed: 4.22 step/s
epoch: 0 / 2, steps: 2000 / 5352, loss: 0.011783, speed: 4.26 step/s
epoch: 0 / 2, steps: 2050 / 5352, loss: 0.014299, speed: 4.25 step/s
epoch: 0 / 2, steps: 2100 / 5352, loss: 0.010042, speed: 4.28 step/s
epoch: 0 / 2, steps: 2150 / 5352, loss: 0.010234, speed: 4.24 step/s
epoch: 0 / 2, steps: 2200 / 5352, loss: 0.010122, speed: 4.30 step/s
epoch: 0 / 2, steps: 2250 / 5352, loss: 0.008944, speed: 4.22 step/s
epoch: 0 / 2, steps: 2300 / 5352, loss: 0.009281, speed: 4.34 step/s
epoch: 0 / 2, steps: 2350 / 5352, loss: 0.009252, speed: 4.25 step/s
epoch: 0 / 2, steps: 2400 / 5352, loss: 0.010335, speed: 4.26 step/s
epoch: 0 / 2, steps: 2450 / 5352, loss: 0.009249, speed: 4.29 step/s
epoch: 0 / 2, steps: 2500 / 5352, loss: 0.009273, speed: 4.24 step/s
epoch: 0 / 2, steps: 2550 / 5352, loss: 0.007440, speed: 4.28 step/s
epoch: 0 / 2, steps: 2600 / 5352, loss: 0.008797, speed: 4.29 step/s
epoch: 0 / 2, steps: 2650 / 5352, loss: 0.008859, speed: 4.28 step/s
epoch: 0 / 2, steps: 2700 / 5352, loss: 0.008952, speed: 4.32 step/s
epoch: 0 / 2, steps: 2750 / 5352, loss: 0.007367, speed: 4.29 step/s
epoch: 0 / 2, steps: 2800 / 5352, loss: 0.007996, speed: 4.19 step/s
epoch: 0 / 2, steps: 2850 / 5352, loss: 0.007748, speed: 4.30 step/s
epoch: 0 / 2, steps: 2900 / 5352, loss: 0.007244, speed: 4.29 step/s
epoch: 0 / 2, steps: 2950 / 5352, loss: 0.006419, speed: 4.25 step/s
epoch: 0 / 2, steps: 3000 / 5352, loss: 0.007522, speed: 4.29 step/s
epoch: 0 / 2, steps: 3050 / 5352, loss: 0.007346, speed: 4.25 step/s
epoch: 0 / 2, steps: 3100 / 5352, loss: 0.008252, speed: 4.27 step/s
epoch: 0 / 2, steps: 3150 / 5352, loss: 0.006726, speed: 4.29 step/s
epoch: 0 / 2, steps: 3200 / 5352, loss: 0.006741, speed: 4.25 step/s
epoch: 0 / 2, steps: 3250 / 5352, loss: 0.007330, speed: 4.31 step/s
epoch: 0 / 2, steps: 3300 / 5352, loss: 0.007728, speed: 4.30 step/s
epoch: 0 / 2, steps: 3350 / 5352, loss: 0.005440, speed: 4.31 step/s
epoch: 0 / 2, steps: 3400 / 5352, loss: 0.006389, speed: 4.26 step/s
epoch: 0 / 2, steps: 3450 / 5352, loss: 0.006755, speed: 4.26 step/s
epoch: 0 / 2, steps: 3500 / 5352, loss: 0.005665, speed: 4.26 step/s
epoch: 0 / 2, steps: 3550 / 5352, loss: 0.006122, speed: 4.20 step/s
epoch: 0 / 2, steps: 3600 / 5352, loss: 0.006181, speed: 4.26 step/s
epoch: 0 / 2, steps: 3650 / 5352, loss: 0.006389, speed: 4.26 step/s
epoch: 0 / 2, steps: 3700 / 5352, loss: 0.006517, speed: 4.23 step/s
epoch: 0 / 2, steps: 3750 / 5352, loss: 0.004906, speed: 4.26 step/s
epoch: 0 / 2, steps: 3800 / 5352, loss: 0.005490, speed: 4.24 step/s
epoch: 0 / 2, steps: 3850 / 5352, loss: 0.005950, speed: 4.08 step/s
epoch: 0 / 2, steps: 3900 / 5352, loss: 0.005796, speed: 4.21 step/s
epoch: 0 / 2, steps: 3950 / 5352, loss: 0.004934, speed: 4.28 step/s
epoch: 0 / 2, steps: 4000 / 5352, loss: 0.004503, speed: 4.27 step/s
epoch: 0 / 2, steps: 4050 / 5352, loss: 0.004397, speed: 4.28 step/s
epoch: 0 / 2, steps: 4100 / 5352, loss: 0.004144, speed: 4.18 step/s
epoch: 0 / 2, steps: 4150 / 5352, loss: 0.004736, speed: 4.28 step/s
epoch: 0 / 2, steps: 4200 / 5352, loss: 0.004336, speed: 4.29 step/s
epoch: 0 / 2, steps: 4250 / 5352, loss: 0.004310, speed: 4.26 step/s
epoch: 0 / 2, steps: 4300 / 5352, loss: 0.004534, speed: 4.25 step/s
epoch: 0 / 2, steps: 4350 / 5352, loss: 0.004380, speed: 4.20 step/s
epoch: 0 / 2, steps: 4400 / 5352, loss: 0.004350, speed: 4.28 step/s
epoch: 0 / 2, steps: 4450 / 5352, loss: 0.004721, speed: 4.30 step/s
epoch: 0 / 2, steps: 4500 / 5352, loss: 0.003458, speed: 4.18 step/s
epoch: 0 / 2, steps: 4550 / 5352, loss: 0.004181, speed: 4.27 step/s
epoch: 0 / 2, steps: 4600 / 5352, loss: 0.004579, speed: 4.23 step/s
epoch: 0 / 2, steps: 4650 / 5352, loss: 0.004575, speed: 4.19 step/s
epoch: 0 / 2, steps: 4700 / 5352, loss: 0.004307, speed: 4.27 step/s
epoch: 0 / 2, steps: 4750 / 5352, loss: 0.004365, speed: 4.31 step/s
epoch: 0 / 2, steps: 4800 / 5352, loss: 0.004365, speed: 4.29 step/s
epoch: 0 / 2, steps: 4850 / 5352, loss: 0.003723, speed: 4.30 step/s
epoch: 0 / 2, steps: 4900 / 5352, loss: 0.004648, speed: 4.27 step/s
epoch: 0 / 2, steps: 4950 / 5352, loss: 0.004886, speed: 4.26 step/s
epoch: 0 / 2, steps: 5000 / 5352, loss: 0.004225, speed: 4.29 step/s
epoch: 0 / 2, steps: 5050 / 5352, loss: 0.004350, speed: 4.28 step/s
epoch: 0 / 2, steps: 5100 / 5352, loss: 0.003667, speed: 4.27 step/s
epoch: 0 / 2, steps: 5150 / 5352, loss: 0.003098, speed: 4.24 step/s
epoch: 0 / 2, steps: 5200 / 5352, loss: 0.003984, speed: 4.26 step/s
epoch: 0 / 2, steps: 5250 / 5352, loss: 0.003870, speed: 4.28 step/s
epoch: 0 / 2, steps: 5300 / 5352, loss: 0.004336, speed: 4.22 step/s
epoch: 0 / 2, steps: 5350 / 5352, loss: 0.004293, speed: 4.24 step/s
epoch time footprint: 0 hour 20 min 55 sec

=====start training of 1 epochs=====
epoch: 1 / 2, steps: 48 / 5352, loss: 0.002881, speed: 4.25 step/s
epoch: 1 / 2, steps: 98 / 5352, loss: 0.003354, speed: 4.20 step/s
epoch: 1 / 2, steps: 148 / 5352, loss: 0.002854, speed: 4.27 step/s
epoch: 1 / 2, steps: 198 / 5352, loss: 0.003613, speed: 4.22 step/s
epoch: 1 / 2, steps: 248 / 5352, loss: 0.003249, speed: 4.26 step/s
epoch: 1 / 2, steps: 298 / 5352, loss: 0.003046, speed: 4.27 step/s
epoch: 1 / 2, steps: 348 / 5352, loss: 0.003595, speed: 4.25 step/s
epoch: 1 / 2, steps: 398 / 5352, loss: 0.004121, speed: 4.29 step/s
epoch: 1 / 2, steps: 448 / 5352, loss: 0.003194, speed: 4.27 step/s
epoch: 1 / 2, steps: 498 / 5352, loss: 0.003622, speed: 4.29 step/s
epoch: 1 / 2, steps: 548 / 5352, loss: 0.003387, speed: 4.26 step/s
epoch: 1 / 2, steps: 598 / 5352, loss: 0.004010, speed: 4.24 step/s
epoch: 1 / 2, steps: 648 / 5352, loss: 0.003333, speed: 4.27 step/s
epoch: 1 / 2, steps: 698 / 5352, loss: 0.003030, speed: 4.32 step/s
epoch: 1 / 2, steps: 748 / 5352, loss: 0.004185, speed: 4.29 step/s
epoch: 1 / 2, steps: 798 / 5352, loss: 0.002702, speed: 4.28 step/s
epoch: 1 / 2, steps: 848 / 5352, loss: 0.003886, speed: 4.25 step/s
epoch: 1 / 2, steps: 898 / 5352, loss: 0.003025, speed: 4.29 step/s
epoch: 1 / 2, steps: 948 / 5352, loss: 0.004369, speed: 4.32 step/s
epoch: 1 / 2, steps: 998 / 5352, loss: 0.003555, speed: 4.21 step/s
epoch: 1 / 2, steps: 1048 / 5352, loss: 0.004115, speed: 4.26 step/s
epoch: 1 / 2, steps: 1098 / 5352, loss: 0.003514, speed: 4.16 step/s
epoch: 1 / 2, steps: 1148 / 5352, loss: 0.002826, speed: 4.31 step/s
epoch: 1 / 2, steps: 1198 / 5352, loss: 0.002491, speed: 4.30 step/s
epoch: 1 / 2, steps: 1248 / 5352, loss: 0.003286, speed: 4.22 step/s
epoch: 1 / 2, steps: 1298 / 5352, loss: 0.002838, speed: 4.27 step/s
epoch: 1 / 2, steps: 1348 / 5352, loss: 0.002872, speed: 4.28 step/s
epoch: 1 / 2, steps: 1398 / 5352, loss: 0.004169, speed: 4.23 step/s
epoch: 1 / 2, steps: 1448 / 5352, loss: 0.003755, speed: 4.29 step/s
epoch: 1 / 2, steps: 1498 / 5352, loss: 0.002883, speed: 4.23 step/s
epoch: 1 / 2, steps: 1548 / 5352, loss: 0.002871, speed: 4.28 step/s
epoch: 1 / 2, steps: 1598 / 5352, loss: 0.002420, speed: 4.30 step/s
epoch: 1 / 2, steps: 1648 / 5352, loss: 0.002560, speed: 4.27 step/s
epoch: 1 / 2, steps: 1698 / 5352, loss: 0.003345, speed: 4.18 step/s
epoch: 1 / 2, steps: 1748 / 5352, loss: 0.003580, speed: 4.25 step/s
epoch: 1 / 2, steps: 1798 / 5352, loss: 0.002884, speed: 4.27 step/s
epoch: 1 / 2, steps: 1848 / 5352, loss: 0.004138, speed: 4.24 step/s
epoch: 1 / 2, steps: 1898 / 5352, loss: 0.002940, speed: 4.26 step/s
epoch: 1 / 2, steps: 1948 / 5352, loss: 0.002196, speed: 4.25 step/s
epoch: 1 / 2, steps: 1998 / 5352, loss: 0.003657, speed: 4.26 step/s
epoch: 1 / 2, steps: 2048 / 5352, loss: 0.003009, speed: 4.27 step/s
epoch: 1 / 2, steps: 2098 / 5352, loss: 0.002162, speed: 4.31 step/s
epoch: 1 / 2, steps: 2148 / 5352, loss: 0.002524, speed: 4.26 step/s
epoch: 1 / 2, steps: 2198 / 5352, loss: 0.002588, speed: 4.28 step/s
epoch: 1 / 2, steps: 2248 / 5352, loss: 0.002743, speed: 4.31 step/s
epoch: 1 / 2, steps: 2298 / 5352, loss: 0.002255, speed: 4.26 step/s
epoch: 1 / 2, steps: 2348 / 5352, loss: 0.003633, speed: 4.30 step/s
epoch: 1 / 2, steps: 2398 / 5352, loss: 0.002488, speed: 4.31 step/s
epoch: 1 / 2, steps: 2448 / 5352, loss: 0.002564, speed: 4.27 step/s
epoch: 1 / 2, steps: 2498 / 5352, loss: 0.002715, speed: 4.32 step/s
epoch: 1 / 2, steps: 2548 / 5352, loss: 0.002240, speed: 4.27 step/s
epoch: 1 / 2, steps: 2598 / 5352, loss: 0.002332, speed: 4.29 step/s
epoch: 1 / 2, steps: 2648 / 5352, loss: 0.002317, speed: 4.29 step/s
epoch: 1 / 2, steps: 2698 / 5352, loss: 0.002979, speed: 4.22 step/s
epoch: 1 / 2, steps: 2748 / 5352, loss: 0.002951, speed: 4.28 step/s
epoch: 1 / 2, steps: 2798 / 5352, loss: 0.002859, speed: 4.20 step/s
epoch: 1 / 2, steps: 2848 / 5352, loss: 0.003190, speed: 4.25 step/s
epoch: 1 / 2, steps: 2898 / 5352, loss: 0.002822, speed: 4.27 step/s
epoch: 1 / 2, steps: 2948 / 5352, loss: 0.001922, speed: 4.25 step/s
epoch: 1 / 2, steps: 2998 / 5352, loss: 0.002181, speed: 4.24 step/s
epoch: 1 / 2, steps: 3048 / 5352, loss: 0.002438, speed: 4.31 step/s
epoch: 1 / 2, steps: 3098 / 5352, loss: 0.001835, speed: 4.26 step/s
epoch: 1 / 2, steps: 3148 / 5352, loss: 0.002860, speed: 4.28 step/s
epoch: 1 / 2, steps: 3198 / 5352, loss: 0.002489, speed: 4.22 step/s
epoch: 1 / 2, steps: 3248 / 5352, loss: 0.002574, speed: 4.23 step/s
epoch: 1 / 2, steps: 3298 / 5352, loss: 0.002109, speed: 4.29 step/s
epoch: 1 / 2, steps: 3348 / 5352, loss: 0.002587, speed: 4.16 step/s
epoch: 1 / 2, steps: 3398 / 5352, loss: 0.002031, speed: 4.27 step/s
epoch: 1 / 2, steps: 3448 / 5352, loss: 0.003532, speed: 4.31 step/s
epoch: 1 / 2, steps: 3498 / 5352, loss: 0.003243, speed: 4.25 step/s
epoch: 1 / 2, steps: 3548 / 5352, loss: 0.002701, speed: 4.26 step/s
epoch: 1 / 2, steps: 3598 / 5352, loss: 0.002815, speed: 4.27 step/s
epoch: 1 / 2, steps: 3648 / 5352, loss: 0.002458, speed: 4.28 step/s
epoch: 1 / 2, steps: 3698 / 5352, loss: 0.002668, speed: 4.25 step/s
epoch: 1 / 2, steps: 3748 / 5352, loss: 0.002385, speed: 4.26 step/s
epoch: 1 / 2, steps: 3798 / 5352, loss: 0.002186, speed: 4.27 step/s
epoch: 1 / 2, steps: 3848 / 5352, loss: 0.003757, speed: 4.27 step/s
epoch: 1 / 2, steps: 3898 / 5352, loss: 0.002339, speed: 4.23 step/s
epoch: 1 / 2, steps: 3948 / 5352, loss: 0.002287, speed: 4.25 step/s
epoch: 1 / 2, steps: 3998 / 5352, loss: 0.003288, speed: 4.28 step/s
epoch: 1 / 2, steps: 4048 / 5352, loss: 0.002677, speed: 4.23 step/s
epoch: 1 / 2, steps: 4098 / 5352, loss: 0.002587, speed: 4.24 step/s
epoch: 1 / 2, steps: 4148 / 5352, loss: 0.002182, speed: 4.24 step/s
epoch: 1 / 2, steps: 4198 / 5352, loss: 0.002209, speed: 4.28 step/s
epoch: 1 / 2, steps: 4248 / 5352, loss: 0.003369, speed: 4.13 step/s
epoch: 1 / 2, steps: 4298 / 5352, loss: 0.002609, speed: 4.26 step/s
epoch: 1 / 2, steps: 4348 / 5352, loss: 0.002384, speed: 4.29 step/s
epoch: 1 / 2, steps: 4398 / 5352, loss: 0.002895, speed: 4.25 step/s
epoch: 1 / 2, steps: 4448 / 5352, loss: 0.003119, speed: 4.27 step/s
epoch: 1 / 2, steps: 4498 / 5352, loss: 0.002288, speed: 4.26 step/s
epoch: 1 / 2, steps: 4548 / 5352, loss: 0.003341, speed: 4.25 step/s
epoch: 1 / 2, steps: 4598 / 5352, loss: 0.002699, speed: 4.26 step/s
epoch: 1 / 2, steps: 4648 / 5352, loss: 0.002447, speed: 4.24 step/s

=====start evaluating ckpt of 10000 steps=====

100%|██████████| 646/646 [08:04<00:00,  1.33it/s]

eval loss: 0.002434
precision: 64.70	 recall: 62.10	 f1: 63.37	
saving checkpoing model_10000.pdparams to checkpoints 
epoch: 1 / 2, steps: 4698 / 5352, loss: 0.002275, speed: 0.10 step/s
epoch: 1 / 2, steps: 4748 / 5352, loss: 0.002032, speed: 4.26 step/s
epoch: 1 / 2, steps: 4798 / 5352, loss: 0.002255, speed: 4.19 step/s
epoch: 1 / 2, steps: 4848 / 5352, loss: 0.003138, speed: 4.28 step/s
epoch: 1 / 2, steps: 4898 / 5352, loss: 0.001771, speed: 4.28 step/s
epoch: 1 / 2, steps: 4948 / 5352, loss: 0.002749, speed: 4.24 step/s
epoch: 1 / 2, steps: 4998 / 5352, loss: 0.003003, speed: 4.28 step/s
epoch: 1 / 2, steps: 5048 / 5352, loss: 0.002809, speed: 4.24 step/s
epoch: 1 / 2, steps: 5098 / 5352, loss: 0.001894, speed: 4.29 step/s
epoch: 1 / 2, steps: 5148 / 5352, loss: 0.002233, speed: 4.28 step/s
epoch: 1 / 2, steps: 5198 / 5352, loss: 0.002597, speed: 4.27 step/s
epoch: 1 / 2, steps: 5248 / 5352, loss: 0.002875, speed: 4.30 step/s
epoch: 1 / 2, steps: 5298 / 5352, loss: 0.001676, speed: 4.26 step/s
epoch: 1 / 2, steps: 5348 / 5352, loss: 0.002207, speed: 4.24 step/s
epoch time footprint: 0 hour 29 min 20 sec

=====start evaluating last ckpt of 10704 steps=====

100%|██████████| 646/646 [07:57<00:00,  1.35it/s]

eval loss: 0.002349
precision: 62.01	 recall: 62.44	 f1: 62.22	

=====training complete=====

1.4 快速复现基线Step4：提交预测结果

将训练保存的模型加载后进行预测。

NOTE: 注意设置用于预测的模型参数路径。

!bash predict.sh

+ export CUDA_VISIBLE_DEVICES=0
+ CUDA_VISIBLE_DEVICES=0
+ export BATCH_SIZE=8
+ BATCH_SIZE=8
+ export CKPT=./checkpoints/model_10000.pdparams
+ CKPT=./checkpoints/model_10000.pdparams
+ export DATASET_FILE=./data/test_data.json
+ DATASET_FILE=./data/test_data.json
+ python run_duie.py --do_predict --init_checkpoint ./checkpoints/model_10000.pdparams --predict_data_file ./data/test_data.json --max_seq_length 512 --batch_size 8
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/setuptools/depends.py:2: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
  import imp
[2021-04-12 14:42:04,394] [    INFO] - Downloading https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams and saved to /home/aistudio/.paddlenlp/models/ernie-1.0
[2021-04-12 14:42:04,395] [    INFO] - Downloading ernie_v1_chn_base.pdparams from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/ernie_v1_chn_base.pdparams
100%|████████████████████████████████| 390123/390123 [00:05<00:00, 67876.65it/s]
W0412 14:42:10.218497   113 device_context.cc:362] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 10.1, Runtime API Version: 10.1
W0412 14:42:10.223258   113 device_context.cc:372] device: 0, cuDNN Version: 7.6.
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for classifier.weight. classifier.weight is not found in the provided dict.
  warnings.warn(("Skip loading for {}. ".format(key) + str(err)))
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py:1303: UserWarning: Skip loading for classifier.bias. classifier.bias is not found in the provided dict.
  warnings.warn(("Skip loading for {}. ".format(key) + str(err)))
[2021-04-12 14:42:16,808] [    INFO] - Downloading vocab.txt from https://paddlenlp.bj.bcebos.com/models/transformers/ernie/vocab.txt
100%|█████████████████████████████████████████| 89/89 [00:00<00:00, 4363.55it/s]
[2021-04-12 14:42:16,941] [    INFO] - Preprocessing data, loaded from ./data/test_data.json
100%|████████████████████████████████████| 50583/50583 [03:43<00:00, 225.96it/s]

=====start predicting=====
 20%|███████▎                             | 1259/6322 [24:34<3:12:58,  2.29s/it]

 （未完待续）

预测结果会被保存在data/predictions.json，data/predictions.json.zip，其格式与原数据集文件一致。

之后可以使用官方评估脚本评估训练模型在dev_data.json上的效果。如：

python re_official_evaluation.py --golden_file=dev_data.json --predict_file=predicitons.json.zip [–alias_file alias_dict]

输出指标为Precision, Recall 和 F1，Alias file包含了合法的实体别名，最终评测的时候会使用，这里不予提供。

之后在test_data.json上预测，然后预测结果（.zip文件）至评测网站。

二、Tricks

2.1 尝试更多的预训练模型

基线采用的预训练模型为ERNIE，PaddleNLP提供了丰富的预训练模型，如BERT，RoBERTa，Electra，XLNet等参考PaddleNLP预训练模型介绍

如可以选择RoBERTa large中文模型优化模型效果，只需更换模型和tokenizer即可无缝衔接。

from paddlenlp.transformers import RobertaForTokenClassification, RobertaTokenizer

model = RobertaForTokenClassification.from_pretrained(
    "roberta-wwm-ext-large",
    num_classes=(len(label_map) - 2) * 2 + 2)
tokenizer = RobertaTokenizer.from_pretrained("roberta-wwm-ext-large")

2.2 模型集成

使用多个模型进行训练预测，将各个模型预测结果进行融合。

参考资料

https://aistudio.baidu.com/aistudio/competition/detail/65

你可能感兴趣的:(Information,extraction,深度学习,python,自然语言处理,关系抽取,nlp)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twitter easyui 前端 python
#使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI linux PHP android
╔-----------------------------------╗┆
zookeeper admin 笔记 braveCS zookeeper
Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
Spring配置多个连接池 easterfly spring
项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置： <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" &nb
Mysql 171815164 mysql
例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
CommonDAO（公共/基础DAO） g21121 DAO
好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
直言有讳永夜-极光感悟随笔
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
安装CentOS 7 和Win 7后，Win7 引导丢失随便小屋 centos
一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。一、首先具有root 的权限。即进入Terminal后输入命令su，然后输入密码即可二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
Oracle备份与恢复案例 aijuans oracle
Oracle备份与恢复案例一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
JavaEE开源快速开发平台G4Studio v5.0发布無為子
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。访问G4Studio网站 http://www.g4it.org 2013-04-06 发布G4Studio_V5.0版本功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
Oracle显示根据高考分数模拟录取百合不是茶 PL/SQL编程 oracle例子模拟高考录取学习交流
题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 1,创建student表,和result表学生信息表; create table student( student_id number primary key,--学生id
优秀的领导与差劲的领导 bijian1013 领导管理团队
责任优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。努力工作优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
js函数在浏览器下的兼容 Bill_chen jquery 浏览器 IE DWR ext
做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： IE6：node.nextSibling,对于FF是不能识别的； FF：node.nextElementSibling,对于IE是不能识别的；兼容解决方式：var Div = node.nextSibl
【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
吞吐量与用户线程暂停时间衡量垃圾回收算法优劣的指标有两个：吞吐量越高，则算法越好暂停时间越短，则算法越好首先说明吞吐量和暂停时间的含义。垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
J2EE监听器和过滤器基础白糖_ J2EE
Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 ServletContex监听器 ServletContex又叫application
博弈AngularJS讲义(16) - 提供者 boyitech js AngularJS api Angular Provider
Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
sqlserver 2000 无法验证产品密钥 Chen.H sql windows SQL Server Microsoft
在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。这样做, 收到以下错误信息CD KEY的 SQ
[新概念武器]气象战争 comsci
气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 原因如下: 地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
oracle 中 rollup、cube、grouping 使用详解 daizj oracle grouping rollup cube
oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景 --- ROLLUP ，为了理解分组的成员数量，我增加了分组的计数 COUNT(SAL)
技术资料汇总分享 Dead_knight 技术资料汇总分享
本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
初一下学期难记忆单词背诵第一课 dcj3sjt126com english word
could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
截取视图的图片, 然后分享出去 dcj3sjt126com OS Objective-C
OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
MySql重置密码 fanxiaolong MySql重置密码
方法一: 在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库然后进入mysql mysql>use mysql; mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcache MemoryStore DiskStore 存储驱除策略
Ehcache中储存缓存的方式目录 1 堆内存（MemoryStore） 1.1 指定可用内存 1.2 驱除策略 1.3 元素过期 2 &nbs
spring mvc中的@propertysource jackyrong spring mvc
在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource 在spring 3.1中开始引入比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中 @PropertySource(&
重学单例模式 lanqiu17 单例 Singleton 模式
最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式静态内部类方式: package test.pattern.singleton.statics; publ
.NET开源核心运行时，且行且珍惜 netcome java .net 开源
背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web 高并发 oscahe缓存
此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
Spring+Mybatis 手动控制事务 toknowme mybatis
@Override public boolean testDelete(String jobCode) throws Exception { boolean flag = false; &nbs
菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
熟悉Android开发架构和API调用掌握APP适应不同型号手机屏幕开发技巧熟悉Android下的数据存储熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具熟悉Android框架原理及Activity生命周期熟练进行Android UI布局熟练使用SQLite数据库；熟悉Android下网络通信机制，S