code stringlengths 17 6.64M |
|---|
def format_metric(metric):
'\n 把计算出的评价指标转化为str，float保留四位小数\n :param metric:\n :return:\n \n Convert the evaluation measures into str, keep four decimal places for float\n :param metric:\n :return:\n '
if ((type(metric) is not tuple) and (type(metric) is not list)):
metric = [me... |
def shuffle_in_unison_scary(data):
'\n shuffle整个数据集dict的内容\n :param data:\n :return:\n \n shuffle the contents of the dict of whole dataset\n :param data:\n :return:\n '
rng_state = np.random.get_state()
for d in data:
np.random.set_state(rng_state)
np.random.shuffl... |
def best_result(metric, results_list):
'\n 求一个结果list中最佳的结果\n :param metric:\n :param results_list:\n :return:\n \n Compute the best result in a list of results\n :param metric:\n :param results_list:\n :return:\n '
if ((type(metric) is list) or (type(metric) is tuple)):
m... |
def strictly_increasing(l):
'\n 判断是否严格单调增\n :param l:\n :return:\n \n Test if monotonically increasing\n :param l:\n :return:\n '
return all(((x < y) for (x, y) in zip(l, l[1:])))
|
def strictly_decreasing(l):
'\n 判断是否严格单调减\n :param l:\n :return:\n \n Test if monotonically decreasing\n :param l:\n :return:\n '
return all(((x > y) for (x, y) in zip(l, l[1:])))
|
def non_increasing(l):
'\n 判断是否单调非增\n :param l:\n :return:\n \n Test if monotonically non-increasing\n :param l:\n :return:\n '
return all(((x >= y) for (x, y) in zip(l, l[1:])))
|
def non_decreasing(l):
'\n 判断是否单调非减\n :param l:\n :return:\n \n Test if monotonically non-decreasing\n :param l:\n :return:\n '
return all(((x <= y) for (x, y) in zip(l, l[1:])))
|
def monotonic(l):
'\n 判断是否单调\n :param l:\n :return:\n \n Test if monotonic\n :param l:\n :return:\n '
return (non_increasing(l) or non_decreasing(l))
|
def numpy_to_torch(d, gpu=True, requires_grad=True):
'\n numpy array转化为pytorch tensor，有gpu则放到gpu\n :param d:\n :param gpu: whether put tensor to gpu\n :param requires_grad: whether the tensor requires grad\n :return:\n \n Convert numpy array to pytorch tensor, if there is gpu then put into gp... |
def tensor_to_gpu(t):
if (torch.cuda.device_count() > 0):
t = t.cuda()
return t
|
def get_init_paras_dict(class_name, paras_dict):
base_list = inspect.getmro(class_name)
paras_list = []
for base in base_list:
paras = inspect.getfullargspec(base.__init__)
paras_list.extend(paras.args)
paras_list = sorted(list(set(paras_list)))
out_dict = {}
for para in paras_... |
def check_dir_and_mkdir(path):
if ((os.path.basename(path).find('.') == (- 1)) or path.endswith('/')):
dirname = path
else:
dirname = os.path.dirname(path)
if (not os.path.exists(dirname)):
print('make dirs:', dirname)
os.makedirs(dirname)
return
|
class DataLoader(object):
'\n 只负责load数据集文件，记录一些数据集信息\n Only responsible for loading the dataset file, and recording some information of the dataset\n '
@staticmethod
def parse_data_args(parser):
'\n data loader 的数据集相关的命令行参数\n :param parser:\n :return:\n \n ... |
class ProLogicDL(DataLoader):
def __init__(self, path, dataset, *args, **kwargs):
"\n 初始化\n :param path: 数据集目录\n :param dataset: 数据集名称\n :param label: 标签column的名称\n :param load_data: 是否要载入数据文件，否则只载入数据集信息\n :param sep: csv的分隔符\n :param seqs_sep: 变长column的内部... |
class DataProcessor(object):
data_columns = [UID, IID, X]
info_columns = [SAMPLE_ID, TIME]
@staticmethod
def parse_dp_args(parser):
'\n 数据处理生成batch的命令行参数\n :param parser:\n :return:\n \n Command-line parameters to generate batches in data processing\n ... |
class HistoryDP(DataProcessor):
data_columns = [UID, IID, X, C_HISTORY, C_HISTORY_NEG]
info_columns = [SAMPLE_ID, TIME, C_HISTORY_LENGTH, C_HISTORY_NEG_LENGTH]
@staticmethod
def parse_dp_args(parser):
'\n 数据处理生成batch的命令行参数\n :param parser:\n :return:\n \n Co... |
class ProLogicDP(DataProcessor):
data_columns = [X]
info_columns = [SAMPLE_ID]
@staticmethod
def parse_dp_args(parser):
'\n 数据处理生成batch的命令行参数\n :param parser:\n :return:\n \n Command-line parameters to generate batches in data processing\n :param pars... |
class ProLogicRecDP(HistoryDP):
@staticmethod
def parse_dp_args(parser):
'\n 数据处理生成batch的命令行参数\n :param parser:\n :return:\n \n Command-line parameters to generate batches in data processing\n :param parser:\n :return:\n '
parser.add_arg... |
class RNNLogicDP(DataProcessor):
data_columns = [X]
info_columns = [SAMPLE_ID]
def __init__(self, *args, **kwargs):
DataProcessor.__init__(self, *args, **kwargs)
assert (self.rank == 0)
def get_feed_dict(self, data, batch_start, batch_size, train, neg_data=None, special_cols=None):
... |
def format_5core(in_json, out_csv, label01=True):
records = []
for line in open(in_json, 'r'):
record = json.loads(line)
records.append(record)
out_df = pd.DataFrame()
out_df[UID] = [r['reviewerID'] for r in records]
out_df[IID] = [r['asin'] for r in records]
out_df[LABEL] = [r... |
def main():
all_data_file = os.path.join(DATA_DIR, 'reviews_Electronics01_5.csv')
format_5core(in_json=os.path.join(RAW_DATA, 'reviews_Electronics_5.json'), out_csv=all_data_file, label01=True)
dataset_name = '5Electronics01-1-5'
leave_out_by_time_csv(all_data_file, dataset_name, leave_n=1, warm_n=5)
... |
def format_user_feature(out_file):
print('format_user_feature', USERS_FILE)
user_df = pd.read_csv(USERS_FILE, sep='|', header=None)
user_df = user_df[[0, 1, 2, 3]]
user_df.columns = [UID, 'u_age', 'u_gender', 'u_occupation']
(min_age, max_age) = (10, 60)
user_df['u_age'] = user_df['u_age'].app... |
def format_item_feature(out_file):
print('format_item_feature', ITEMS_FILE, out_file)
item_df = pd.read_csv(ITEMS_FILE, sep='|', header=None, encoding='ISO-8859-1')
item_df = item_df.drop([1, 3, 4], axis=1)
item_df.columns = [IID, 'i_year', 'i_Other', 'i_Action', 'i_Adventure', 'i_Animation', "i_Child... |
def format_all_inter(out_file, label01=True):
print('format_all_inter', RATINGS_FILE, out_file)
inter_df = pd.read_csv(RATINGS_FILE, sep='\t', header=None)
inter_df.columns = [UID, IID, LABEL, TIME]
inter_df = inter_df.sort_values(by=TIME)
inter_df = inter_df.drop_duplicates([UID, IID]).reset_inde... |
def main():
format_user_feature(USER_FEATURE_FILE)
format_item_feature(ITEM_FEATURE_FILE)
format_all_inter(ALL_DATA_FILE, label01=True)
dataset_name = 'ml100k01-1-5'
leave_out_by_time_csv(ALL_DATA_FILE, dataset_name, leave_n=1, warm_n=5, u_f=USER_FEATURE_FILE, i_f=ITEM_FEATURE_FILE)
return
|
def random_variables(num=100):
values = np.random.randint(2, size=num)
variables = dict(zip(range(1, (num + 1)), values))
return variables
|
def random_logic_sent(variables, min_or=1, max_or=5, min_and=1, max_and=5, v_ps=None):
num_or = np.random.randint(min_or, (max_or + 1))
ors = []
for i in range(num_or):
num_and = np.random.randint(min_and, (max_and + 1))
ands = []
for j in range(num_and):
if_not = np.ra... |
def calcu_logic_sent(sent, variables):
ors = sent.split('v')
for i in ors:
ands = i.split('^')
tmp_ands = 0
for j in ands:
if_not = j.startswith('~')
j = (int(j) if (not if_not) else int(j[1:]))
tmp = (variables[j] if (not if_not) else (1 - variables... |
def random_logic_dataset(sent_num=3000, variables_num=1000, min_or=1, max_or=5, min_and=1, max_and=5):
variables = random_variables(num=variables_num)
(sents, labels) = ([], [])
for i in tqdm(range(sent_num), leave=False, ncols=100, mininterval=1):
sent = random_logic_sent(variables, min_or=min_or... |
def main():
dataset_name = 'logic1k_3k-15-15'
(variables, dataset) = random_logic_dataset(variables_num=1000, sent_num=3000, min_and=1, max_and=5, min_or=1, max_or=5)
print(dataset)
dataset_dir = os.path.join(DATASET_DIR, dataset_name)
if (not os.path.exists(dataset_dir)):
os.mkdir(dataset... |
def build_run_environment(para_dict, dl_name, dp_name, model_name, runner_name):
if (type(para_dict) is str):
para_dict = eval(para_dict)
if (type(dl_name) is str):
dl_name = eval(dl_name)
if (type(dp_name) is str):
dp_name = eval(dp_name)
if (type(model_name) is str):
... |
def main():
init_parser = argparse.ArgumentParser(description='Model', add_help=False)
init_parser.add_argument('--rank', type=int, default=1, help='1=ranking, 0=rating/click')
init_parser.add_argument('--data_loader', type=str, default='', help='Choose data_loader')
init_parser.add_argument('--model_... |
class BiasedMF(RecModel):
def _init_weights(self):
self.uid_embeddings = torch.nn.Embedding(self.user_num, self.ui_vector_size)
self.iid_embeddings = torch.nn.Embedding(self.item_num, self.ui_vector_size)
self.user_bias = torch.nn.Embedding(self.user_num, 1)
self.item_bias = torch... |
class CNNLogic(DeepModel):
include_id = False
include_user_features = False
include_item_features = False
include_context_features = False
data_loader = 'ProLogicDL'
data_processor = 'RNNLogicDP'
@staticmethod
def parse_model_args(parser, model_name='CNNLogic'):
parser.add_arg... |
class DeepModel(BaseModel):
@staticmethod
def parse_model_args(parser, model_name='DeepModel'):
parser.add_argument('--f_vector_size', type=int, default=64, help='Size of feature vectors.')
parser.add_argument('--layers', type=str, default='[64]', help='Size of each layer.')
return Ba... |
class GRU4Rec(RecModel):
data_processor = 'HistoryDP'
@staticmethod
def parse_model_args(parser, model_name='GRU4Rec'):
parser.add_argument('--hidden_size', type=int, default=64, help='Size of hidden vectors in GRU.')
parser.add_argument('--num_layers', type=int, default=1, help='Number o... |
class NARM(GRU4Rec):
data_processor = 'HistoryDP'
@staticmethod
def parse_model_args(parser, model_name='NARM'):
parser.add_argument('--attention_size', type=int, default=16, help='Size of attention hidden space.')
return GRU4Rec.parse_model_args(parser, model_name)
def __init__(self... |
class RNNLogic(DeepModel):
include_id = False
include_user_features = False
include_item_features = False
include_context_features = False
data_loader = 'ProLogicDL'
data_processor = 'RNNLogicDP'
@staticmethod
def parse_model_args(parser, model_name='RNNLogic'):
parser.add_arg... |
class RecModel(BaseModel):
include_id = False
include_user_features = False
include_item_features = False
include_context_features = False
@staticmethod
def parse_model_args(parser, model_name='RecModel'):
parser.add_argument('--u_vector_size', type=int, default=64, help='Size of user... |
class SVDPP(RecModel):
data_processor = 'HistoryDP'
def _init_weights(self):
self.uid_embeddings = torch.nn.Embedding(self.user_num, self.ui_vector_size)
self.iid_embeddings = torch.nn.Embedding(self.item_num, self.ui_vector_size)
self.iid_embeddings_implicit = torch.nn.Embedding(self... |
class BaseRunner(object):
@staticmethod
def parse_runner_args(parser):
'\n 跑模型的命令行参数\n :param parser:\n :return:\n \n Command-line parameters to run the model\n :param parser:\n :return:\n '
parser.add_argument('--load', type=int, defaul... |
def qk_attention(query, key, value, valid=None, beta=1):
'\n :param query: ? * l * a\n :param key: ? * l * a\n :param value: ? * l * v\n :param valid: ? * l\n :param beta: smooth softmax\n :return: ? * v\n '
ele_valid = (1 if (valid is None) else valid.unsqueeze(dim=(- 1)))
att_v = (q... |
def seq_rnn(seq_vectors, valid, rnn, lstm=False, init=None):
'\n :param seq_vectors: b * l * v\n :param valid: b * l\n :param rnn: pytorch RNN object\n :param lstm:\n :param init:\n :return:\n '
seq_lengths = valid.sum(dim=(- 1))
n_samples = seq_lengths.size()[0]
seq_lengths_valid... |
def rank_loss(prediction, label, real_batch_size, loss_sum):
"\n 计算rank loss，类似BPR-max，参考论文:\n @inproceedings{hidasi2018recurrent,\n title={Recurrent neural networks with top-k gains for session-based recommendations},\n author={Hidasi, Bal{'a}zs and Karatzoglou, Alexandros},\n booktitle={Pro... |
def cold_sampling(vectors, cs_ratio):
'\n :param vectors: ? * v\n :param cs_ratio: 0 < cs_ratio < 1\n :return:\n '
cs_p = torch.empty(vectors.size()[:(- 1)]).fill_(cs_ratio).unsqueeze(dim=(- 1))
drop_pos = utils.tensor_to_gpu(torch.bernoulli(cs_p))
random_vectors = utils.tensor_to_gpu(torc... |
def group_user_interactions_csv(in_csv, out_csv, label=LABEL, sep=SEP):
print('group_user_interactions_csv', out_csv)
all_data = pd.read_csv(in_csv, sep=sep)
group_inters = group_user_interactions_df(in_df=all_data, label=label)
group_inters.to_csv(out_csv, sep=sep, index=False)
return group_inter... |
def group_user_interactions_df(in_df, pos_neg, label=LABEL, seq_sep=SEQ_SEP):
all_data = in_df
if (label in all_data.columns):
if (pos_neg == 1):
all_data = all_data[(all_data[label] > 0)]
elif (pos_neg == 0):
all_data = all_data[(all_data[label] <= 0)]
(uids, inter... |
def random_split_data(all_data_file, dataset_name, vt_ratio=0.1, copy_files=None, copy_suffixes=None):
'\n 随机切分已经生成的数据集文件 *.all.csv -> *.train.csv,*.validation.csv,*.test.csv\n :param all_data_file: 数据预处理完的文件 *.all.csv\n :param dataset_name: 给数据集起个名字\n :param vt_ratio: 验证集和测试集比例\n :param copy_files... |
def leave_out_by_time_df(all_df, leave_n=1, warm_n=5, split_n=1, max_user=(- 1)):
min_label = all_df[LABEL].min()
if (min_label > 0):
leave_df = all_df.groupby(UID).head(warm_n)
all_df = all_df.drop(leave_df.index)
split_dfs = []
for i in range(split_n):
total_uids ... |
def leave_out_by_time_csv(all_data_file, dataset_name, leave_n=1, warm_n=5, u_f=None, i_f=None):
'\n 默认all_data里的交互是按时间顺序排列的，按交互顺序，把最后的交互划分到验证集和测试集里\n :param all_data_file: 数据预处理完的文件 *.all.csv，交互按时间顺序排列\n :param dataset_name: 给数据集起个名字\n :param leave_n: 验证和测试集保留几个用户交互\n :param warm_n: 保证测试用户在训练集中至少有... |
def mean_reciprocal_rank(rs):
"Score is reciprocal of the rank of the first relevant item\n First element is 'rank 1'. Relevance is binary (nonzero is relevant).\n Example from http://en.wikipedia.org/wiki/Mean_reciprocal_rank\n >>> rs = [[0, 0, 1], [0, 1, 0], [1, 0, 0]]\n >>> mean_reciprocal_rank(rs... |
def r_precision(r):
'Score is precision after all relevant documents have been retrieved\n Relevance is binary (nonzero is relevant).\n >>> r = [0, 0, 1]\n >>> r_precision(r)\n 0.33333333333333331\n >>> r = [0, 1, 0]\n >>> r_precision(r)\n 0.5\n >>> r = [1, 0, 0]\n >>> r_precision(r)\n ... |
def precision_at_k(r, k):
'Score is precision @ k\n Relevance is binary (nonzero is relevant).\n >>> r = [0, 0, 1]\n >>> precision_at_k(r, 1)\n 0.0\n >>> precision_at_k(r, 2)\n 0.0\n >>> precision_at_k(r, 3)\n 0.33333333333333331\n >>> precision_at_k(r, 4)\n Traceback (most recent ca... |
def average_precision(r):
'Score is average precision (area under PR curve)\n Relevance is binary (nonzero is relevant).\n >>> r = [1, 1, 0, 1, 0, 1, 0, 0, 0, 1]\n >>> delta_r = 1. / sum(r)\n >>> sum([sum(r[:x + 1]) / (x + 1.) * delta_r for x, y in enumerate(r) if y])\n 0.7833333333333333\n >>> ... |
def mean_average_precision(rs):
'Score is mean average precision\n Relevance is binary (nonzero is relevant).\n >>> rs = [[1, 1, 0, 1, 0, 1, 0, 0, 0, 1]]\n >>> mean_average_precision(rs)\n 0.78333333333333333\n >>> rs = [[1, 1, 0, 1, 0, 1, 0, 0, 0, 1], [0]]\n >>> mean_average_precision(rs)\n ... |
def dcg_at_k(r, k, method=0):
'Score is discounted cumulative gain (dcg)\n Relevance is positive real values. Can use binary\n as the previous methods.\n Example from\n http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf\n >>> r = [3, 2, 3, 0, 0, 1, 2, 2, 3, 0]\n >>> dc... |
def ndcg_at_k(r, k, method=0):
'Score is normalized discounted cumulative gain (ndcg)\n Relevance is positive real values. Can use binary\n as the previous methods.\n Example from\n http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf\n >>> r = [3, 2, 3, 0, 0, 1, 2, 2, 3, 0... |
def parse_global_args(parser):
'\n 全局命令行参数\n :param parser:\n :return:\n \n Global command-line parameters\n :param parser:\n :return:\n '
parser.add_argument('--gpu', type=str, default='0', help='Set CUDA_VISIBLE_DEVICES')
parser.add_argument('--verbose', type=int, default=logging... |
def balance_data(data):
'\n 让正负样本数接近，正负样本数差距太大时使用\n :param data:\n :return:\n \n Make the number of positive and negative examples close, use when the difference between the number of positive/negative examples is too large\n :param data:\n :return:\n '
pos_indexes = np.where((data['Y'... |
def input_data_is_list(data):
'\n 如果data是一个dict的list，则合并这些dict，在测试多个数据集比如验证测试同时计算时\n :param data: dict or list\n :return:\n \n If data is a list of dict, then merge these dict, when testing multiple datasets, e.g., when validation and testing are done concurrently\n :param data: dict or list\n ... |
def format_metric(metric):
'\n 把计算出的评价指标转化为str，float保留四位小数\n :param metric:\n :return:\n \n Convert the evaluation measures into str, keep four decimal places for float\n :param metric:\n :return:\n '
if ((type(metric) is not tuple) and (type(metric) is not list)):
metric = [me... |
def shuffle_in_unison_scary(data):
'\n shuffle整个数据集dict的内容\n :param data:\n :return:\n \n shuffle the contents of the dict of whole dataset\n :param data:\n :return:\n '
rng_state = np.random.get_state()
for d in data:
np.random.set_state(rng_state)
np.random.shuffl... |
def best_result(metric, results_list):
'\n 求一个结果list中最佳的结果\n :param metric:\n :param results_list:\n :return:\n \n Compute the best result in a list of results\n :param metric:\n :param results_list:\n :return:\n '
if ((type(metric) is list) or (type(metric) is tuple)):
m... |
def strictly_increasing(l):
'\n 判断是否严格单调增\n :param l:\n :return:\n \n Test if monotonically increasing\n :param l:\n :return:\n '
return all(((x < y) for (x, y) in zip(l, l[1:])))
|
def strictly_decreasing(l):
'\n 判断是否严格单调减\n :param l:\n :return:\n \n Test if monotonically decreasing\n :param l:\n :return:\n '
return all(((x > y) for (x, y) in zip(l, l[1:])))
|
def non_increasing(l):
'\n 判断是否单调非增\n :param l:\n :return:\n \n Test if monotonically non-increasing\n :param l:\n :return:\n '
return all(((x >= y) for (x, y) in zip(l, l[1:])))
|
def non_decreasing(l):
'\n 判断是否单调非减\n :param l:\n :return:\n \n Test if monotonically non-decreasing\n :param l:\n :return:\n '
return all(((x <= y) for (x, y) in zip(l, l[1:])))
|
def monotonic(l):
'\n 判断是否单调\n :param l:\n :return:\n \n Test if monotonic\n :param l:\n :return:\n '
return (non_increasing(l) or non_decreasing(l))
|
def numpy_to_torch(d, gpu=True, requires_grad=True):
'\n numpy array转化为pytorch tensor，有gpu则放到gpu\n :param d:\n :param gpu: whether put tensor to gpu\n :param requires_grad: whether the tensor requires grad\n :return:\n \n Convert numpy array to pytorch tensor, if there is gpu then put into gp... |
def tensor_to_gpu(t):
if (torch.cuda.device_count() > 0):
t = t.cuda()
return t
|
def get_init_paras_dict(class_name, paras_dict):
base_list = inspect.getmro(class_name)
paras_list = []
for base in base_list:
paras = inspect.getfullargspec(base.__init__)
paras_list.extend(paras.args)
paras_list = sorted(list(set(paras_list)))
out_dict = {}
for para in paras_... |
def check_dir_and_mkdir(path):
if ((os.path.basename(path).find('.') == (- 1)) or path.endswith('/')):
dirname = path
else:
dirname = os.path.dirname(path)
if (not os.path.exists(dirname)):
print('make dirs:', dirname)
os.makedirs(dirname)
return
|
def main():
'\n Main entry.\n '
print(('pid %i: Hello' % os.getpid()))
print('Python version:', sys.version)
print('Env:')
for (key, value) in sorted(os.environ.items()):
print(('%s=%s' % (key, value)))
print()
if os.environ.get('PE_HOSTFILE', ''):
try:
pr... |
def iterate_dataset(dataset, recurrent_net, batch_size, max_seqs):
'\n :type dataset: Dataset.Dataset\n :type recurrent_net: bool\n :type batch_size: int\n :type max_seqs: int\n '
batch_gen = dataset.generate_batches(recurrent_net=recurrent_net, batch_size=batch_size, max_seqs=max_seqs)
whi... |
def iterate_epochs():
'\n Iterate through epochs.\n '
start_epoch = 1
final_epoch = EngineBase.config_get_final_epoch(config)
print(('Starting with epoch %i.' % (start_epoch,)), file=log.v3)
print(('Final epoch is: %i' % final_epoch), file=log.v3)
recurrent_net = ('lstm' in config.value(... |
def init(config_filename, command_line_options):
'\n :param str config_filename:\n :param list[str] command_line_options:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
rnn.init_config(config_filename, command_line_options)
global config
config = rnn.config
rnn.init_log... |
def main(argv):
'\n Main entry.\n '
assert (len(argv) >= 2), ('usage: %s <config>' % argv[0])
init(config_filename=argv[1], command_line_options=argv[2:])
iterate_epochs()
rnn.finalize()
|
def dump_devs(tf_session_opts, use_device_lib=False, filter_gpu=True):
'\n :param dict[str] tf_session_opts:\n :param bool use_device_lib:\n :param bool filter_gpu:\n '
s = os.environ.get('CUDA_VISIBLE_DEVICES', None)
cuda_num_visible = None
if (s is not None):
cuda_num_visible = l... |
def main():
'\n Main entry.\n '
arg_parser = ArgumentParser()
arg_parser.add_argument('--try_subsets', action='store_true')
arg_parser.add_argument('--visible_device_list')
arg_parser.add_argument('--use_device_lib', action='store_true')
args = arg_parser.parse_args()
orig_cuda_visib... |
def get_curl_cmd():
'\n :rtype: list[str]\n '
return ['curl', '-F', ('file=@%s' % fn), args.http_host]
|
def _get_dataset_opts(name: str):
opts = {'class': 'TaskNumberBaseConvertDataset', 'input_base': data_feature_dim.dimension, 'output_base': targets_dim.dimension}
if (name == 'train'):
opts['num_seqs'] = 10000
else:
opts['num_seqs'] = 1000
opts['fixed_random_seed'] = sum(map(ord, n... |
def get_model(**_kwargs):
'get model, RETURNN config callback'
return Model(in_dim=data_feature_dim, encoder_in_dim=encoder_in_dim, num_enc_layers=12, enc_model_dim=Dim(name='enc', dimension=512, kind=Dim.Types.Feature), enc_ff_dim=Dim(name='enc-ff', dimension=2048, kind=Dim.Types.Feature), enc_att_num_heads=... |
class Model(rf.Module):
'Model definition'
def __init__(self, in_dim: Dim, encoder_in_dim: Dim, *, num_enc_layers: int=12, target_dim: Dim, eos_idx: int, bos_idx: int, enc_model_dim: Dim=Dim(name='enc', dimension=512), enc_ff_dim: Dim=Dim(name='enc-ff', dimension=2048), enc_att_num_heads: int=4, enc_conforme... |
def train_step(*, model: Model, extern_data: TensorDict, **_kwargs):
'Function is run within RETURNN.'
data = extern_data[extern_data_inputs_name]
targets = extern_data[extern_data_targets_name]
(enc_args, enc_spatial_dim) = model.encode(data, in_spatial_dim=data_spatial_dim)
batch_dims = data.rem... |
def forward_step(*, model: Model, extern_data: TensorDict, **_kwargs) -> Tuple[(Tensor, Tensor, Dim, Dim)]:
'\n Function is run within RETURNN.\n\n Earlier we used the generic beam_search function,\n but now we just directly perform the search here,\n as this is overall simpler and shorter.\n\n :re... |
def main():
'main'
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--bench-action', choices=('run', 'multi-run', 'profile'), default='run')
(args, remaining_args) = arg_parser.parse_known_args()
try:
multiprocessing.set_start_method('spawn')
except Exception as exc:
... |
def _custom_loop(argv):
from returnn.log import log
from returnn.util.basic import hms
from returnn.datasets import init_dataset
from returnn.torch.data import pipeline as data_pipeline
from returnn.torch.data import returnn_dataset_wrapper
from returnn.torch.data import extern_data as extern_... |
def _subproc_check_call(*args):
print('$', *args)
subprocess.check_call(args)
|
def _subproc_check_call_filter_returnn_out(*args):
print('$', *args)
line_count = 0
need_newline = False
with subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as p:
while True:
line = p.stdout.readline()
if (not line):
break
... |
def main():
'\n Main entry.\n '
tmp_dir = tempfile.mkdtemp()
os.symlink(('%s/returnn' % _base_dir), ('%s/returnn' % tmp_dir))
config_fn = ('%s/returnn.config' % tmp_dir)
with open(config_fn, 'w') as f:
f.write('#!rnn.py\n')
f.write('use_tensorflow = True\n')
f.write('... |
def make_config_dict(lstm_unit, use_gpu):
'\n :param str lstm_unit: "NativeLSTM", "LSTMBlock", "LSTMBlockFused", "CudnnLSTM", etc, one of LstmCellTypes\n :param bool use_gpu:\n :return: config dict\n :rtype: dict[str]\n '
num_layers = base_settings['num_layers']
network = {}
for i in ra... |
def benchmark(lstm_unit, use_gpu):
'\n :param str lstm_unit: e.g. "LSTMBlock", one of LstmCellTypes\n :param bool use_gpu:\n :return: runtime in seconds of the training itself, excluding initialization\n :rtype: float\n '
device = {True: 'GPU', False: 'CPU'}[use_gpu]
key = ('%s:%s' % (devic... |
def main():
'\n Main entry.\n '
global LstmCellTypes
print('Benchmarking LSTMs.')
better_exchook.install()
print('Args:', ' '.join(sys.argv))
arg_parser = ArgumentParser()
arg_parser.add_argument('cfg', nargs='*', help=('opt=value, opt in %r' % sorted(base_settings.keys())))
arg_... |
class Hyp():
'\n Represents a hypothesis in a given decoder step, including the label sequence so far.\n '
def __init__(self, idx):
'\n :param int idx: hyp idx (to identify it in a beam)\n '
self.idx = idx
self.source_idx = None
self.score = 0.0
sel... |
def main():
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--graph', help='compiled TF graph', required=True)
arg_parser.add_argument('--chkpt', help='TF checkpoint (model params)', required=True)
arg_parser.add_argument('--beam_size', type=int, default=1... |
def mkdir_p(path):
try:
os.makedirs(path)
except OSError as exc:
if ((exc.errno == errno.EEXIST) and os.path.isdir(path)):
pass
else:
raise
|
def hdf5_strings(handle, name, data):
try:
S = max([len(d) for d in data])
dset = handle.create_dataset(name, (len(data),), dtype=('S' + str(S)))
dset[...] = data
except Exception:
dt = h5py.special_dtype(vlen=str)
del handle[name]
dset = handle.create_dataset(n... |
def load_char_list(char_list_path):
charlist = []
with open(char_list_path) as f:
for l in f:
charlist.append(l.strip())
return charlist
|
def load_file_list_and_transcriptions_and_sizes_and_n_labels(file_list_path, char_list_path, pad_whitespace, base_path):
charlist = load_char_list(char_list_path)
file_list = []
transcription_list = []
size_list = []
with open(file_list_path) as f:
for l in f:
if l.startswith('... |
def write_to_hdf(file_list, transcription_list, charlist, n_labels, out_file_name, dataset_prefix, pad_y=15, pad_x=15, compress=True):
with h5py.File(out_file_name, 'w') as f:
f.attrs['inputPattSize'] = 1
f.attrs['numDims'] = 1
f.attrs['numSeqs'] = len(file_list)
classes = charlist... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.