id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
38,712 | import os
import sys
from functools import partial
import paddle
import paddle.nn as nn
import pandas as pd
from paddlenlp.datasets import load_dataset as ppnlp_load_dataset
from paddlenlp.transformers import BertTokenizer as PPNLPBertTokenizer
from models.pd_bert import BertConfig, BertForSequenceClassification
def g... | null |
38,713 | from collections import OrderedDict
import numpy as np
import paddle
import torch
from paddlenlp.transformers import BertForPretraining as PDBertForMaskedLM
from transformers import BertForMaskedLM as PTBertForMaskedLM
def convert_pytorch_checkpoint_to_paddle(
pytorch_checkpoint_path="pytorch_model.bin",
paddl... | null |
38,714 | from collections import OrderedDict
import numpy as np
import paddle
import torch
from paddlenlp.transformers import BertForPretraining as PDBertForMaskedLM
from transformers import BertForMaskedLM as PTBertForMaskedLM
def compare(out_torch, out_paddle):
out_torch = out_torch.detach().numpy()
out_paddle = out_p... | null |
38,715 | import numpy as np
import paddle
import torch
def generate(seed):
np.random.seed(seed)
weight = np.random.normal(0, 0.02, (768, 2)).astype("float32")
bias = np.zeros((2,)).astype("float32")
paddle_weights = {
"classifier.weight": weight,
"classifier.bias": bias,
}
torch_weights ... | null |
38,716 | import numpy as np
def gen_fake_data():
fake_data = np.random.randint(1, 30522, size=(4, 64)).astype(np.int64)
fake_label = np.array([0, 1, 1, 0]).astype(np.int64)
np.save("fake_data.npy", fake_data)
np.save("fake_label.npy", fake_label) | null |
38,717 | import datetime
import os
import random
import sys
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn as nn
import utils
from paddle.metric import Accuracy
from paddle.optimizer import AdamW
from reprod_log import ReprodLogger
from paddlenlp.data import Dict, Pad, Stack
from pad... | null |
38,718 | import datetime
import os
import random
import sys
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn as nn
import utils
from paddle.metric import Accuracy
from paddle.optimizer import AdamW
from reprod_log import ReprodLogger
from paddlenlp.data import Dict, Pad, Stack
from pad... | null |
38,719 | import datetime
import os
import random
import sys
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn as nn
import utils
from paddle.metric import Accuracy
from paddle.optimizer import AdamW
from reprod_log import ReprodLogger
from paddlenlp.data import Dict, Pad, Stack
from pad... | null |
38,720 | import datetime
import os
import random
import sys
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn as nn
import utils
from paddle.metric import Accuracy
from paddle.optimizer import AdamW
from reprod_log import ReprodLogger
from paddlenlp.data import Dict, Pad, Stack
from pad... | null |
38,721 | import datetime
import os
import random
import sys
import time
from functools import partial
import numpy as np
import paddle
import paddle.nn as nn
import utils
from paddle.metric import Accuracy
from paddle.optimizer import AdamW
from reprod_log import ReprodLogger
from paddlenlp.data import Dict, Pad, Stack
from pad... | null |
38,722 | import datetime
import errno
import os
import time
from collections import defaultdict, deque
import paddle
from paddlenlp.transformers import (
CosineDecayWithWarmup,
LinearDecayWithWarmup,
PolyDecayWithWarmup,
)
scheduler_type2cls = {
"linear": LinearDecayWithWarmup,
"cosine": CosineDecayWithWarmu... | null |
38,723 | import datetime
import errno
import os
import time
from collections import defaultdict, deque
import paddle
from paddlenlp.transformers import (
CosineDecayWithWarmup,
LinearDecayWithWarmup,
PolyDecayWithWarmup,
)
def mkdir(path):
try:
os.makedirs(path)
except OSError as e:
if e.err... | null |
38,724 | import datetime
import os
import random
import sys
import time
import numpy as np
import torch
import torch.utils.data
import utils
from datasets import load_dataset, load_metric
from reprod_log import ReprodLogger
from torch import nn
from transformers import AdamW, BertTokenizer, DataCollatorWithPadding, get_schedule... | null |
38,725 | import datetime
import os
import random
import sys
import time
import numpy as np
import torch
import torch.utils.data
import utils
from datasets import load_dataset, load_metric
from reprod_log import ReprodLogger
from torch import nn
from transformers import AdamW, BertTokenizer, DataCollatorWithPadding, get_schedule... | null |
38,726 | import datetime
import os
import random
import sys
import time
import numpy as np
import torch
import torch.utils.data
import utils
from datasets import load_dataset, load_metric
from reprod_log import ReprodLogger
from torch import nn
from transformers import AdamW, BertTokenizer, DataCollatorWithPadding, get_schedule... | null |
38,727 | import datetime
import os
import random
import sys
import time
import numpy as np
import torch
import torch.utils.data
import utils
from datasets import load_dataset, load_metric
from reprod_log import ReprodLogger
from torch import nn
from transformers import AdamW, BertTokenizer, DataCollatorWithPadding, get_schedule... | null |
38,728 | import datetime
import os
import random
import sys
import time
import numpy as np
import torch
import torch.utils.data
import utils
from datasets import load_dataset, load_metric
from reprod_log import ReprodLogger
from torch import nn
from transformers import AdamW, BertTokenizer, DataCollatorWithPadding, get_schedule... | null |
38,729 | import datetime
import errno
import os
import time
from collections import defaultdict, deque
import torch
The provided code snippet includes necessary dependencies for implementing the `accuracy` function. Write a Python function `def accuracy(output, target, topk=(1,))` to solve the following problem:
Computes the a... | Computes the accuracy over the k top predictions for the specified values of k |
38,730 | import datetime
import errno
import os
import time
from collections import defaultdict, deque
import torch
def mkdir(path):
try:
os.makedirs(path)
except OSError as e:
if e.errno != errno.EEXIST:
raise | null |
38,731 | import csv
import os
import textwrap
import datasets
import numpy as np
def _mnli_split_generator(name, data_dir, split, matched):
return datasets.SplitGenerator(
name=name,
gen_kwargs={
"data_file": os.path.join(data_dir, "%s_%s.tsv" % (split, "matched" if matched else "mismatched")),
... | null |
38,732 | from collections import OrderedDict
import numpy as np
import paddle
import torch
from paddlenlp.transformers import BertForPretraining as PDBertForMaskedLM
from transformers import BertForMaskedLM as PTBertForMaskedLM
def convert_pytorch_checkpoint_to_paddle(
pytorch_checkpoint_path="pytorch_model.bin",
paddl... | null |
38,734 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from criterion import ParserCriterion
from data import build_vocab, convert_example, create_dataloader
from metric import ParserEvaluator
from model.dep import BiAffineParser
from utils import decode, flat... | null |
38,735 | import argparse
import copy
import os
import numpy as np
import paddle
from data import convert_example, load_vocab
from utils import eisner, flat_words, istree, pad_sequence
from paddlenlp.datasets import load_dataset
def pad_sequence(sequences, padding_value=0, fix_len=None):
"""Fill sequences(np.ndarray) into a... | null |
38,736 | import argparse
import copy
import os
import numpy as np
import paddle
from data import convert_example, load_vocab
from utils import eisner, flat_words, istree, pad_sequence
from paddlenlp.datasets import load_dataset
def eisner(scores, mask):
"""Eisner algorithm is a general dynamic programming decoding algorith... | null |
38,737 | import os
import math
import numpy as np
import paddle
from paddle.io import Dataset
from paddlenlp.data import Vocab
from utils import kmeans, pad_sequence
The provided code snippet includes necessary dependencies for implementing the `load_vocab` function. Write a Python function `def load_vocab(vocab_dir)` to solve... | load vocabs |
38,738 | import argparse
import copy
import os
from functools import partial
import numpy as np
import paddle
from data import convert_example, create_dataloader, load_vocab
from model.dep import BiAffineParser
from utils import decode, flat_words
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import Au... | null |
38,739 | from __future__ import absolute_import, division, print_function
import argparse
def parse_args():
parser = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
"--data_dir",
default=None,
type=str,
required=True,
help="The input data dir. Should con... | null |
38,740 | import argparse
import json
import os
from PIL import Image
from paddlenlp.transformers import AutoTokenizer
def bbox_string(box, width, length):
def actual_bbox_string(box, width, length):
def convert(args):
with open(os.path.join(args.output_dir, args.data_split + ".txt.tmp"), "w", encoding="utf8",) as fw, open(... | null |
38,741 | import argparse
import json
import os
from PIL import Image
from paddlenlp.transformers import AutoTokenizer
def seg_file(file_path, tokenizer, max_len):
subword_len_counter = 0
output_path = file_path[:-4]
with open(file_path, "r", encoding="utf8") as f_p, open(output_path, "w", encoding="utf8") as fw_p:
... | null |
38,742 | import logging
import os
import random
import numpy as np
import paddle
from funsd import FunsdDataset
from seqeval.metrics import (
classification_report,
f1_score,
precision_score,
recall_score,
)
from tqdm import tqdm, trange
from utils import parse_args
from paddlenlp.transformers import (
Layou... | null |
38,743 | import logging
import os
import paddle
from paddle.io import Dataset
class InputExample(object):
"""A single training/test example for token classification."""
def __init__(self, guid, words, labels, boxes, actual_bboxes, file_name, page_size):
"""Constructs a InputExample.
Args:
gui... | null |
38,744 | import logging
import os
import paddle
from paddle.io import Dataset
logger = logging.getLogger(__name__)
class InputFeatures(object):
def __init__(
self,
input_ids,
input_mask,
segment_ids,
label_ids,
boxes,
actual_bboxes,
... | null |
38,745 | import argparse
import copy
import logging
import os
import random
import sys
import numpy as np
import paddle
from seqeval.metrics import (
classification_report,
f1_score,
precision_score,
recall_score,
)
from xfun import XFUN
from paddlenlp.transformers import (
LayoutXLMForTokenClassification,
... | null |
38,746 | import argparse
import copy
import logging
import os
import random
import sys
import numpy as np
import paddle
from seqeval.metrics import (
classification_report,
f1_score,
precision_score,
recall_score,
)
from xfun import XFUN
from paddlenlp.transformers import (
LayoutXLMForTokenClassification,
... | null |
38,747 | import argparse
import copy
import logging
import os
import random
import sys
import numpy as np
import paddle
from seqeval.metrics import (
classification_report,
f1_score,
precision_score,
recall_score,
)
from xfun import XFUN
from paddlenlp.transformers import (
LayoutXLMForTokenClassification,
... | print arguments |
38,748 | import json
import os
import cv2
import numpy as np
import paddle
import copy
from paddle.io import Dataset
def get_relation_span(rel, entities):
bound = []
for entity_index in [rel["head"], rel["tail"]]:
bound.append(entities[entity_index]["start"])
bound.append(entities[entity_index]["end"])
... | null |
38,749 | import json
import os
import cv2
import numpy as np
import paddle
import copy
from paddle.io import Dataset
def reformat(data):
new_data = {}
for item in data:
for k, v in item.items():
if k not in new_data:
new_data[k] = []
new_data[k].append(v)
return new_d... | null |
38,750 | import sys
import os
import random
import numbers
import logging
import argparse
import paddle
import numpy as np
from paddlenlp.transformers import LayoutXLMModel, LayoutXLMTokenizer, LayoutXLMForRelationExtraction
from xfun import XFUN
def parse_args():
parser = argparse.ArgumentParser()
# Required parameter... | null |
38,751 | import sys
import os
import random
import numbers
import logging
import argparse
import paddle
import numpy as np
from paddlenlp.transformers import LayoutXLMModel, LayoutXLMTokenizer, LayoutXLMForRelationExtraction
from xfun import XFUN
The provided code snippet includes necessary dependencies for implementing the `p... | print arguments |
38,752 | import sys
import numpy as np
import paddle
import torch
def get_input_demo(platform="paddle", device="cpu"):
info = paddle.load("fake_input_paddle_xlm.data")
# imgs = np.random.rand(info["input_ids"].shape[0], 3, 224, 224).astype(np.float32)
# info["image"] = paddle.to_tensor(imgs)
if platform == "torc... | null |
38,753 | import sys
import numpy as np
import paddle
import torch
def get_input_demo(platform="paddle", device="cpu"):
info = paddle.load("fake_input_paddle_xlm.data")
# imgs = np.random.rand(info["input_ids"].shape[0], 3, 224, 224).astype(np.float32)
# info["image"] = paddle.to_tensor(imgs)
if platform == "torc... | null |
38,754 | import sys
import numpy as np
import paddle
import torch
def get_statistic_info(x, y):
mean_abs_diff = np.mean(np.abs(x - y))
max_abs_diff = np.max(np.abs(x - y))
return mean_abs_diff, max_abs_diff | null |
38,755 | import argparse
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
os.environ["FLAGS_use_cuda_managed_memory"] = "true"
import paddle
import torch
from paddlenlp.transformers import LlamaForCausalLM
def merge(args):
model_dict = {}
# load the first item: blip2-flan-t5-xxl
state_dict = paddle.load(args.blip... | null |
38,756 | import argparse
import os
import requests
from PIL import Image
from paddlenlp.transformers import MiniGPT4ForConditionalGeneration, MiniGPT4Processor
def predict(args):
# load MiniGPT4 moel and processor
model = MiniGPT4ForConditionalGeneration.from_pretrained(args.pretrained_name_or_path)
model.eval()
... | null |
38,757 | import argparse
import os
import random
import time
import numpy as np
import paddle
from paddle.io import DataLoader
from utils import DataCollatorMLM
from paddlenlp.trainer.argparser import strtobool
from paddlenlp.transformers import (
LinearDecayWithWarmup,
RobertaConfig,
RobertaForMaskedLM,
)
IGNORE = ... | null |
38,758 | import math
import time
import paddle
from args import parse_args, print_args
from dataset import OneBillionWordDataset, load_vocab
from elmo import ELMo, ELMoLoss
from paddle.io import DataLoader
def load_vocab(vocab_file=None, max_word_length=50):
if vocab_file is None:
return CharsVocabulary(max_word_le... | null |
38,759 | import argparse
import os
import re
import numpy as np
import paddle
import paddle.distributed as dist
import paddle.nn as nn
from gensim.models.keyedvectors import KeyedVectors
from paddle.io import DataLoader, Dataset
from sklearn.model_selection import train_test_split
def parse_args():
parser = argparse.Argume... | null |
38,760 | import argparse
import os
import re
import numpy as np
import paddle
import paddle.distributed as dist
import paddle.nn as nn
from gensim.models.keyedvectors import KeyedVectors
from paddle.io import DataLoader, Dataset
from sklearn.model_selection import train_test_split
def load_data_and_labels(positive_data_file, ne... | null |
38,761 | import argparse
def parse_args():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--train_data_path", type=str, default="./1-billion-word/training-tokenized-shuffled/*", help="Specify the path to load train data.")
parser.add_argument("--dev_data_path", type=str, default="./1-bil... | null |
38,762 | import argparse
def print_args(args):
print("----------- Configuration Arguments -----------")
for arg, value in sorted(vars(args).items()):
print("%s: %s" % (arg, value))
print("------------------------------------------------") | null |
38,763 | import argparse
import os
import re
import numpy as np
import paddle
import paddle.distributed as dist
import paddle.nn as nn
from dataset import load_vocab
from elmo import get_elmo_layer
from paddle.io import DataLoader, Dataset
from sklearn.model_selection import train_test_split
def parse_args():
parser = argp... | null |
38,764 | import argparse
import os
import re
import numpy as np
import paddle
import paddle.distributed as dist
import paddle.nn as nn
from dataset import load_vocab
from elmo import get_elmo_layer
from paddle.io import DataLoader, Dataset
from sklearn.model_selection import train_test_split
def load_data_and_labels(positive_da... | null |
38,765 | from typing import List
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
import paddle.nn.initializer as I
from dataset import create_batches, load_vocab
def reverse_sequence(x, sequence_lengths):
batch_size = x.shape[0]
sequence_lengths = sequence_lengths.numpy().data
... | null |
38,766 | from typing import List
import numpy as np
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
import paddle.nn.initializer as I
from dataset import create_batches, load_vocab
class ELMo(nn.Layer):
def __init__(
self,
batch_size=None,
char_embed_dim=16,
projection_d... | null |
38,767 | import glob
import random
from copy import deepcopy
from typing import List
import numpy as np
import paddle
from paddle.io import IterableDataset
def create_one_batch(sentences, vocab, max_seq_len):
# Add <S>, </S> for every sentence
max_len = max([len(sentence) for sentence in sentences]) + 2
max_len = mi... | Batch the sentences as character ids Each sentence is a list of tokens without <s> or </s>, e.g. [['The', 'first', 'sentence', '.'], ['Second', '.']] |
38,768 | import os
import time
import paddle
import paddle.distributed as dist
import paddle.nn as nn
from args import parse_args, print_args
from dataset import OneBillionWordDataset, load_vocab
from elmo import ELMo, ELMoLoss
from paddle.io import DataLoader
def save_params(elmo, optimizer, save_dir, name):
elmo_ckpt = os... | null |
38,769 | from collections import OrderedDict
import argparse
huggingface_to_paddle = {
".attn.": ".",
"intermediate.dense": "ffn",
"output.dense": "ffn_output",
".output.LayerNorm.": ".layer_norm.",
".LayerNorm.": ".layer_norm.",
"lm_head.decoder.bias": "lm_head.decoder_bias",
}
skip_weights = ["lm_head.... | null |
38,770 | import math
import time
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from typing import Dict, List, Optional
import numpy as np
import paddle
from paddle.io import DataLoader, Dataset
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack
f... | null |
38,771 | import argparse
from functools import partial
import os
import paddle
from paddle.io import DataLoader
import pandas as pd
from tqdm import tqdm
from paddlenlp.datasets import load_dataset
from paddlenlp.data import Tuple, Pad
from paddlenlp.transformers import MPNetForSequenceClassification, MPNetTokenizer
from run_gl... | null |
38,772 | import argparse
from functools import partial
import os
import paddle
from paddle.io import DataLoader
import pandas as pd
from tqdm import tqdm
from paddlenlp.datasets import load_dataset
from paddlenlp.data import Tuple, Pad
from paddlenlp.transformers import MPNetForSequenceClassification, MPNetTokenizer
from run_gl... | null |
38,773 | import json
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from typing import List, Optional
import numpy as np
import paddle
from datasets import load_dataset
from paddle.io import DataLoader, Dataset
from paddlenlp.data import Pad, Stack
from paddlenlp.metri... | null |
38,774 | import json
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from typing import List, Optional
import numpy as np
import paddle
from datasets import load_dataset
from paddle.io import DataLoader, Dataset
from paddlenlp.data import Pad, Stack
from paddlenlp.metri... | null |
38,775 | import paddle
from paddlenlp.transformers import RWConfig, RWForCausalLM, RWTokenizer
def parse_arguments():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--model_name_or_path", default="tiiuae/falcon-7b", help="The directory of model.")
parser.add_argument("--batch_size", ty... | null |
38,776 | import paddle
from paddlenlp.transformers import RWConfig, RWForCausalLM, RWTokenizer
def batchfy_text(texts, batch_size):
batch_texts = []
batch_start = 0
while batch_start < len(texts):
batch_texts += [texts[batch_start : min(batch_start + batch_size, len(texts))]]
batch_start += batch_si... | null |
38,777 | import argparse
import os
import random
import time
from functools import partial
from math import ceil
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics imp... | null |
38,778 | import argparse
import os
import random
import time
from functools import partial
from math import ceil
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics imp... | null |
38,779 | import argparse
import os
import random
import time
from functools import partial
from math import ceil
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics imp... | print arguments |
38,780 | import numpy as np
def custom_convert_example(example, tokenizer, data_args, is_test=True):
source = None
title = None
target = None
if "source" in example and "title" in example:
source = example["source"]
if "title" in example.keys():
title = example["title"]
elif "con... | null |
38,781 | import paddle
from paddle.distributed import fleet
from paddlenlp.peft import LoRAConfig, LoRAModel
from paddlenlp.transformers import (
AutoConfig,
AutoModelForConditionalGeneration,
AutoTokenizer,
)
def parse_arguments():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument... | null |
38,782 | import paddle
from paddle.distributed import fleet
from paddlenlp.peft import LoRAConfig, LoRAModel
from paddlenlp.transformers import (
AutoConfig,
AutoModelForConditionalGeneration,
AutoTokenizer,
)
def batchfy_text(texts, batch_size):
batch_texts = []
batch_start = 0
while batch_start < len(... | null |
38,783 | import argparse
import logging
import os
import time
from pprint import pprint
import numpy as np
import paddle
import paddle.distributed as dist
import yaml
from attrdict import AttrDict
from mem_transformer import MemTransformerLM
from reader import get_lm_data_loader, get_lm_vocab
def parse_args():
parser = arg... | null |
38,784 | import argparse
import logging
import os
import time
from pprint import pprint
import numpy as np
import paddle
import paddle.distributed as dist
import yaml
from attrdict import AttrDict
from mem_transformer import MemTransformerLM
from reader import get_lm_data_loader, get_lm_vocab
logger = logging.getLogger(__name__... | null |
38,785 | import paddle
import paddle.nn as nn
import paddle.nn.functional as F
global_dtype = paddle.get_default_dtype()
def sample_logits(embedding, bias, labels, inputs, sampler):
true_log_probs, samp_log_probs, neg_samples = sampler.sample(labels)
n_sample = neg_samples.shape[0]
b1, b2 = labels.shape[0], labels.... | null |
38,786 | import argparse
import logging
import os
from pprint import pprint
import numpy as np
import paddle
import yaml
from attrdict import AttrDict
from mem_transformer import MemTransformerLM
from reader import get_lm_data_loader, get_lm_vocab
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument... | null |
38,787 | import argparse
import logging
import os
from pprint import pprint
import numpy as np
import paddle
import yaml
from attrdict import AttrDict
from mem_transformer import MemTransformerLM
from reader import get_lm_data_loader, get_lm_vocab
logger = logging.getLogger(__name__)
class MemTransformerLM(nn.Layer):
def _... | null |
38,788 | import os
def read_data(fname, word2idx):
"""
Data is processed into a one-dimensional vector, and each value is the code corresponding to a word.
The two sentences are separated by special characters < EOS >.
Args:
fname (str):
data filename
word2idx (dict):
word... | load data Args: config: config Returns: word dict, and train, valid, test data |
38,789 | import argparse
import os
import random
import string
import time
import numpy as np
import paddle
import paddle.nn as nn
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import (
BigBirdForSequenceClassification,
BigBirdTokenizer,
create_bigbird_rand_... | null |
38,790 | import argparse
import os
import random
import string
import time
import numpy as np
import paddle
import paddle.nn as nn
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import (
BigBirdForSequenceClassification,
BigBirdTokenizer,
create_bigbird_rand_... | null |
38,791 | import argparse
import os
import random
import string
import time
import numpy as np
import paddle
import paddle.nn as nn
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import (
BigBirdForSequenceClassification,
BigBirdTokenizer,
create_bigbird_rand_... | null |
38,792 | import argparse
import os
import random
import string
import time
import numpy as np
import paddle
import paddle.nn as nn
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import (
BigBirdForSequenceClassification,
BigBirdTokenizer,
create_bigbird_rand_... | null |
38,793 | import argparse
from paddlenlp.trainer.argparser import strtobool
def strtobool(v):
if isinstance(v, bool):
return v
if v.lower() in ("yes", "true", "t", "y", "1"):
return True
elif v.lower() in ("no", "false", "f", "n", "0"):
return False
else:
raise ArgumentTypeError(
... | null |
38,794 | import os
import random
import time
from functools import partial
import args
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics import AccuracyAndF1, Mcc, PearsonAndSpea... | null |
38,795 | import os
import random
import time
from functools import partial
import args
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics import AccuracyAndF1, Mcc, PearsonAndSpea... | print arguments |
38,796 | import os
import random
import time
import args
import numpy as np
import paddle
from paddle.io import DataLoader, Dataset
from paddlenlp.data import Stack
from paddlenlp.transformers import (
BigBirdForPretraining,
BigBirdPretrainingCriterion,
BigBirdTokenizer,
LinearDecayWithWarmup,
create_bigbird... | null |
38,797 | import json
import math
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from args import parse_args
from paddle.io import DataLoader
from paddlenlp.data import Dict, Pad, Stack
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics.squad import compute_pred... | null |
38,798 | import argparse
def parse_args():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--train_file", type=str, required=False, default=None, help="Train data path.")
parser.add_argument("--predict_file", type=str, required=False, default=None, help="Predict data path.")
parser.ad... | null |
38,799 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics import AccuracyAndF1, Mcc... | null |
38,800 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics import AccuracyAndF1, Mcc... | null |
38,801 | import argparse
import os
import random
import time
from functools import partial
import numpy as np
import paddle
from paddle.io import DataLoader
from paddle.metric import Accuracy
from paddlenlp.data import Pad, Stack, Tuple
from paddlenlp.datasets import load_dataset
from paddlenlp.metrics import AccuracyAndF1, Mcc... | print arguments |
38,802 | import argparse
import logging
import random
import numpy as np
import paddle
import paddle.distributed as dist
from data_processor import DataGenerator, MrpcProcessor, XNLIProcessor
from paddle.io import DataLoader, DistributedBatchSampler
from paddle.metric import Accuracy
from tqdm import tqdm
from trainer import Tr... | null |
38,803 | import argparse
import logging
import random
import numpy as np
import paddle
import paddle.distributed as dist
from data_processor import DataGenerator, MrpcProcessor, XNLIProcessor
from paddle.io import DataLoader, DistributedBatchSampler
from paddle.metric import Accuracy
from tqdm import tqdm
from trainer import Tr... | null |
38,804 | import paddle
from paddle.optimizer import AdamW
from tqdm import tqdm
from paddlenlp.transformers import LinearDecayWithWarmup
def _create_model_arguments(batch):
return batch | null |
38,805 | import paddle
from paddle import _C_ops
from paddle.framework import core
def is_fused_matmul_bias_supported():
if paddle.is_compiled_with_cuda() and not paddle.is_compiled_with_rocm() or paddle.is_compiled_with_xpu():
return hasattr(core.eager.ops.legacy, "fused_gemm_epilogue")
else:
return Fal... | null |
38,806 | import os
import paddle
from paddlenlp.transformers import LlamaConfig, LlamaForCausalLM
from paddlenlp.utils.log import logger
def merge_pipeline_parallel(tp_degree, pp_degree, path):
tp_state_dict_list = []
for tp in range(tp_degree):
tp_state_dict = {}
for pp in range(pp_degree):
... | null |
38,807 | import os
import paddle
from paddlenlp.transformers import LlamaConfig, LlamaForCausalLM
from paddlenlp.utils.log import logger
logger = Logger()
The provided code snippet includes necessary dependencies for implementing the `merge_tensor_parallel` function. Write a Python function `def merge_tensor_parallel(cls, sta... | the entry of converting config and converting model file Args: input_dir (str | None): the input dir which contains `pytorch_model.bin` and `config.json` file config (PretrainedConfig): the PretrainedConfig instance of model |
38,808 | import time
from typing import Any, Dict, List, Optional, Tuple, Union
import numpy as np
import paddle
import paddle.nn as nn
from paddle.optimizer.lr import LambdaDecay
from rouge import Rouge
from sklearn.metrics import accuracy_score
from paddlenlp.metrics import BLEU
from paddlenlp.trainer import PrinterCallback, ... | null |
38,809 | import time
from typing import Any, Dict, List, Optional, Tuple, Union
import numpy as np
import paddle
import paddle.nn as nn
from paddle.optimizer.lr import LambdaDecay
from rouge import Rouge
from sklearn.metrics import accuracy_score
from paddlenlp.metrics import BLEU
from paddlenlp.trainer import PrinterCallback, ... | null |
38,810 | import os
import random
import sys
import types
from collections import OrderedDict
from dataclasses import dataclass, field
from typing import List, Optional
import numpy as np
import paddle
import paddle.distributed as dist
from paddle.distributed import fleet
from paddlenlp.ops import Topology
from paddlenlp.trainer... | null |
38,811 | import os
import random
import sys
import types
from collections import OrderedDict
from dataclasses import dataclass, field
from typing import List, Optional
import numpy as np
import paddle
import paddle.distributed as dist
from paddle.distributed import fleet
from paddlenlp.ops import Topology
from paddlenlp.trainer... | null |
38,812 | import os
import random
import sys
import types
from collections import OrderedDict
from dataclasses import dataclass, field
from typing import List, Optional
import numpy as np
import paddle
import paddle.distributed as dist
from paddle.distributed import fleet
from paddlenlp.ops import Topology
from paddlenlp.trainer... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.