id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
38,610 | import copy
from typing import List, Dict
from collections import defaultdict
import yaml
import json
import os
from uie.evaluation.sel2record import RecordSchema, merge_schema
def merge_pred_text_file(text_filename, pred_filename):
assert len(test_instances) == len(pred_instances)
to_sumbit_instances = dict()
... | Merge predicted result from trained model 将预测文件夹中的预测结果进行合并 |
38,611 | import copy
from typing import List, Dict
from collections import defaultdict
import yaml
import json
import os
from uie.evaluation.sel2record import RecordSchema, merge_schema
schema_folder = options.schema_folder
output_folder = options.output_folder
output_folder = options.pred_folder
def convert_duuie_t... | Preprocessing event dataset for CCKS 2022 针对 CCKS 2022 竞赛数据进行预处理 |
38,612 | import argparse
import logging
import math
import os
import paddle
from paddle.amp import GradScaler, auto_cast
from paddle.optimizer import AdamW
from uie.evaluation.sel2record import evaluate_extraction_results
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
from uie.seq2struct.utils import (
better_... | null |
38,613 | import argparse
import logging
import math
import os
import paddle
from paddle.amp import GradScaler, auto_cast
from paddle.optimizer import AdamW
from uie.evaluation.sel2record import evaluate_extraction_results
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
from uie.seq2struct.utils import (
better_... | null |
38,614 | import json
import os
import math
from tqdm import tqdm
import paddle
from paddlenlp.data import Pad
from paddlenlp.transformers import T5ForConditionalGeneration
from uie.evaluation.sel2record import RecordSchema, MapConfig, SEL2Record
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
def read_json_file(fi... | null |
38,615 | import json
import os
import math
from tqdm import tqdm
import paddle
from paddlenlp.data import Pad
from paddlenlp.transformers import T5ForConditionalGeneration
from uie.evaluation.sel2record import RecordSchema, MapConfig, SEL2Record
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
class RecordSchema:
... | null |
38,616 | import json
import os
import math
from tqdm import tqdm
import paddle
from paddlenlp.data import Pad
from paddlenlp.transformers import T5ForConditionalGeneration
from uie.evaluation.sel2record import RecordSchema, MapConfig, SEL2Record
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
special_to_remove = {"... | null |
38,617 | import json
import os
import math
from tqdm import tqdm
import paddle
from paddlenlp.data import Pad
from paddlenlp.transformers import T5ForConditionalGeneration
from uie.evaluation.sel2record import RecordSchema, MapConfig, SEL2Record
from uie.seq2struct.t5_bert_tokenizer import T5BertTokenizer
def find_to_predict_f... | null |
38,618 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def load_dict(dict_path):
vocab = {}
... | null |
38,619 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
The provided code snippet includes necessar... | Load vocab from file |
38,620 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
The provided code snippet includes necessar... | Parse the padding result Args: sentences (list): the tagging sentences. predictions (list): the prediction tags. lengths (list): the valid length of each sentence. label_vocab (dict): the label vocab. Returns: outputs (list): the formatted output. |
38,621 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def convert_to_features(example, tokenizer)... | null |
38,622 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def read(data_path):
with open(data_pat... | null |
38,623 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def load_dict(dict_path)... | null |
38,624 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
The provided code snippe... | Load vocab from file |
38,625 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
The provided code snippe... | Parse the padding result Args: sentences (list): the tagging sentences. predictions (list): the prediction tags. lengths (list): the valid length of each sentence. label_vocab (dict): the label vocab. Returns: outputs (list): the formatted output. |
38,626 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def convert_to_features(... | null |
38,627 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import AutoTokenizer
from paddlenlp.utils.log import logger
def read(data_path):
... | null |
38,628 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.utils.log import logger
def load_dict(dict_path):
vocab = {}
i = 0
with open(dict_path, "r", encoding="u... | null |
38,629 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.utils.log import logger
The provided code snippet includes necessary dependencies for implementing the `load_vocab` ... | Load vocab from file |
38,630 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.utils.log import logger
The provided code snippet includes necessary dependencies for implementing the `parse_decode... | Parse the padding result Args: sentences (list): the tagging sentences. predictions (list): the prediction tags. lengths (list): the valid length of each sentence. label_vocab (dict): the label vocab. Returns: outputs (list): the formatted output. |
38,631 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.utils.log import logger
def convert_tokens_to_ids(tokens, vocab, oov_token=None):
token_ids = []
oov_id = voc... | null |
38,632 | import argparse
import os
from functools import partial
import paddle
from paddle import inference
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.utils.log import logger
def read(data_path):
with open(data_path, "r", encoding="utf-8") as fp:
next(fp)... | null |
38,633 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import ErnieCrfForTokenClassification
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenCla... | null |
38,634 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import ErnieCrfForTokenClassification
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenCla... | null |
38,635 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import ErnieCrfForTokenClassification
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenCla... | null |
38,636 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import ErnieCrfForTokenClassification
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenCla... | null |
38,637 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenClassification, AutoTokenizer
def convert_to_featur... | null |
38,638 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenClassification, AutoTokenizer
def evaluate(model, m... | null |
38,639 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenClassification, AutoTokenizer
def parse_decodes(sen... | null |
38,640 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenClassification, AutoTokenizer
def create_dataloader... | null |
38,641 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
from paddlenlp.transformers import AutoModelForTokenClassification, AutoTokenizer
def batchify_fn(sampl... | null |
38,642 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import BiGRUWithCRF
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
def convert_tokens_to_ids(tokens, vocab, oov_token=None):
def convert_to... | null |
38,643 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import BiGRUWithCRF
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
def evaluate(model, metric, data_loader):
model.eval()
metric.re... | null |
38,644 | import argparse
import os
from functools import partial
import paddle
from data import load_dataset, load_dict, parse_decodes
from model import BiGRUWithCRF
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvaluator
def parse_decodes(sentences, predictions, lengths, label_vocab):
"""... | null |
38,645 | import json
import os
from utils import cal_md5, read_by_lines, text_to_sents, write_by_lines
enum_role = "环节"
def read_by_lines(path):
"""read the data by line"""
result = list()
with open(path, "r", encoding="utf8") as infile:
for line in infile:
result.append(line.strip())
return... | data_process |
38,646 | import json
import os
from utils import cal_md5, read_by_lines, text_to_sents, write_by_lines
enum_role = "环节"
def read_by_lines(path):
"""read the data by line"""
result = list()
with open(path, "r", encoding="utf8") as infile:
for line in infile:
result.append(line.strip())
return... | enum_data_process |
38,647 | import json
import os
from utils import cal_md5, read_by_lines, text_to_sents, write_by_lines
enum_role = "环节"
def read_by_lines(path):
"""read the data by line"""
result = list()
with open(path, "r", encoding="utf8") as infile:
for line in infile:
result.append(line.strip())
return... | schema_process |
38,648 | import json
import os
from utils import cal_md5, read_by_lines, text_to_sents, write_by_lines
def marked_doc_2_sentence(doc):
"""marked_doc_2_sentence"""
def argument_in_sent(sent, argument_list, trigger):
"""argument_in_sent"""
trigger_start = sent.find(trigger)
if trigger_start < 0:
... | docs_data_process |
38,649 | import argparse
import ast
import json
import os
import random
import warnings
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from utils import load_dict, read_by_lines, write_by_lines
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvalua... | null |
38,650 | import argparse
import ast
import json
import os
import random
import warnings
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from utils import load_dict, read_by_lines, write_by_lines
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.metrics import ChunkEvalua... | null |
38,651 | import argparse
import ast
import csv
import json
import os
import random
import traceback
from collections import namedtuple
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from utils import load_dict, read_by_lines, write_by_lines
from paddlenlp.data import Pad, Stack, ... | null |
38,652 | import argparse
import ast
import csv
import json
import os
import random
import traceback
from collections import namedtuple
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from utils import load_dict, read_by_lines, write_by_lines
from paddlenlp.data import Pad, Stack, ... | null |
38,653 | import argparse
import json
from utils import extract_result, read_by_lines, write_by_lines
enum_event_type = "公司上市"
enum_role = "环节"
def event_normalization(doc):
"""event_merge"""
for event in doc.get("event_list", []):
argument_list = []
argument_set = set()
for arg in event["argument... | predict_data_process |
38,654 | import json
import os
from utils import read_by_lines, write_by_lines
The provided code snippet includes necessary dependencies for implementing the `data_process` function. Write a Python function `def data_process(path, model="trigger", is_predict=False)` to solve the following problem:
data_process
Here is the fun... | data_process |
38,655 | import json
import os
from utils import read_by_lines, write_by_lines
def read_by_lines(path):
"""read the data by line"""
result = list()
with open(path, "r", encoding="utf8") as infile:
for line in infile:
result.append(line.strip())
return result
The provided code snippet includ... | schema_process |
38,656 | import argparse
import json
from utils import extract_result, read_by_lines, write_by_lines
def read_by_lines(path):
"""read the data by line"""
result = list()
with open(path, "r", encoding="utf8") as infile:
for line in infile:
result.append(line.strip())
return result
def write... | predict_data_process |
38,657 | import argparse
import json
import os
import random
import sys
import time
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from data_loader import DataCollator, DuIEDataset
from paddle.io import DataLoader
from tqdm import tqdm
from utils import decoding, get_precision_recall_f1... | sets random seed |
38,658 | import argparse
import json
import os
import random
import sys
import time
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from data_loader import DataCollator, DuIEDataset
from paddle.io import DataLoader
from tqdm import tqdm
from utils import decoding, get_precision_recall_f1... | null |
38,659 | import argparse
import json
import os
import random
import sys
import time
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from data_loader import DataCollator, DuIEDataset
from paddle.io import DataLoader
from tqdm import tqdm
from utils import decoding, get_precision_recall_f1... | null |
38,660 | import collections
import json
import os
from dataclasses import dataclass
from typing import Dict, List, Optional, Union
import numpy as np
import paddle
from extract_chinese_and_punct import ChineseAndPunctuationExtractor
from paddlenlp.transformers import AutoTokenizer, PretrainedTokenizer
InputFeature = collections... | null |
38,661 | import argparse
import json
import os
import sys
import zipfile
SUCCESS = 0
CODE_INFO = {
SUCCESS: "success",
FILE_ERROR: "file is not exists",
NOT_ZIP_FILE: "predict file is not a zipfile",
ENCODING_ERROR: "file encoding error",
JSON_ERROR: "json parse is error",
SCHEMA_ERROR: "schema is error"... | calculate precision, recall, f1 |
38,662 | import argparse
import numpy as np
import paddle
from biencoder_base_model import BiEncoder, BiEncoderNllLoss
from NQdataset import DataUtil, NQdataSetForDPR
from paddle.optimizer.lr import LambdaDecay
from paddlenlp.transformers.bert.modeling import BertModel
batch_data = []
def dataLoader_for_DPR(batch_size, source_... | null |
38,663 | import argparse
import numpy as np
import paddle
from biencoder_base_model import BiEncoder, BiEncoderNllLoss
from NQdataset import DataUtil, NQdataSetForDPR
from paddle.optimizer.lr import LambdaDecay
from paddlenlp.transformers.bert.modeling import BertModel
model = get_model("bert-base-uncased")
class BiEncoder(nn.... | null |
38,664 | import argparse
import numpy as np
import paddle
from biencoder_base_model import BiEncoder, BiEncoderNllLoss
from NQdataset import DataUtil, NQdataSetForDPR
from paddle.optimizer.lr import LambdaDecay
from paddlenlp.transformers.bert.modeling import BertModel
args = parser.parse_args()
learning_rate = args.learning_ra... | null |
38,665 | import argparse
import numpy as np
import paddle
from biencoder_base_model import BiEncoder, BiEncoderNllLoss
from NQdataset import DataUtil, NQdataSetForDPR
from paddle.optimizer.lr import LambdaDecay
from paddlenlp.transformers.bert.modeling import BertModel
dataset = get_dataset(data_path)
class NQdataSetForDPR(Dat... | null |
38,666 | import argparse
import numpy as np
import paddle
from biencoder_base_model import BiEncoder, BiEncoderNllLoss
from NQdataset import DataUtil, NQdataSetForDPR
from paddle.optimizer.lr import LambdaDecay
from paddlenlp.transformers.bert.modeling import BertModel
args = parser.parse_args()
chunk_nums = args.batch_size // ... | null |
38,667 | import argparse
import os
from functools import partial
from pprint import pprint
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from data import convert_example, create_dataloader, read_text_pair
from paddlenlp.data import Pad, Tuple
from paddlenlp.datasets import load_dataset... | null |
38,668 | import argparse
import os
from functools import partial
from pprint import pprint
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from data import convert_example, create_dataloader, read_text_pair
from paddlenlp.data import Pad, Tuple
from paddlenlp.datasets import load_dataset... | null |
38,669 | import collections
import json
import random
from typing import List
import numpy as np
import paddle
from paddle.io import Dataset
from paddlenlp.transformers.bert.tokenizer import BertTokenizer
def normalize_question(question: str) -> str:
question = question.replace("’", "'")
return question | null |
38,670 | import collections
import json
import random
from typing import List
import numpy as np
import paddle
from paddle.io import Dataset
from paddlenlp.transformers.bert.tokenizer import BertTokenizer
def normalize_passage(ctx_text: str):
ctx_text = ctx_text.replace("\n", " ").replace("’", "'")
if ctx_text.startswi... | null |
38,671 | import argparse
import csv
import glob
import gzip
import json
import logging
import pickle
import time
from typing import Dict, Iterator, List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from faiss_indexer import DenseFlatIndexer, DenseHNSWFlatIndexer, DenseIndexer
from NQdataset... | null |
38,672 | import argparse
import csv
import glob
import gzip
import json
import logging
import pickle
import time
from typing import Dict, Iterator, List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from faiss_indexer import DenseFlatIndexer, DenseHNSWFlatIndexer, DenseIndexer
from NQdataset... | null |
38,673 | import argparse
import csv
import glob
import gzip
import json
import logging
import pickle
import time
from typing import Dict, Iterator, List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from faiss_indexer import DenseFlatIndexer, DenseHNSWFlatIndexer, DenseIndexer
from NQdataset... | null |
38,674 | import argparse
import csv
import glob
import gzip
import json
import logging
import pickle
import time
from typing import Dict, Iterator, List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from faiss_indexer import DenseFlatIndexer, DenseHNSWFlatIndexer, DenseIndexer
from NQdataset... | null |
38,675 | import argparse
import csv
import glob
import gzip
import json
import logging
import pickle
import time
from typing import Dict, Iterator, List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from faiss_indexer import DenseFlatIndexer, DenseHNSWFlatIndexer, DenseIndexer
from NQdataset... | null |
38,676 | import argparse
import csv
import logging
import os
import pathlib
import pickle
from typing import List, Tuple
import numpy as np
import paddle
from biencoder_base_model import BiEncoder
from NQdataset import BertTensorizer
from paddle import nn
from paddle.io import DataLoader, Dataset
from tqdm import tqdm
from padd... | null |
38,677 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from data import convert_example, create_dataloader, read_text_pair
from hardest_negative.model import SemanticIndexHardestNeg
from paddlenlp.data import Pad, Tuple
from paddlenlp.datasets import load_data... | null |
38,678 | import os
import time
import logging
import pickle
from typing import List, Tuple, Iterator
import faiss
import numpy as np
logger = logging.getLogger()
def iterate_encoded_files(vector_files: list) -> Iterator[Tuple[object, np.array]]:
for i, file in enumerate(vector_files):
logger.info("Reading file %s",... | null |
38,679 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from data import convert_example, create_dataloader, read_text_pair
from gradient_cache.model import SemanticIndexCacheNeg
import paddlenlp as ppnlp
from paddlenlp.data imp... | sets random seed |
38,680 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from data import convert_example, create_dataloader, read_text_pair
from gradient_cache.model import SemanticIndexCacheNeg
import paddlenlp as ppnlp
from paddlenlp.data imp... | null |
38,681 | import argparse
import os
from functools import partial
import numpy as np
import paddle
from base_model import SemanticIndexBase
from data import convert_example, create_dataloader, read_text_pair
from paddlenlp.data import Pad, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.ops import convert_to_fp1... | Predicts the data labels. Args: model (obj:`SemanticIndexBase`): A model to extract text embedding or calculate similarity of text pair. data_loader (obj:`List(Example)`): The processed data ids of text pair: [query_input_ids, query_token_type_ids, title_input_ids, title_token_type_ids] Returns: results(obj:`List`): co... |
38,682 | import argparse
import os
import time
from functools import partial
import paddle
from ance.model import SemanticIndexANCE
from ann_util import build_index
from data import (
convert_example,
create_dataloader,
gen_id2corpus,
gen_text_file,
get_latest_ann_data,
get_latest_checkpoint,
)
from padd... | null |
38,683 | import collections
import logging
import string
import unicodedata
from functools import partial
from multiprocessing import Pool as ProcessPool
from typing import Tuple, List, Dict
import regex as re
from tokenizers import SimpleTokenizer
def _normalize_answer(s):
def exact_match_score(prediction, ground_truth):
... | null |
38,684 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from ance.model import SemanticIndexANCE
from data import (
convert_example,
create_dataloader,
get_latest_ann_data,
get_latest_checkpoint,
read_text_triplet,
)
from paddlenlp.data impo... | null |
38,685 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from batch_negative.model import SemanticIndexBatchNeg
from data import convert_example, create_dataloader, read_text_pair
from paddlenlp.data import Pad, Tuple
from paddlenlp.datasets import load_dataset
... | null |
38,686 | import argparse
import numpy as np
The provided code snippet includes necessary dependencies for implementing the `recall` function. Write a Python function `def recall(rs, N=10)` to solve the following problem:
Ratio of recalled Ground Truth at topN Recalled Docs >>> rs = [[0, 0, 1], [0, 1, 0], [1, 0, 0]] >>> recall(... | Ratio of recalled Ground Truth at topN Recalled Docs >>> rs = [[0, 0, 1], [0, 1, 0], [1, 0, 0]] >>> recall(rs, N=1) 0.333333 >>> recall(rs, N=2) >>> 0.6666667 >>> recall(rs, N=3) >>> 1.0 Args: rs: Iterator of recalled flag() Returns: Recall@N |
38,687 | import argparse
from functools import partial
import paddle
import paddle.nn.functional as F
from tqdm import tqdm
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokenizer
The provided code snippet inc... | Given a prediction dataset, it gives the prediction results. Args: model(obj:`paddle.nn.Layer`): A model to classify texts. data_loader(obj:`paddle.io.DataLoader`): The dataset loader which generates batches. label_map(obj:`dict`): The label id (key) to label str (value) map. |
38,688 | import argparse
from functools import partial
import paddle
import paddle.nn.functional as F
from tqdm import tqdm
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokenizer
The provided code snippet inc... | Builds model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens. Args: example(obj:`dict`): Dict of input data, containing text and label if it have label. tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transfo... |
38,689 | import argparse
from functools import partial
import paddle
import paddle.nn.functional as F
from tqdm import tqdm
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokenizer
def create_dataloader(dataset... | null |
38,690 | import argparse
import numpy as np
import paddle
from scipy.special import softmax
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.transformers import SkepTokenizer
def convert_example(example, tokenizer, label_list, max_seq_len=512, is_test=False):
text = example
encoded_inputs = tokenizer(t... | null |
38,691 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokeniz... | Sets random seed. |
38,692 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokeniz... | Builds model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens. Args: example(obj:`dict`): Dict of input data, containing text and label if it have label. tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transfo... |
38,693 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokeniz... | null |
38,695 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokeniz... | Given a dataset, it evals model and computes the metric. Args: model(obj:`paddle.nn.Layer`): A model to classify texts. metric(obj:`paddle.metric.Metric`): The evaluation metric. data_loader(obj:`paddle.io.DataLoader`): The dataset loader which generates batches. |
38,696 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokeniz... | Builds model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens. Args: example(obj:`dict`): Dict of input data, containing text and label if it have label. tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transfo... |
38,698 | import argparse
import paddle
import paddle.nn.functional as F
from paddlenlp.data import DataCollatorWithPadding
from paddlenlp.transformers import SkepForSequenceClassification, SkepTokenizer
args = parser.parse_args()
def convert_example_to_feature(example, tokenizer, max_seq_len=512):
"""
Builds model input... | Predicts the data labels. Args: model (obj:`paddle.nn.Layer`): A model to classify texts. data (obj:`List(Example)`): The processed data whose each element is a Example (numedtuple) object. A Example object contains `text`(word_ids) and `seq_len`(sequence length). tokenizer(obj:`PretrainedTokenizer`): This tokenizer in... |
38,699 | import argparse
from functools import partial
import paddle
from tqdm import tqdm
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
def parse_predict_result(predictions, seq_lens, labe... | Given a prediction dataset, it gives the prediction results. Args: model(obj:`paddle.nn.Layer`): A model to classify texts. data_loader(obj:`paddle.io.DataLoader`): The dataset loader which generates batches. label_map(obj:`dict`): The label id (key) to label str (value) map. |
38,700 | import argparse
from functools import partial
import paddle
from tqdm import tqdm
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
The provided code snippet includes necessary depend... | Builds model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens. Args: example(obj:`dict`): Dict of input data, containing text and label if it have label. tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transfo... |
38,701 | import argparse
from functools import partial
import paddle
from tqdm import tqdm
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
def create_dataloader(dataset, mode="train", batch_... | null |
38,702 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
The provided code ... | Sets random seed. |
38,703 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
The provided code ... | Builds model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens. Args: example(obj:`dict`): Dict of input data, containing text and label if it have label. tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transfo... |
38,704 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddlenlp.data import DataCollatorForTokenClassification
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import SkepCrfForTokenClassification, SkepTokenizer
def create_dataloa... | null |
38,705 | from functools import partial
import argparse
import os
import random
import numpy as np
import paddle
from paddlenlp.datasets import load_dataset
from paddlenlp.data import JiebaTokenizer, Pad, Stack, Tuple, Vocab
from data import create_dataloader, convert_example, read_custom_data
from model import TextCNNModel
The... | Sets random seed. |
38,706 | import argparse
import numpy as np
import paddle
import paddle.nn.functional as F
from paddlenlp.data import JiebaTokenizer, Pad, Vocab
The provided code snippet includes necessary dependencies for implementing the `convert_example` function. Write a Python function `def convert_example(data, tokenizer, pad_token_id=0... | convert_example |
38,707 | import numpy as np
import paddle
The provided code snippet includes necessary dependencies for implementing the `create_dataloader` function. Write a Python function `def create_dataloader(dataset, mode="train", batch_size=1, batchify_fn=None, trans_fn=None)` to solve the following problem:
Create dataloader. Args: da... | Create dataloader. Args: dataset(obj:`paddle.io.Dataset`): Dataset instance. mode(obj:`str`, optional, defaults to obj:`train`): If mode is 'train', it will shuffle the dataset randomly. batch_size(obj:`int`, optional, defaults to 1): The sample number of a mini-batch. batchify_fn(obj:`callable`, optional, defaults to ... |
38,708 | import numpy as np
import paddle
The provided code snippet includes necessary dependencies for implementing the `preprocess_prediction_data` function. Write a Python function `def preprocess_prediction_data(data, tokenizer, pad_token_id=0, max_ngram_filter_size=3)` to solve the following problem:
It process the predic... | It process the prediction data as the format used as training. Args: data (obj:`list[str]`): The prediction data whose each element is a tokenized text. tokenizer(obj: paddlenlp.data.JiebaTokenizer): It use jieba to cut the chinese string. pad_token_id(obj:`int`, optional, defaults to 0): The pad token index. max_ngram... |
38,709 | import numpy as np
import paddle
The provided code snippet includes necessary dependencies for implementing the `convert_example` function. Write a Python function `def convert_example(example, tokenizer)` to solve the following problem:
convert_example
Here is the function:
def convert_example(example, tokenizer):
... | convert_example |
38,710 | import numpy as np
import paddle
The provided code snippet includes necessary dependencies for implementing the `read_custom_data` function. Write a Python function `def read_custom_data(filename)` to solve the following problem:
Reads data.
Here is the function:
def read_custom_data(filename):
"""Reads data."""... | Reads data. |
38,711 | import argparse
import paddle
import paddle.nn.functional as F
from paddlenlp.data import JiebaTokenizer, Pad, Vocab
from model import TextCNNModel
from data import preprocess_prediction_data
The provided code snippet includes necessary dependencies for implementing the `predict` function. Write a Python function `def... | Predicts the data labels. Args: model (obj:`paddle.nn.Layer`): A model to classify texts. data (obj:`list`): The processed data whose each element is a `list` object, which contains - word_ids(obj:`list[int]`): The list of word ids. label_map(obj:`dict`): The label id (key) to label str (value) map. batch_size(obj:`int... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.