code stringlengths 17 6.64M |
|---|
def set_next_API_ID():
global API_ID
lock.acquire()
API_ID = ((API_ID + 1) % len(API_name_key_list))
openai.api_base = 'https://{0}.openai.azure.com/'.format(API_name_key_list[API_ID][0])
openai.api_key = API_name_key_list[API_ID][1]
lock.release()
|
def multi_threading_running(func, queries, n=20, multiple_API=True):
def wrapped_function(query, max_try=20):
if multiple_API:
set_next_API_ID()
try:
result = func(query)
return result
except (openai.error.RateLimitError, openai.error.APIError) as e:
... |
def query_azure_openai_chat(query, engine='gpt-35-turbo'):
global default_engine, cache
query_string = json.dumps(query)
if (query_string in cache):
return cache[query_string]
if (default_engine is not None):
engine = default_engine
if (engine == 'chatgpt'):
engine = 'gpt-3... |
def query_azure_openai_complete(query, engine='gpt-35-turbo'):
if (engine == 'chatgpt'):
engine = 'gpt-35-turbo'
try:
response = openai.Completion.create(engine=engine, prompt=query, max_tokens=2000, temperature=0, stop=['<END>'])
except TypeError as e:
print(e)
return {'ch... |
def test_speed_1():
import json
path = 'khan/topic_19.jsonal'
questions = []
timer = Timer()
with open(path) as reader:
for (i, line) in enumerate(reader):
js = json.loads(line.strip())
question = js['Question']
questions.append(question)
questions =... |
def test_speed_2():
import json
path = 'D:\\Datasets\\AGIEval\\outputs\\model_output\\english_choice\\sat_math\\turbo_few\\test_sat_math_gpt-35-turbo_cot_False_few.jsonl'
with open(path, encoding='utf8') as reader:
questions = []
for line in reader:
js = json.loads(line.strip()... |
def query_openai(context_list, setting_name, n_multiply=3):
n = (len(openai_api.API_name_key_list) * n_multiply)
try:
print('multi-thread n =', n)
if (setting_name == 'complete'):
results = openai_api.multi_threading_running(openai_api.query_azure_openai_complete, context_list, n=n... |
def query_openai_with_retry(context_list, setting_name, retry_time=4, results=None):
if (results is None):
results = query_openai(context_list, setting_name)
while (retry_time > 0):
filtered_context_list = []
for i in range(len(results)):
if (utils.extract_answer(results[i]... |
def run_multiple_dataset_batch(work_items):
if (len(work_items) == 0):
return
print('work items:', work_items)
dataset_list = []
item_list = []
for (input_path, output_path, mode, _) in work_items:
assert (mode == work_items[0][2])
js_list = utils.read_jsonl(input_path)
... |
def run_multiple_dataset(work_items):
batch = []
count = 0
batch_size = 1000
if (openai_api.default_engine == 'gpt-4'):
batch_size = 500
for item in work_items:
if os.path.exists(item[1]):
if (len(utils.read_jsonl(item[1])) == item[3]):
continue
... |
class TaskSchema(object):
def __init__(self, passage=None, question=None, options=None, label=None, answer=None, other=None):
self.passage = passage
self.question = question
self.options = options
self.label = label
self.answer = answer
self.other = other
def ... |
class AgiInstance(object):
def __init__(self, task_description, data_source, task_schema, output, evaluation_metric, task_example):
self.task_description = task_description
self.data_source = data_source
self.task_schema = task_schema
self.output = output
self.evaluation_m... |
class ChatGPTSchema(object):
def __init__(self, context=None, metadata=''):
self.context = context
self.metadata = metadata
def to_dict(self):
return {'context': self.context, 'metadata': self.metadata}
|
class ResultsForHumanSchema(object):
def __init__(self, index, problem_input, label, model_input='', model_output='', parse_result='', first_stage_output='', second_stage_input='', is_correct=False):
self.index = index
self.problem_input = problem_input
self.model_input = model_input
... |
def convert_zero_shot(line, dataset_name):
try:
passage = (line['passage'] if (line['passage'] is not None) else '')
if (dataset_name in english_qa_datasets):
option_string = 'ABCDEFG'
count = len(line['options'])
if (count == 1):
count = 5
... |
def convert_zero_shot_CoT_stage1(line, dataset_name):
try:
passage = (line['passage'] if (line['passage'] is not None) else '')
if (dataset_name in english_qa_datasets):
return (((((((passage + 'Q: ') + line['question']) + ' ') + 'Answer Choices: ') + ' '.join(line['options'])) + '\n')... |
def combine_prompt(prompt_path, dataset_name, load_explanation=True, chat_mode=False):
skip_passage = False
if (dataset_name == 'sat-en-without-passage'):
skip_passage = True
dataset_name = 'sat-en'
demostrations = []
context_row = [0, 1, 3, 5, 7, 9]
explanation_row = [0, 2, 4, 6, ... |
def concat_prompt(demos, dataset_name, max_tokens, end_of_example='\n', verbose=False):
demostration_en = 'Here are the answers for the problems in the exam.\n'
demostration_zh = '以下是考试中各个问题的答案。\n'
for i in range(len(demos)):
if (dataset_name in english_qa_datasets):
demostration_en = ... |
def concat_prompt_chat_mode(demos, dataset_name, max_tokens, end_of_example='\n', verbose=False):
answers = []
sentences = ''
for i in range(len(demos)):
answers += [{'role': 'user', 'content': demos[i][0]}, {'role': 'assistant', 'content': demos[i][1]}]
sentences += json.dumps(answers[(- ... |
def convert_few_shot(line, dataset_name, demo, n_shot, chat_mode=False):
passage = (line['passage'] if (line['passage'] is not None) else '')
question = line['question']
options = (line['options'] if (line['options'] is not None) else '')
if (dataset_name in english_qa_datasets):
question_inpu... |
def load_dataset(dataset_name, setting_name, parent_path, prompt_path=None, max_tokens=None, end_of_example='\n', chat_mode=False, verbose=False):
test_path = os.path.join(parent_path, (dataset_name + '.jsonl'))
loaded_jsonl = read_jsonl(test_path)
processed = []
if ((setting_name == 'few-shot-CoT') o... |
def generate_second_stage_input(dataset_name, input_list, output_list, with_format_prompt=False):
try:
english_format_prompt = 'Based on the previous results, your task is to extract the final answer and provide the output enclosed in brackets【】, such as 【0】 or 【A】.'
chinese_format_prompt = '根据以上内... |
def load_dataset_as_result_schema(dataset_name, parent_path):
test_path = os.path.join(parent_path, (dataset_name + '.jsonl'))
loaded_jsonl = read_jsonl(test_path)
processed = []
for (i, line) in enumerate(loaded_jsonl):
problem_input = convert_zero_shot(line, dataset_name)
processed.a... |
def convert_to_set(item):
if isinstance(item, list):
return set(item)
if isinstance(item, str):
return {item}
if (item is None):
return {}
raise ValueError("Input can't parse:", item)
|
def evaluate_single_sample(dataset_name, prediction, label):
if (dataset_name in dataset_loader.multi_choice_datasets):
p = convert_to_set(prediction)
l = convert_to_set(label)
return (p == l)
elif (dataset_name in dataset_loader.math_output_datasets):
return is_equiv(predictio... |
def _fix_fracs(string):
substrs = string.split('\\frac')
new_str = substrs[0]
if (len(substrs) > 1):
substrs = substrs[1:]
for substr in substrs:
new_str += '\\frac'
if (substr[0] == '{'):
new_str += substr
else:
try:
... |
def _fix_a_slash_b(string):
if (len(string.split('/')) != 2):
return string
a = string.split('/')[0]
b = string.split('/')[1]
try:
a = int(a)
b = int(b)
assert (string == '{}/{}'.format(a, b))
new_string = (((('\\frac{' + str(a)) + '}{') + str(b)) + '}')
... |
def _remove_right_units(string):
if ('\\text{ ' in string):
splits = string.split('\\text{ ')
assert (len(splits) == 2)
return splits[0]
else:
return string
|
def _fix_sqrt(string):
if ('\\sqrt' not in string):
return string
splits = string.split('\\sqrt')
new_string = splits[0]
for split in splits[1:]:
if (split[0] != '{'):
a = split[0]
new_substr = ((('\\sqrt{' + a) + '}') + split[1:])
else:
new_... |
def _strip_string(string):
string = string.replace('\n', '')
string = string.replace('\\!', '')
string = string.replace('\\\\', '\\')
string = string.replace('tfrac', 'frac')
string = string.replace('dfrac', 'frac')
string = string.replace('\\left', '')
string = string.replace('\\right', '... |
def is_equiv(str1, str2, verbose=False):
if ((str1 is None) and (str2 is None)):
print('WARNING: Both None')
return True
if ((str1 is None) or (str2 is None)):
return False
try:
ss1 = _strip_string(str1)
ss2 = _strip_string(str2)
if verbose:
prin... |
def extract_last_line(string):
lines = string.split('\n')
for item in lines[::(- 1)]:
if (item.strip() != ''):
string = item
break
return string
|
def remove_few_shot_prefix(string: str):
prefix_list = ['The answer is therefore', '答案是']
for prefix in prefix_list:
if string.startswith(prefix):
string = string[len(prefix):].strip()
elif (prefix in string):
index = string.rfind(prefix)
if (index >= 0):
... |
def try_parse_few_shot_qa_single_answer(string, setting_name, language='en'):
if (setting_name == 'few-shot-CoT'):
string = extract_last_line(string)
if (language == 'en'):
pattern = 'answer is .*?([A-G])'
match = re.search(pattern, string)
elif (language == 'zh'):
pattern ... |
def try_parse_few_shot_pattern(string: str, dataset_name, setting_name):
if (setting_name == 'few-shot-CoT'):
string = extract_last_line(string)
if (dataset_name in dataset_loader.chinese_cloze_datasets):
return string.startswith('答案是')
elif (dataset_name in dataset_loader.english_cloze_da... |
def parse_few_shot_qa_single_answer(string, setting_name, language='en'):
answer = try_parse_few_shot_qa_single_answer(string, setting_name, language)
if (answer is None):
return find_first_capital_letter(string)
else:
return answer
|
def find_first_capital_letter(answer):
letter_set = {'A', 'B', 'C', 'D', 'E', 'F'}
for c in answer:
if (c in letter_set):
return c
return ''
|
def extract_answer_in_bracket(answer, prefix='【', suffix='】'):
if ((prefix not in answer) and (suffix not in answer)):
return ''
s = (answer.index(prefix) + len(prefix))
t = answer.index(suffix)
ret = answer[s:t]
return ret
|
def parse_math_answer(setting_name, raw_string):
if (setting_name == 'few-shot-CoT'):
raw_string = extract_last_line(raw_string)
if ((setting_name == 'few-shot-CoT') or (setting_name == 'few-shot')):
raw_string = remove_few_shot_prefix(raw_string)
return raw_string
def remove_boxe... |
def parse_qa_multiple_answer(string, setting_name):
if (setting_name == 'few-shot-CoT'):
string = extract_last_line(string)
pattern = '\\(*([A-F])\\)*'
match = re.findall(pattern, string)
if match:
return match
return []
|
def post_process(dataset_name, setting_name, prediction):
if ((dataset_name in dataset_loader.english_cloze_datasets) or (dataset_name in dataset_loader.chinese_cloze_datasets)):
return parse_math_answer(setting_name, prediction)
if (dataset_name in ['jec-qa-kd', 'jec-qa-ca', 'gaokao-physics']):
... |
def read_jsonl(path):
with open(path, encoding='utf8') as fh:
results = []
for line in fh:
if (line is None):
continue
try:
results.append((json.loads(line) if (line != 'null') else line))
except Exception as e:
pr... |
def save_jsonl(lines, directory):
with open(directory, 'w', encoding='utf8') as f:
for line in lines:
f.write((json.dumps(line, ensure_ascii=False) + '\n'))
|
def extract_answer(js):
try:
if ((js is None) or (js == 'null')):
return ''
answer = ''
if isinstance(js, str):
answer = js
elif ('text' in js['choices'][0]):
answer = js['choices'][0]['text']
else:
answer = js['choices'][0]['... |
def read_json_dirs(path):
fnames_list = []
for (subdir, dirs, files) in os.walk(path):
for file in files:
fnames_list.append(os.path.join(subdir, file))
return fnames_list
|
def read_jsonl(path):
with open(path) as fh:
return [json.loads(line) for line in fh.readlines() if line]
|
def save_jsonl(lines, directory):
with open(directory, 'w') as f:
for line in lines:
f.write('{}\n'.format(json.dumps(line)))
|
def lsat_preprosess(args):
def _preprocess_file(input_dir, output_dir):
def parse_unicode(s):
return s.encode('utf-8').decode('utf-8')
def format_lsat(raw):
cleaned = []
for r in raw[0]:
option_string = 'ABCDEFGH'
option_list =... |
def boolean_string(s):
if (s not in {'False', 'True'}):
raise ValueError('Not a valid boolean string')
return (s == 'True')
|
def main(_):
if FLAGS.gpu:
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu
tf.set_random_seed(1234)
np.random.seed(0)
model = GridCell(FLAGS)
output_dir = os.path.join('output', os.path.splitext(os.path.basename(__file__))[0], datetime.... |
def cg(f_Ax, b, cg_iters=10, callback=None, verbose=False, residual_tol=1e-10):
'\n Demmel p 312\n '
p = b.copy()
r = b.copy()
x = np.zeros_like(b)
rdotr = r.dot(r)
fmtstr = '%10i %10.3g %10.3g'
titlestr = '%10s %10s %10s'
if verbose:
print((titlestr % ('iter', 'residual ... |
def make_atari_env(env_id, num_env, seed, wrapper_kwargs=None, start_index=0):
'\n Create a wrapped, monitored SubprocVecEnv for Atari.\n '
if (wrapper_kwargs is None):
wrapper_kwargs = {}
def make_env(rank):
def _thunk():
env = make_atari(env_id)
env.seed((... |
def make_mujoco_env(env_id, seed):
'\n Create a wrapped, monitored gym.Env for MuJoCo.\n '
set_global_seeds(seed)
env = gym.make(env_id)
env = Monitor(env, logger.get_dir())
env.seed(seed)
return env
|
def make_robotics_env(env_id, seed, rank=0):
'\n Create a wrapped, monitored gym.Env for MuJoCo.\n '
set_global_seeds(seed)
env = gym.make(env_id)
env = FlattenDictWrapper(env, ['observation', 'desired_goal'])
env = Monitor(env, (logger.get_dir() and os.path.join(logger.get_dir(), str(rank))... |
def arg_parser():
'\n Create an empty argparse.ArgumentParser.\n '
import argparse
return argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
|
def atari_arg_parser():
'\n Create an argparse.ArgumentParser for run_atari.py.\n '
parser = arg_parser()
parser.add_argument('--env', help='environment ID', default='BreakoutNoFrameskip-v4')
parser.add_argument('--seed', help='RNG seed', type=int, default=0)
parser.add_argument('--num-times... |
def mujoco_arg_parser():
'\n Create an argparse.ArgumentParser for run_mujoco.py.\n '
parser = arg_parser()
parser.add_argument('--env', help='environment ID', type=str, default='Reacher-v2')
parser.add_argument('--seed', help='RNG seed', type=int, default=0)
parser.add_argument('--num-times... |
def robotics_arg_parser():
'\n Create an argparse.ArgumentParser for run_mujoco.py.\n '
parser = arg_parser()
parser.add_argument('--env', help='environment ID', type=str, default='FetchReach-v0')
parser.add_argument('--seed', help='RNG seed', type=int, default=0)
parser.add_argument('--num-... |
def fmt_row(width, row, header=False):
out = ' | '.join((fmt_item(x, width) for x in row))
if header:
out = ((out + '\n') + ('-' * len(out)))
return out
|
def fmt_item(x, l):
if isinstance(x, np.ndarray):
assert (x.ndim == 0)
x = x.item()
if isinstance(x, (float, np.float32, np.float64)):
v = abs(x)
if (((v < 0.0001) or (v > 10000.0)) and (v > 0)):
rep = ('%7.2e' % x)
else:
rep = ('%7.5f' % x)
... |
def colorize(string, color, bold=False, highlight=False):
attr = []
num = color2num[color]
if highlight:
num += 10
attr.append(str(num))
if bold:
attr.append('1')
return ('\x1b[%sm%s\x1b[0m' % (';'.join(attr), string))
|
@contextmanager
def timed(msg):
global MESSAGE_DEPTH
print(colorize(((('\t' * MESSAGE_DEPTH) + '=: ') + msg), color='magenta'))
tstart = time.time()
MESSAGE_DEPTH += 1
(yield)
MESSAGE_DEPTH -= 1
print(colorize((('\t' * MESSAGE_DEPTH) + ('done in %.3f seconds' % (time.time() - tstart))), co... |
class Dataset(object):
def __init__(self, data_map, deterministic=False, shuffle=True):
self.data_map = data_map
self.deterministic = deterministic
self.enable_shuffle = shuffle
self.n = next(iter(data_map.values())).shape[0]
self._next_id = 0
self.shuffle()
d... |
def iterbatches(arrays, *, num_batches=None, batch_size=None, shuffle=True, include_final_partial_batch=True):
assert ((num_batches is None) != (batch_size is None)), 'Provide num_batches or batch_size, but not both'
arrays = tuple(map(np.asarray, arrays))
n = arrays[0].shape[0]
assert all(((a.shape[0... |
class Filter(object):
def __call__(self, x, update=True):
raise NotImplementedError
def reset(self):
pass
|
class IdentityFilter(Filter):
def __call__(self, x, update=True):
return x
|
class CompositionFilter(Filter):
def __init__(self, fs):
self.fs = fs
def __call__(self, x, update=True):
for f in self.fs:
x = f(x)
return x
def output_shape(self, input_space):
out = input_space.shape
for f in self.fs:
out = f.output_sha... |
class ZFilter(Filter):
'\n y = (x-mean)/std\n using running estimates of mean,std\n '
def __init__(self, shape, demean=True, destd=True, clip=10.0):
self.demean = demean
self.destd = destd
self.clip = clip
self.rs = RunningStat(shape)
def __call__(self, x, update... |
class AddClock(Filter):
def __init__(self):
self.count = 0
def reset(self):
self.count = 0
def __call__(self, x, update=True):
return np.append(x, (self.count / 100.0))
def output_shape(self, input_space):
return ((input_space.shape[0] + 1),)
|
class FlattenFilter(Filter):
def __call__(self, x, update=True):
return x.ravel()
def output_shape(self, input_space):
return (int(np.prod(input_space.shape)),)
|
class Ind2OneHotFilter(Filter):
def __init__(self, n):
self.n = n
def __call__(self, x, update=True):
out = np.zeros(self.n)
out[x] = 1
return out
def output_shape(self, input_space):
return (input_space.n,)
|
class DivFilter(Filter):
def __init__(self, divisor):
self.divisor = divisor
def __call__(self, x, update=True):
return (x / self.divisor)
def output_shape(self, input_space):
return input_space.shape
|
class StackFilter(Filter):
def __init__(self, length):
self.stack = deque(maxlen=length)
def reset(self):
self.stack.clear()
def __call__(self, x, update=True):
self.stack.append(x)
while (len(self.stack) < self.stack.maxlen):
self.stack.append(x)
ret... |
def discount(x, gamma):
'\n computes discounted sums along 0th dimension of x.\n\n inputs\n ------\n x: ndarray\n gamma: float\n\n outputs\n -------\n y: ndarray with same shape as x, satisfying\n\n y[t] = x[t] + gamma*x[t+1] + gamma^2*x[t+2] + ... + gamma^k x[t+k],\n ... |
def explained_variance(ypred, y):
'\n Computes fraction of variance that ypred explains about y.\n Returns 1 - Var[y-ypred] / Var[y]\n\n interpretation:\n ev=0 => might as well have predicted zero\n ev=1 => perfect prediction\n ev<0 => worse than just predicting zero\n\n '
... |
def explained_variance_2d(ypred, y):
assert ((y.ndim == 2) and (ypred.ndim == 2))
vary = np.var(y, axis=0)
out = (1 - (np.var((y - ypred)) / vary))
out[(vary < 1e-10)] = 0
return out
|
def ncc(ypred, y):
return np.corrcoef(ypred, y)[(1, 0)]
|
def flatten_arrays(arrs):
return np.concatenate([arr.flat for arr in arrs])
|
def unflatten_vector(vec, shapes):
i = 0
arrs = []
for shape in shapes:
size = np.prod(shape)
arr = vec[i:(i + size)].reshape(shape)
arrs.append(arr)
i += size
return arrs
|
def discount_with_boundaries(X, New, gamma):
'\n X: 2d array of floats, time x features\n New: 2d array of bools, indicating when a new episode has started\n '
Y = np.zeros_like(X)
T = X.shape[0]
Y[(T - 1)] = X[(T - 1)]
for t in range((T - 2), (- 1), (- 1)):
Y[t] = (X[t] + ((gamma... |
def test_discount_with_boundaries():
gamma = 0.9
x = np.array([1.0, 2.0, 3.0, 4.0], 'float32')
starts = [1.0, 0.0, 0.0, 1.0]
y = discount_with_boundaries(x, starts, gamma)
assert np.allclose(y, [((1 + (gamma * 2)) + ((gamma ** 2) * 3)), (2 + (gamma * 3)), 3, 4])
|
def zipsame(*seqs):
L = len(seqs[0])
assert all(((len(seq) == L) for seq in seqs[1:]))
return zip(*seqs)
|
def unpack(seq, sizes):
"\n Unpack 'seq' into a sequence of lists, with lengths specified by 'sizes'.\n None = just one bare element, not a list\n\n Example:\n unpack([1,2,3,4,5,6], [3,None,2]) -> ([1,2,3], 4, [5,6])\n "
seq = list(seq)
it = iter(seq)
assert (sum(((1 if (s is None) else... |
class EzPickle(object):
'Objects that are pickled and unpickled via their constructor\n arguments.\n\n Example usage:\n\n class Dog(Animal, EzPickle):\n def __init__(self, furcolor, tailkind="bushy"):\n Animal.__init__()\n EzPickle.__init__(furcolor, tailkind)... |
def set_global_seeds(i):
try:
import tensorflow as tf
except ImportError:
pass
else:
tf.set_random_seed(i)
np.random.seed(i)
random.seed(i)
|
def pretty_eta(seconds_left):
'Print the number of seconds in human readable format.\n\n Examples:\n 2 days\n 2 hours and 37 minutes\n less than a minute\n\n Paramters\n ---------\n seconds_left: int\n Number of seconds to be converted to the ETA\n Returns\n -------\n eta: str... |
class RunningAvg(object):
def __init__(self, gamma, init_value=None):
'Keep a running estimate of a quantity. This is a bit like mean\n but more sensitive to recent changes.\n\n Parameters\n ----------\n gamma: float\n Must be between 0 and 1, where 0 is the most se... |
def boolean_flag(parser, name, default=False, help=None):
'Add a boolean flag to argparse parser.\n\n Parameters\n ----------\n parser: argparse.Parser\n parser to add the flag to\n name: str\n --<name> will enable the flag, while --no-<name> will disable it\n default: bool or None\n ... |
def get_wrapper_by_name(env, classname):
'Given an a gym environment possibly wrapped multiple times, returns a wrapper\n of class named classname or raises ValueError if no such wrapper was applied\n\n Parameters\n ----------\n env: gym.Env of gym.Wrapper\n gym environment\n classname: str\... |
def relatively_safe_pickle_dump(obj, path, compression=False):
"This is just like regular pickle dump, except from the fact that failure cases are\n different:\n\n - It's never possible that we end up with a pickle in corrupted state.\n - If a there was a different file at the path, that file wil... |
def pickle_load(path, compression=False):
'Unpickle a possible compressed pickle.\n\n Parameters\n ----------\n path: str\n path to the output file\n compression: bool\n if true assumes that pickle was compressed when created and attempts decompression.\n\n Returns\n -------\n o... |
class MpiAdam(object):
def __init__(self, var_list, *, beta1=0.9, beta2=0.999, epsilon=1e-08, scale_grad_by_procs=True, comm=None):
self.var_list = var_list
self.beta1 = beta1
self.beta2 = beta2
self.epsilon = epsilon
self.scale_grad_by_procs = scale_grad_by_procs
... |
@U.in_session
def test_MpiAdam():
np.random.seed(0)
tf.set_random_seed(0)
a = tf.Variable(np.random.randn(3).astype('float32'))
b = tf.Variable(np.random.randn(2, 5).astype('float32'))
loss = (tf.reduce_sum(tf.square(a)) + tf.reduce_sum(tf.sin(b)))
stepsize = 0.01
update_op = tf.train.Adam... |
def mpi_fork(n, bind_to_core=False):
'Re-launches the current script with workers\n Returns "parent" for original parent, "child" for MPI children\n '
if (n <= 1):
return 'child'
if (os.getenv('IN_MPI') is None):
env = os.environ.copy()
env.update(MKL_NUM_THREADS='1', OMP_NUM... |
def mpi_mean(x, axis=0, comm=None, keepdims=False):
x = np.asarray(x)
assert (x.ndim > 0)
if (comm is None):
comm = MPI.COMM_WORLD
xsum = x.sum(axis=axis, keepdims=keepdims)
n = xsum.size
localsum = np.zeros((n + 1), x.dtype)
localsum[:n] = xsum.ravel()
localsum[n] = x.shape[ax... |
def mpi_moments(x, axis=0, comm=None, keepdims=False):
x = np.asarray(x)
assert (x.ndim > 0)
(mean, count) = mpi_mean(x, axis=axis, comm=comm, keepdims=True)
sqdiffs = np.square((x - mean))
(meansqdiff, count1) = mpi_mean(sqdiffs, axis=axis, comm=comm, keepdims=True)
assert (count1 == count)
... |
def test_runningmeanstd():
import subprocess
subprocess.check_call(['mpirun', '-np', '3', 'python', '-c', 'from baselines.common.mpi_moments import _helper_runningmeanstd; _helper_runningmeanstd()'])
|
def _helper_runningmeanstd():
comm = MPI.COMM_WORLD
np.random.seed(0)
for (triple, axis) in [((np.random.randn(3), np.random.randn(4), np.random.randn(5)), 0), ((np.random.randn(3, 2), np.random.randn(4, 2), np.random.randn(5, 2)), 0), ((np.random.randn(2, 3), np.random.randn(2, 4), np.random.randn(2, 4))... |
class RunningMeanStd(object):
def __init__(self, epsilon=0.01, shape=()):
self._sum = tf.get_variable(dtype=tf.float64, shape=shape, initializer=tf.constant_initializer(0.0), name='runningsum', trainable=False)
self._sumsq = tf.get_variable(dtype=tf.float64, shape=shape, initializer=tf.constant_i... |
@U.in_session
def test_runningmeanstd():
for (x1, x2, x3) in [(np.random.randn(3), np.random.randn(4), np.random.randn(5)), (np.random.randn(3, 2), np.random.randn(4, 2), np.random.randn(5, 2))]:
rms = RunningMeanStd(epsilon=0.0, shape=x1.shape[1:])
U.initialize()
x = np.concatenate([x1, x... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.