id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
163,884 | from sacred import Experiment
from pace.modules import decode_utils
def step50k():
max_epoch = 100
max_steps = 50000 | null |
163,885 | from sacred import Experiment
from pace.modules import decode_utils
def step100k():
max_epoch = 100
max_steps = 100000 | null |
163,886 | from sacred import Experiment
from pace.modules import decode_utils
def step200k():
max_epoch = 200
max_steps = 200000 | null |
163,887 | from sacred import Experiment
from pace.modules import decode_utils
def vit32_base():
vit = "vit_base_patch32_384"
patch_size = 32
hidden_size = 768
num_heads = 12
num_layers = 12 | null |
163,888 | import torch
from pytorch_lightning.metrics import Metric
The provided code snippet includes necessary dependencies for implementing the `scores_to_ranks` function. Write a Python function `def scores_to_ranks(scores: torch.Tensor)` to solve the following problem:
Convert model output scores into ranks.
Here is the f... | Convert model output scores into ranks. |
163,889 | import random
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
Image.MAX_IMAGE_PIXELS = None
def TranslateX(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
assert -0.45 <= v <= 0.45
if random.random() > 0.5:
v = -v
v = v * img.size... | null |
163,890 | import random
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
Image.MAX_IMAGE_PIXELS = None
def TranslateY(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
assert -0.45 <= v <= 0.45
if random.random() > 0.5:
v = -v
v = v * img.size... | null |
163,894 | import random
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
Image.MAX_IMAGE_PIXELS = None
def SamplePairing(imgs): # [0, 0.4]
def f(img1, v):
i = np.random.choice(len(imgs))
img2 = PIL.Image.fromarray(imgs[i])
return PIL.Ima... | null |
163,899 | import json
import glob
import argparse
def parse_prediction(file_name):
predictions = json.load(open(file_name, 'r'))
output_result = {}
for item in predictions:
pred_eid, pred_response = item['turn_id'], item['predictions']
output_result[pred_eid] = pred_response
return output_result
... | null |
163,900 | from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import json
import nltk
import numpy as np
def normalize_sentence(sentence):
"""Normalize the sentences and tokenize."""
return nltk.tokenize.word_tokenize(sentence.lower())
from nltk.stem.porter import PorterSte... | Evaluates response generation using the raw data and model predictions. Args: gt_responses: Ground truth responses. model_responses: Generated responses. single_round_eval: Evaluate only for the last turn. record_instance_results: Save path for instance level metrics. |
163,901 | from pace.utils.write_mmconv_rg import MMConvRGExtract
from collections import defaultdict, Counter
import re
import math
import json
import nltk
from nltk.util import ngrams
import numpy as np
def normalize_sentence(sentence):
"""Normalize the sentences and tokenize."""
flag = False
while not flag:
... | null |
163,902 | from pace.utils.write_mmconv_rg import MMConvRGExtract
from collections import defaultdict, Counter
import re
import math
import json
import nltk
from nltk.util import ngrams
import numpy as np
def normalize_sentence(sentence):
"""Normalize the sentences and tokenize."""
flag = False
while not flag:
... | null |
163,903 | import json
import re
import os
import copy
import numpy as np
def evaluate_from_flat_list(d_true, d_pred):
"""
<list>d_true and <list>d_pred are in the following format:
(Each element represents a single turn, with (multiple) frames)
[
[
{
'act': <str>,
... | null |
163,904 | import json
import os
import pandas as pd
import pyarrow as pa
import random
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2captions, iid2split):
import random
random.seed(33)
def make_arrow(root, dataset_root):
with open(f"{root}/karpathy/dataset_coco.jso... | null |
163,905 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2pos, iid2neg, iid2split):
name = path.split("/")[-1]
with open(path, "rb") as fp:
binary = fp.read()
pos = ii... | null |
163,906 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2pos, iid2neg, iid2split):
name = path.split("/")[-1]
with open(path, "rb") as fp:
binary = fp.read()
pos = ii... | null |
163,907 | import pyarrow as pa
import pandas as pd
from tqdm import tqdm
from PIL import Image
import numpy as np
import json
import os
import gc
import io
def iid2content(dialog,imgs_root,split):
image_hash =str(dialog['image_hash'])
rounds = len(dialog['dialog'])
turns = dialog['dialog']
path = os.path.join(img... | null |
163,908 | import json
import pandas as pd
import pyarrow as pa
import random
import os
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2captions):
name = path.split("/")[-1]
iid = int(name[:-4])
with open(path, "rb") as fp:
binary = fp.read()
cdicts =... | null |
163,909 | import re
import json
from collections import defaultdict
slot_split = slot.split()
act = slot_split[-1]
name = slot_split[0] if slot_split[0] in slot_values else ' '.join(slot_split[:2])
value = ' '.join(slot_split[len(name.split()): -1])
if not value:
value = None
return name, value, a... | null |
163,910 | import re
import json
from collections import defaultdict
contractions =
manual_map = {
"none": "0",
"zero": "0",
"one": "1",
"two": "2",
"three": "3",
"four": "4",
"five": "5",
"six": "6",
"seven": "7",
"eight": "8",
"nine": "9",
"ten": "10",
}
articles = ["a", "an", "th... | null |
163,911 | import json
import pandas as pd
import pyarrow as pa
import gc
import random
import os
from tqdm import tqdm
from glob import glob
def path2rest(path, iid2captions):
split, _, name = path.split("/")[-3:]
split = split.split("_")[-1]
iid = name
with open(path, "rb") as fp:
binary = fp.read()
... | null |
163,912 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
class MMConvPreProcess():
def __init__(self) -> None:
def get_token_text(self, token):
def next_token(... | null |
163,913 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
class MMConvPreProcess():
def __init__(self) -> None:
self.remove_tokens={'<|imagesource|>': {'<|system|>... | null |
163,914 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
class MMConvRGExtract():
def get_token_text(self, token):
def call(self, text, begin_token, end_token=None,... | null |
163,915 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def rerank_samples_by_length(tokenizer , dataset_root , names):
ret = get_all_columns(dataset_root ,names , colu... | null |
163,916 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def get_special_tokens(dataset_root , names):
ret = get_all_columns(dataset_root ,names , columns=["image", "sou... | null |
163,917 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def generate_vocab(extended_tokens_file , vocab_file, save_path):
ex_id = 0
with open(extended_tokens_file ,... | null |
163,918 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def do_statistic(tokenizer , dataset_root , names):
ret = get_all_columns(dataset_root ,names , columns=["image"... | null |
163,919 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def augment_data(dataset_root , names , turn_nums=[0,-2,-4]):
ret = get_all_columns(dataset_root ,names , column... | null |
163,920 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
def rewrite_rg_task_to_end2end(dataset_root , names):
ret = get_all_columns(dataset_root ,names , columns=["imag... | null |
163,921 | import json
import pandas as pd
import pyarrow as pa
import gc
import random
import os
from tqdm import tqdm
from glob import glob
def path2rest(path, iid2captions):
split, _, name = path.split("/")[-3:]
split = split.split("_")[-1]
iid = name
with open(path, "rb") as fp:
binary = fp.read()
... | null |
163,922 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
import Levenshtein
def make_results(ignore_index, outputs, extras):
span_pred = outputs['span'].detach().clone()... | null |
163,923 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
import Levenshtein
def gen_excerpts(text, nof_words=1):
def levenshtein_ratio(len1, len2, dist):
def match(text, sub... | null |
163,924 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
from copy import deepcopy
import re
import Levenshtein
remove_tokens={'<|imagesource|>': {'<|system|>', '<|user|>', '<|endofcontext|>', '<|endofresponse|... | null |
163,925 | import argparse
import json
import copy
import numpy as np
from pace.utils.eval_mmconv_rg import normalize_sentence
def reformat_turn(t):
frame = {
'act': t['act'],
'slots': [[s,v] for s, v in t['act_attributes']['slot_values'].items()],
'request_slots': t['act_attributes']['request_slots'],... | <list>d_true and <list>d_pred are in the following format: (Equivalent to "dialogue_data" field in the input data JSON file) [ { "dialogue": [ { "transcript_annotated": { 'act': <str>, 'act_attributes': { 'slot_values': { SLOT_NAME: SLOT_VALUE, ... }, 'request_slots': [ SLOT_NAME, ... ], 'objects': [ <int> ] } }, ... }... |
163,926 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from write_mmconv_rg import get_all_columns
from transformers import BertTokenizer
def ge... | null |
163,927 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from write_mmconv_rg import get_all_columns
from transformers import BertTokenizer
def get... | null |
163,928 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from write_mmconv_rg import get_all_columns
from transformers import BertTokenizer
def get... | null |
163,929 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from write_mmconv_rg import get_all_columns
from transformers import BertTokenizer
col... | null |
163,930 |
def paste_region(src_img, tar_img, bbox):
x1, y1, h, w = bbox[0], bbox[1], bbox[2], bbox[3]
x2, y2 = x1+w, y1+h
region = src_img.crop((x1,y1,x2,y2))
tar_img.paste(region, (x1,y1,x2,y2))
return tar_img, [str(x1), str(y1), str(x2), str(y2)] | null |
163,931 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from transformers import BertTokenizer
from write_mmconv_rg import get_all_columns
from PI... | null |
163,932 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from transformers import BertTokenizer
from write_mmconv_rg import get_all_columns
from PI... | null |
163,933 | import json
import pandas as pd
import numpy as np
import pyarrow as pa
import random
import os
import ipdb
import base64
import math
from io import BytesIO
from tqdm import tqdm
import jsonpath
import csv
import pickle
import re
from transformers import BertTokenizer
from write_mmconv_rg import get_all_columns
from PI... | null |
163,934 |
def rerank_samples_by_length(tokenizer , dataset_root , names):
columns = ['turn_id','image','target','source','none1','none2','simmc2-1','simmc2-2']
ret = get_all_columns(dataset_root ,names , columns=['turn_id','image','target','source','none1','none2','simmc2-1','simmc2-2'])
sources = ret['source'].to_... | null |
163,935 | import json
import os
import pandas as pd
import pyarrow as pa
import random
import gc
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2captions, iid2split):
name = path.split("/")[-1]
with open(path, "rb") as fp:
binary = fp.read()
captions = i... | null |
163,936 | from multiprocessing import current_process
import torch
import copy
def change_text_maxlen(state_dict, max_pos):
current_max_pos, embed_size = state_dict["text_embeddings.position_embeddings.weight"].shape
if max_pos > current_max_pos:
new_pos_embed = state_dict["text_embeddings.position_embeddings.w... | null |
163,937 | from multiprocessing import current_process
import torch
import copy
def expert_state_load(state_dict):
out_dict = {}
for k, v in state_dict.items():
out_dict[k] = v
if ".mlp" in k or ".norm2" in k:
new_iv = copy.deepcopy(v)
new_cv = copy.deepcopy(v)
new_tv =... | null |
163,938 | from multiprocessing import current_process
import torch
import copy
def resize_token_embedding(state_dict , new_vs):
word_embeddings = state_dict["text_embeddings.word_embeddings.weight"]
decoder_weight = state_dict["mlm_score.decoder.weight"]
decoder_bias = state_dict["mlm_score.bias"]
vs , hs = word... | null |
163,939 | import json
import pandas as pd
import pyarrow as pa
import gc
import random
import os
from tqdm import tqdm
from glob import glob
from collections import defaultdict
def path2rest(path, iid2captions, iid2split, iid2negims):
name = path.split("/")[-1]
with open(path, "rb") as fp:
binary = fp.read()
... | null |
163,940 | import re
import json
import argparse
from typing import Dict, List
def parse_flattened_result(to_parse):
raw_str = to_parse
reg = re.search(r'available[S|s]izes =.*( xxl | XXL | XL | xl | XS | xs | S | s | M | m | L | l )' , to_parse)
if reg != None:
start_pos , end_pos = reg.span()
t = to_... | Formats model predictions for subtask 2, 3. NOTE: This follows the format given by the baseline. Args: predictions <List[str]>: predictions outputted by model Returns: submission <List[Dict]>: submission format |
163,941 | import json
import pandas as pd
import pyarrow as pa
import gc
import random
import os
from tqdm import tqdm
from glob import glob
def path2rest(path, iid2captions):
split, name = path.split("/")[-2:]
split = split.split("_")[-1]
iid = name
with open(path, "rb") as fp:
binary = fp.read()
cap... | null |
163,942 | import argparse
import json
import os
import time
import multiprocessing
import datetime
import re
import random
import copy
from utils import experts_task
import openai
from tqdm import tqdm
args = parser.parse_args()
if args.eval_model == "gpt-4":
cost_per_promtp_token = 0.03 / 1000
cost_per_completion_token ... | null |
163,943 | import argparse
import json
import os
import time
import multiprocessing
import datetime
import re
import random
import copy
from utils import experts_task
import openai
from tqdm import tqdm
os.environ["OPENAI_API_KEY"] = "sk-*******"
def get_json_all(file_path):
file_path = os.path.expanduser(file_path)
json... | null |
163,944 |
def gen_prompt_aspectu_QA(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
####
# Output the three most important angles.
####
prompt = "... | null |
163,945 |
def gen_prompt_aspect_QA(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a user question “{questio... | null |
163,946 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_QA` function. Write a Python function `def gen_prompt_init_QA(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_QA(ques, ans1, ans2, asp):
"""
asp: 从哪个角度... | asp: 从哪个角度 |
163,947 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_QA` function. Write a Python function `def gen_prompt_QA(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]
He... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,948 |
def gen_prompt_aspectu_SUM(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a document “{question}”... | null |
163,949 |
def gen_prompt_aspect_SUM(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a document “{question}”,... | null |
163,950 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_SUM` function. Write a Python function `def gen_prompt_init_SUM(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_SUM(ques, ans1, ans2, asp):
"""
asp: 从哪... | asp: 从哪个角度 |
163,951 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_SUM` function. Write a Python function `def gen_prompt_SUM(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]
... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,952 |
def gen_prompt_aspectu_Story(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a story “{question}”,... | null |
163,953 |
def gen_prompt_aspect_Story(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a story “{question}”, ... | null |
163,954 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_Story` function. Write a Python function `def gen_prompt_init_Story(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_Story(ques, ans1, ans2, asp):
"""
a... | asp: 从哪个角度 |
163,955 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_Story` function. Write a Python function `def gen_prompt_Story(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ..... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,956 |
def gen_prompt_aspectu_DataText(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for the structural dat... | null |
163,957 |
def gen_prompt_aspect_DataText(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for the structural data... | null |
163,958 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_DataText` function. Write a Python function `def gen_prompt_init_DataText(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_DataText(ques, ans1, ans2, asp):
... | asp: 从哪个角度 |
163,959 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_DataText` function. Write a Python function `def gen_prompt_DataText(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], ... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,960 |
def gen_prompt_aspectu_NLI(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a sentence “{question}”... | null |
163,961 |
def gen_prompt_aspect_NLI(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a sentence “{question}”,... | null |
163,962 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_NLI` function. Write a Python function `def gen_prompt_init_NLI(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_NLI(ques, ans1, ans2, asp):
"""
asp: 从哪... | asp: 从哪个角度 |
163,963 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_NLI` function. Write a Python function `def gen_prompt_NLI(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]
... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,964 |
def gen_prompt_aspectu_SDia(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a dialogue context “{q... | null |
163,965 |
def gen_prompt_aspect_SDia(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a dialogue context “{qu... | null |
163,966 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_SDia` function. Write a Python function `def gen_prompt_init_SDia(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_SDia(ques, ans1, ans2, asp):
"""
asp:... | asp: 从哪个角度 |
163,967 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_SDia` function. Write a Python function `def gen_prompt_SDia(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,968 |
def gen_prompt_aspectu_MDia(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for two dialogues “{answer... | null |
163,969 |
def gen_prompt_aspect_MDia(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for two dialogues “{answer_... | null |
163,970 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_MDia` function. Write a Python function `def gen_prompt_init_MDia(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_MDia(ques, ans1, ans2, asp):
"""
asp:... | asp: 从哪个角度 |
163,971 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_MDia` function. Write a Python function `def gen_prompt_MDia(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,972 |
def gen_prompt_aspectu_SaQA(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a user question “{ques... | null |
163,973 |
def gen_prompt_aspect_SaQA(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a user question “{quest... | null |
163,974 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_SaQA` function. Write a Python function `def gen_prompt_init_SaQA(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_SaQA(ques, ans1, ans2, asp):
"""
asp:... | asp: 从哪个角度 |
163,975 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_SaQA` function. Write a Python function `def gen_prompt_SaQA(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,976 |
def gen_prompt_aspectu_Code(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a programming problem ... | null |
163,977 |
def gen_prompt_aspect_Code(ques, ans1, ans2, num):
# prompt = """
# 帮我总结一下，如果我想面向一个用户问题“{question}”，来判断两个模型的回复，分别是“{answer_1}”和“{answer_2}”，需要从哪些角度去评估两个回复哪个更好？
# 输出每个角度的名称和评估内容，每行是一个评估角度，用换行来分割不同的评估角度，每个评估角度均由$开头，由&结束
# """
prompt = """
Please help me summarize that for a programming problem “... | null |
163,978 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_init_Code` function. Write a Python function `def gen_prompt_init_Code(ques, ans1, ans2, asp)` to solve the following problem:
asp: 从哪个角度
Here is the function:
def gen_prompt_init_Code(ques, ans1, ans2, asp):
"""
asp:... | asp: 从哪个角度 |
163,979 |
The provided code snippet includes necessary dependencies for implementing the `gen_prompt_Code` function. Write a Python function `def gen_prompt_Code(ques, ans1, ans2, m1, m2, aspects)` to solve the following problem:
m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...]... | m1: [正向content，逆向content] own m2: [正向content，逆向content] others aspects: [[accuracy, xxx], [], ...] |
163,982 | import numpy as np
import torch
import torch.nn.functional as F
def equal(x, y, dtype=None):
""" Implement equal in dygraph mode. (paddle) """
if dtype is None:
dtype = "float32"
if isinstance(x, torch.Tensor):
x = x.numpy()
if isinstance(y, torch.Tensor):
y = y.numpy()
out =... | Implement not_equal in dygraph mode. (paddle) |
163,983 |
The provided code snippet includes necessary dependencies for implementing the `batch` function. Write a Python function `def batch(reader, batch_size, drop_last=False)` to solve the following problem:
This operator creates a batched reader which combines the data from the input reader to batched data. Args: reader(g... | This operator creates a batched reader which combines the data from the input reader to batched data. Args: reader(generator): the data reader to read from. batch_size(int): size of each mini-batch. drop_last(bool, optional): If set to True, the last batch is dropped when the size of last batch is not equal to batch_si... |
163,993 | import math
import os
import numpy as np
from space.args import str2bool
from space.data.batch import batch
from space.data.dataset import LazyDataset
from space.data.sampler import RandomSampler
from space.data.sampler import SequentialSampler
from space.data.sampler import SortedSampler
def get_data_loader(batch_size... | null |
163,994 | import multiprocessing
import random
from itertools import chain
import os
import glob
import json
import numpy as np
import time
import re
from tqdm import tqdm
from space.args import str2bool
from space.data.tokenizer import Tokenizer
from space.utils import ontology
from space.utils.scores import hierarchical_set_sc... | null |
163,997 | import json
import logging
import os
import sys
import time
from collections import OrderedDict
import torch
import numpy as np
from tqdm import tqdm
from transformers.optimization import AdamW, get_linear_schedule_with_warmup
from space.args import str2bool
from space.data.data_loader import DataLoader
from space.metr... | null |
163,998 | import json
import logging
import os
import sys
import time
from collections import OrderedDict
import torch
import numpy as np
from tqdm import tqdm
from transformers.optimization import AdamW, get_linear_schedule_with_warmup
from space.args import str2bool
from space.data.data_loader import DataLoader
from space.metr... | null |
163,999 | import bisect
import math
import numpy as np
import torch
from space.args import str2bool
def repeat(var, times):
if isinstance(var, list):
return [repeat(x, times) for x in var]
elif isinstance(var, dict):
return {k: repeat(v, times) for k, v in var.items()}
elif isinstance(var, torch.Tens... | null |
164,000 | import bisect
import math
import numpy as np
import torch
from space.args import str2bool
def gather(var, idx):
if isinstance(var, list):
return [gather(x, idx) for x in var]
elif isinstance(var, dict):
return {k: gather(v, idx) for k, v in var.items()}
elif isinstance(var, torch.Tensor):
... | null |
164,001 |
def ignore_nodes(node_names):
node_names = [node_name.strip().lower() for node_name in node_names]
def decorator(func):
def wrapper(*args, **kwargs):
new_res = ()
res = func(*args, **kwargs)
assert isinstance(res, tuple)
assert isinstance(res[0], list)
... | null |
164,003 | db_tokens = ['<sos_db>', '<eos_db>',
'[book_nores]', '[book_fail]', '[book_success]',
'[db_nores]', '[db_0]', '[db_1]', '[db_2]', '[db_3]']
def get_special_tokens(understand_tokens):
special_tokens = ['<go_r>', '<go_b>', '<go_a>', '<go_d>',
'<eos_u>', '<eos_r>', '<eo... | null |
164,004 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
def compute_kl_loss(p, q, filter_scores=None):
p_loss = F.kl_div(F.log_softmax(p, dim=-1), F.softmax(q, dim=-1), reduction='none')
q_loss = F.kl_div(F.log_softmax(q, dim=-1), F.softmax(p, dim=-1), reducti... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.