code stringlengths 101 5.91M |
|---|
def eval_expr(interpreter: Interpreter, in_values: List[Any], out_value: Any, expr: Expr):
return ExprVisitor(interpreter, in_values, out_value).visit(expr) |
class AudioVarianceScaling(Initializer):
def __init__(self, scale=1.0, mode='fan_in', distribution='truncated_normal', seed=None, dtype=tf.float32):
if (scale <= 0.0):
raise ValueError('`scale` must be positive float.')
if (mode not in {'fan_in', 'fan_out', 'fan_avg'}):
raise... |
def handle_propagation_add_coeff(weights, additional_coeffs, lower_bounds):
mus = []
final_lay_idx = len(weights)
if (final_lay_idx in additional_coeffs):
mu = (- additional_coeffs[final_lay_idx])
lay_idx = final_lay_idx
else:
add_coeff = next(iter(additional_coeffs.values()))
... |
class Rprop(Optimizer):
def __init__(self, params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50)):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 < etas[0] < 1.0 < etas[1])):
raise ValueError('Invalid eta values: {}, {}'.format(... |
class ConvLayer(My2DLayer):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1, groups=1, bias=False, has_shuffle=False, use_bn=True, act_func='relu', dropout_rate=0, ops_order='weight_bn_act'):
self.kernel_size = kernel_size
self.stride = stride
self.dilation ... |
def test_serialization_image_masker_inpaint_ns():
test_image_height = 500
test_image_width = 500
test_data = (np.ones((test_image_height, test_image_width, 3)) * 50)
test_shape = (test_image_height, test_image_width, 3)
original_image_masker = shap.maskers.Image('inpaint_ns', test_shape)
with te... |
class SubsetRandomSampler(Sampler[int]):
indices: Sequence[int]
def __init__(self, indices: Sequence[int], generator=None) -> None:
self.indices = indices
self.generator = generator
def __iter__(self):
return (self.indices[i] for i in torch.randperm(len(self.indices), generator=self.... |
def clean_up(text):
text = text.replace('<pad>', '')
text = text.replace('</s>', '')
text = text.replace('.', '')
text = text.replace(',', '')
text = text.replace("'", '')
text = text.replace('"', '')
return text |
def add_predictor(decoder):
p = DummyPredictor(vocab_size=20)
decoder.add_predictor('dummy', p) |
def get_emdedding_layer():
return Embedding(MAX_NUM_WORDS, EMBEDDING_DIM, weights=[embedding_matrix], input_length=MAX_SEQUENCE_LENGTH, trainable=False) |
def main():
args = arg_parser()
print('')
print(args)
print('')
print(f'API_KEY: {API_KEY}')
set_random_seed(args.random_seed)
dataloader = create_dataloader(args)
if (args.dataset_size > 1000):
dataloader = dataloader[:1000]
print(f'Dataloader size: {len(dataloader)}')
i... |
class HDict(MDict):
I = Inherit
def set_parent(self, parent):
self.__dict__['_parent'] = parent
return self
def get_parent(self):
return self.__dict__.get('_parent', None)
def __call__(self, parent):
return self.set_parent(parent)
def get_dict(self):
ret = sup... |
def replace_properties(node: Any, symrepl: Dict[(symbolic.symbol, symbolic.SymbolicType)], name: str, new_name: str):
replace_properties_dict(node, {name: new_name}, symrepl) |
def nullspace_GF(n=300, p=16411, system='sage'):
if (system == 'sage'):
A = random_matrix(GF(p), n, (n + 1))
t = cputime()
v = A.kernel()
return cputime(t)
elif (system == 'magma'):
code = ('\nn := %s;\nA := Random(RMatrixSpace(GF(%s), n, n+1));\nt := Cputime();\nK := Ker... |
class TestDynamicQuantizedLinear(TestCase):
_qengines
(batch_size=st.integers(1, 4), input_channels=st.integers(16, 32), output_channels=st.integers(4, 8), use_bias=st.booleans(), use_relu=st.booleans(), use_multi_dim_input=st.booleans(), use_channelwise=st.booleans(), reduce_range=st.booleans())
def test_q... |
def split_mixture_params(params, output_dim, num_mixes):
mus = params[:(num_mixes * output_dim)]
sigs = params[(num_mixes * output_dim):((2 * num_mixes) * output_dim)]
pi_logits = params[(- num_mixes):]
return (mus, sigs, pi_logits) |
class EpochBatchIterator(EpochBatchIterating):
def __init__(self, dataset, collate_fn, batch_sampler, seed=1, num_shards=1, shard_id=0, num_workers=0, epoch=0):
assert isinstance(dataset, torch.utils.data.Dataset)
self.dataset = dataset
self.collate_fn = collate_fn
self.frozen_batche... |
def pickle_complex_array_and_return_form(pickler_source, tmp_path):
with ProcessPoolExecutor(1, initializer=_init_process_with_pickler, initargs=(pickler_source, tmp_path), mp_context=multiprocessing.get_context('spawn')) as executor:
pickle_future = executor.submit(_pickle_complex_array_and_return_form_imp... |
class EmitConv2dInstance():
def __init__(self, operation_suffix=''):
self.operation_suffix = operation_suffix
self.includes = ['cutlass/cutlass.h', 'cutlass/conv/kernel/default_conv2d_fprop.h', 'cutlass/conv/kernel/default_conv2d_dgrad.h', 'cutlass/conv/kernel/default_conv2d_wgrad.h']
self.t... |
class FlaxAutoModelForNextSentencePrediction(_BaseAutoModelClass):
_model_mapping = FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING |
def set_seed(args):
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed) |
class GeneratedResidualCache():
def __init__(self) -> None:
self._dict: T.Dict[(_GRCKey, T.Callable)] = {}
def get_residual(self, index: SimilarityIndex, optimized_keys: T.Iterable[str], output_dir: T.Optional[T.Openable], namespace: T.Optional[str], sparse_linearization: bool) -> T.Optional[T.Callable]... |
def frechet_inception_distance():
filenames = glob(os.path.join('./real_target', '*.*'))
real_images = [get_images(filename) for filename in filenames]
real_images = np.transpose(real_images, axes=[0, 3, 1, 2])
filenames = glob(os.path.join('./fake', '*.*'))
fake_images = [get_images(filename) for f... |
def type_to_pack_format(typestring):
fmt = None
if (typestring == 'bool'):
fmt = 'B'
elif ((typestring == 'double') or (typestring == 'float')):
fmt = 'f'
elif (typestring == 'int64'):
fmt = 'i'
elif ((typestring == 'repeated int64') or (typestring == 'Shape')):
fmt =... |
def skip(splits, save_folder, conf):
skip = True
split_files = {'train': TRAIN_CSV, 'dev': DEV_CSV, 'test': TEST_CSV, 'enrol': ENROL_CSV}
for split in splits:
if (not os.path.isfile(os.path.join(save_folder, split_files[split]))):
skip = False
save_opt = os.path.join(save_folder, OPT... |
class OnlineCSB2Classifier(BaseSKMObject, ClassifierMixin, MetaEstimatorMixin):
def __init__(self, base_estimator=KNNADWINClassifier(), n_estimators=10, cost_positive=1, cost_negative=0.1, drift_detection=True, random_state=None):
super().__init__()
self.ensemble = None
self.actual_n_estimat... |
class BDD100KUniformWithPos(data.Dataset):
def __init__(self, mode, maxSkip=0, joint_transform_list=None, sliding_crop=None, transform=None, target_transform=None, target_aux_transform=None, dump_images=False, cv_split=None, class_uniform_pct=0.5, class_uniform_tile=1024, test=False, coarse_boost_classes=None, pos_... |
def generate_solver_python_interface(solver_info):
utils.generate_from_template(join(base, 'python/src/nnabla/solver.pyx.tmpl'), solver_info=solver_info)
utils.generate_from_template(join(base, 'python/src/nnabla/solver.pxd.tmpl'), solver_info=solver_info) |
def integrated_bn(fms, bn):
sizes = [p.shape[2:] for p in fms]
(n, c) = (fms[0].shape[0], fms[0].shape[1])
fm = torch.cat([p.view(n, c, 1, (- 1)) for p in fms], dim=(- 1))
fm = bn(fm)
fm = torch.split(fm, [(s[0] * s[1]) for s in sizes], dim=(- 1))
return [p.view(n, c, s[0], s[1]) for (p, s) in z... |
(scope='module')
.usefixtures('columns_target_list_len')
def simple_dataframe_target_ordered_list_len_pandas(columns_target_list_len):
data_target_ordered_list_len = [(1, 2, 19842, [1], [19841], 1), (1, 3, 19843, [1, 2], [19841, 19842], 2), (1, 4, 19844, [1, 2, 3], [19841, 19842, 19843], 3), (1, 5, 19845, [1, 2, 3,... |
class WSHandler(tornado.websocket.WebSocketHandler):
def __init__(self, application, request, **kwargs):
super(WSHandler, self).__init__(application, request, **kwargs)
self.sending = False
def open(self):
print(('New connection opened from ' + self.request.remote_ip))
clients.ap... |
class LifelongAntEnv(mujoco_env.MujocoEnv, utils.EzPickle):
def __init__(self, xml_file='ant.xml', gear_ratio=30, ctrl_cost_weight=0.01, contact_cost_weight=0.0005, healthy_reward=1.0, terminate_when_unhealthy=True, healthy_z_range=(0.2, 1.2), contact_force_range=((- 1.0), 1.0), reset_noise_scale=0.1, exclude_curre... |
def map_brackets_fw(t):
if (t == '('):
return '-lrb-'
if (t == ')'):
return '-rrb-'
return t |
class _Classifier(nn.Module):
def __init__(self, feat_dim=None, num_classes=None, dtype=None):
super().__init__()
self.weight = nn.Parameter(torch.empty(num_classes, feat_dim, dtype=dtype))
self.weight.data.uniform_((- 1), 1).renorm_(2, 0, 1e-05).mul_(100000.0)
def dtype(self):
r... |
def main():
parser = argparse.ArgumentParser(description='Convert keys in timm pretrained vit models to MMSegmentation style.')
parser.add_argument('src', help='src model path or url')
parser.add_argument('dst', help='save path')
parser.add_argument('model', help='model: pcpvt or svt')
args = parser... |
class Cell(VertexGroup):
def __init__(self, p_gen, p_hgr, origin, supremum):
super(Cell, self).__init__(p_gen, p_hgr)
self.origin = origin
self.supremum = supremum
self.centroid = None |
def gl_maker(file_name, min_weight, max_weight, vertices, min_edge, max_edge, sign, direct, self_loop, multigraph):
(edge_dic, weight_dic, edge_number) = edge_gen(vertices, min_weight, max_weight, min_edge, max_edge, sign, direct, self_loop, multigraph)
with open((file_name + '.gl'), 'w') as buf:
for (k... |
class FolderDataset(AnomalibDataset):
def __init__(self, task: TaskType, transform: A.Compose, normal_dir: (str | Path), root: ((str | Path) | None)=None, abnormal_dir: ((str | Path) | None)=None, normal_test_dir: ((str | Path) | None)=None, mask_dir: ((str | Path) | None)=None, split: ((str | Split) | None)=None, ... |
class GNN(nn.Module):
def __init__(self, dim_in, dim_out, **kwargs):
super(GNN, self).__init__()
GNNStage = stage_dict[cfg.gnn.stage_type]
GNNHead = head_dict[cfg.dataset.task]
if cfg.dataset.node_encoder:
NodeEncoder = node_encoder_dict[cfg.dataset.node_encoder_name]
... |
def ndcg_at_k(r, k, method=0):
dcg_max = dcg_at_k(sorted(r, reverse=True), k, method)
if (not dcg_max):
return 0.0
return (dcg_at_k(r, k, method) / dcg_max) |
class ICLLoss(nn.Module):
def __init__(self, device, temperature=0.05, alpha=0.5):
super(ICLLoss, self).__init__()
self.temp = 0.1
self.alpha = alpha
self.device = device
def forward(self, emb, data_dict):
emb = F.normalize(emb, dim=1)
e1i = emb[data_dict['e1i']]
... |
class NTLMConnectionPool(HTTPSConnectionPool):
scheme = '
def __init__(self, user, pw, authurl, *args, **kwargs):
super(NTLMConnectionPool, self).__init__(*args, **kwargs)
self.authurl = authurl
self.rawuser = user
user_parts = user.split('\\', 1)
self.domain = user_parts... |
def load_metadata(args, shard_paths):
(metadata, _, shards_size_dt) = _load_metadata(args, shard_paths)
return (metadata, shards_size_dt) |
class Elliott_VGG(nn.Module):
def __init__(self, vgg_name):
super(Elliott_VGG, self).__init__()
self.features = self._make_layers(cfg[vgg_name])
self.classifier = nn.Linear(512, 100)
def forward(self, x):
out = self.features(x)
out = out.view(out.size(0), (- 1))
o... |
def gen_partition(layer, batch_size, dim_nodes, options, guaranteed=False):
yielded = False
for (ph, pw) in itertools.product(util.factorize(dim_nodes.h, pe.NUM), util.factorize(dim_nodes.w, pe.NUM)):
pdims = [PhyDim2(h, w) for (h, w) in zip(ph, pw)]
if ((not options.partition_batch) and (pdims[... |
def not_modifier(anaphor, antecedent):
if ((anaphor.attributes['type'] == 'NAM') and (antecedent.attributes['type'] == 'NAM')):
return False
elif ((anaphor.attributes['type'] in ['PRO', 'DEM', 'VRB']) or (antecedent.attributes['type'] in ['PRO', 'DEM', 'VRB'])):
return False
else:
re... |
def test_validate_params_missing_params():
_params({'a': [int]}, prefer_skip_nested_validation=True)
def func(a, b):
pass
func(1, 2) |
class LoginUserOracleProgramPolicy(LinearProgramPolicy):
def __init__(self, config):
labeled_demos = [LabeledDemonstration.from_oracle_programs([[WeightedProgram(FocusAndTypeToken(NearToken(LikeToken(StringToken(u'Username'))), UtteranceSelectorToken(4, 5)), 1)], [WeightedProgram(FocusAndTypeToken(NearToken... |
def test_get_parameter_list():
data = {constants.LOGLINE_NAME: ['This is a dataset structure logline', 'This is a dataset structure logline'], constants.PARSED_LOGLINE_NAME: ['This is a * logline', 'This is a * logline']}
df = pd.DataFrame.from_dict(data)
para_list = df.apply(get_parameter_list, axis=1)
... |
class HomologyGroup_class(AdditiveAbelianGroup_fixed_gens):
def __init__(self, n, invfac):
n = len(invfac)
A = (ZZ ** n)
B = A.span([(A.gen(i) * invfac[i]) for i in range(n)])
AdditiveAbelianGroup_fixed_gens.__init__(self, A, B, A.gens())
self._original_invts = invfac
def... |
_KEYPOINT_OUTPUTS.register('keypoint_output')
class Keypoint_output(nn.Module):
def __init__(self, dim_in):
super(Keypoint_output, self).__init__()
num_keypoints = cfg.KRCNN.NUM_CLASSES
assert ((cfg.KRCNN.RESOLUTION[0] // cfg.KRCNN.ROI_XFORM_RESOLUTION[0]) == (cfg.KRCNN.RESOLUTION[1] // cfg.... |
def all_consecutive(x: List[str]):
return np.all((np.diff([get_frame_number(i) for i in x]) == 1)) |
_utils.test()
def test_indices_with_matrix():
grid_m = ti.field(dtype=ti.i32, shape=(10, 10))
def build_grid():
base = int(ti.Vector([2, 4]))
grid_m[base] = 100
grid_m[int(ti.Vector([1, 1]))] = 10
build_grid()
assert (grid_m[(1, 1)] == 10)
assert (grid_m[(2, 4)] == 100) |
def test__dtw_error():
y = np.array([0.0, 0.1, 1.0, 0.5])
y_hat = np.array([0.1, 2.0, 0.5, 0.0])
score_window = 2
expected = np.array([0.0, 1.9, 0.0, 0.0])
returned = _dtw_error(y, y_hat, score_window)
assert_allclose(returned, expected) |
.ort
def test_save_transients(gpu, sdfg_name):
model = onnx.load(os.path.join(data_directory, 'reshape.onnx'))
transients = {}
dace_model = ONNXModel(sdfg_name, model, save_transients=transients, cuda=gpu, onnx_simplify=False)
dace_model()
assert torch.allclose(transients['bertSLASHembeddingsSLASHRe... |
def clean_polys_pre(I):
wrap = (Polynomial(p) for p in I)
return (list(set((p for p in wrap if (not p.is_zero())))), None) |
def pearson_corr(y_true, y_pred):
fsp = (y_pred - K.mean(y_pred))
fst = (y_true - K.mean(y_true))
devP = K.std(y_pred)
devT = K.std(y_true)
return (K.mean((fsp * fst)) / (devP * devT)) |
_if_no_torch
def test_hf_gpt2_roundtrip_fa():
hf_config = HfGpt2Config.from_pretrained('gpt2')
config = Gpt2Config.from_hf_config(hf_config)
config = dataclasses.replace(config, use_flash_attention=True, flash_attention_block_size=128)
_roundtrip_compare_gpt2_checkpoint('gpt2', None, config=config) |
def features_to_string(features):
if (not features):
return None
if (len(features.key) == 0):
return None
return '|'.join((('%s=%s' % (key, value)) for (key, value) in zip(features.key, features.value))) |
def report_detail(hds, nlu, g_sc, g_sa, g_wn, g_wc, g_wo, g_wv, g_wv_str, g_sql_q, g_ans, pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wv_str, pr_sql_q, pr_ans, cnt_list, current_cnt):
(cnt_tot, cnt, cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wv, cnt_wvi, cnt_lx, cnt_x) = current_cnt
print(f'cnt = {cnt} / {cnt_tot} '... |
def vec_gradient(l):
gradient = tf.gradients(l, tf.trainable_variables())
vec_grads = [tf.reshape(grad, [(- 1)]) for grad in gradient]
z = tf.concat(vec_grads, 0)
return z |
def some_query_exact_entity_pair(triple, hits, es, INDEX_NAME, filter_stopwords, entity_mentions_map_filtered_low_count_implicits_dict):
def _internal_func(q1, q2):
result = es.search(index=INDEX_NAME, size=hits, body={'query': {'bool': {'must': [{'term': {'subject_mention_exact': q1}}, {'term': {'object_me... |
def decorator_keywords(func):
_wraps(func)
def wrapped(f=None, **kwargs):
if (f is None):
return sage_wraps(func)((lambda f: func(f, **kwargs)))
else:
return func(f, **kwargs)
return wrapped |
def correctThiago(allnodes, verbose=False):
if verbose:
print('\n', ('-' * 30))
for t in allnodes:
print(t.eduspan, t.prop, t.relation, [r.eduspan for r in t.nodelist])
print('\n', ('-' * 30))
allnodes = findDuplicate(allnodes)
if verbose:
print('\n', ('-' * 30))
... |
class TinyImageNet(Dataset):
def __init__(self, root, split='train', transform=None, target_transform=None):
NUM_IMAGES_PER_CLASS = 500
self.root = os.path.expanduser(root)
self.transform = transform
self.target_transform = target_transform
self.split_dir = os.path.join(self.... |
def convert_detectron2_names(weights):
logger = logging.getLogger(__name__)
logger.info('Remapping Detectrons weights ......')
original_keys = sorted(weights.keys())
layer_keys = copy.deepcopy(original_keys)
layer_keys = [k.replace('proposal_generator.rpn_head.conv', 'proposal_generator.rpn_head.obj... |
def main():
start_time = time.time()
dataset = []
sys.stderr.write((str(datetime.datetime.now()) + '\n'))
book_index = 0
for (i, s_url) in enumerate(ProgressBar()(search_urls)):
time.sleep(SLEEP_SEC)
for try_count in range(MAX_OPEN_COUNT):
try:
response = ... |
class NegativeLog(Flow):
def __init__(self):
super().__init__()
self.eps = torch.finfo(torch.get_default_dtype()).eps
def forward(self, x):
y = (- torch.log(clamp_preserve_gradients(x, min=self.eps, max=(1.0 - self.eps))))
log_det_jac = y
return (y, log_det_jac)
.expo... |
class Macdonald(UniqueRepresentation):
def __repr__(self):
return self._name
def __init__(self, Sym, q='q', t='t'):
self._sym = Sym
self._s = Sym.s()
self.q = Sym.base_ring()(q)
self.t = Sym.base_ring()(t)
self._name_suffix = ''
if (str(q) != 'q'):
... |
class Dataset(object):
def __init__(self, path=None, prefix=None):
if (path is not None):
self.init_from_path(path)
else:
self.data = pd.DataFrame([], columns=['path', 'abspath', 'label', 'name'])
self.prefix = prefix
self.base_seed = 0
self.batch_queu... |
class Experience(object):
envt: Optional[Environment] = None
def __init__(self, agents: List[LearningAgent], feasible_actions_all_agents: List[List[Action]], time: float, num_requests: int):
super(Experience, self).__init__()
self.agents = agents
self.feasible_actions_all_agents = feasib... |
class Processor():
def __init__(self, arg):
arg.model_saved_name = ('./save_models/' + arg.Experiment_name)
arg.work_dir = ('./work_dir/' + arg.Experiment_name)
self.arg = arg
self.save_arg()
if (arg.phase == 'train'):
if (not arg.train_feeder_args['debug']):
... |
def wronskian(*args):
if (not args):
raise TypeError('wronskian() takes at least one argument (0 given)')
elif (len(args) == 1):
return args[0]
else:
if (isinstance(args[(- 1)], Expression) and args[(- 1)].is_symbol()):
v = args[(- 1)]
fs = args[0:(- 1)]
... |
class ConsoleStatisticsWriter(Writer):
def __init__(self, precision: int=3, use_logging: bool=False, functions: dict=None):
super().__init__()
self.aggregator = StatisticsAggregator(functions)
self.write_helper = ConsoleWriterHelper(use_logging)
self.precision = precision
def wri... |
def test_bernoulli_ts_zozotown_prior():
with pytest.raises(Exception):
BernoulliTS(n_actions=2, is_zozotown_prior=True)
policy_all = BernoulliTS(n_actions=2, is_zozotown_prior=True, campaign='all')
assert (len(np.unique(policy_all.alpha)) != 1)
assert (len(np.unique(policy_all.beta)) != 1)
p... |
class InvalidSyscall(UnsupportedSyscall):
def __init__(self, x86=None, x64=None):
UnsupportedSyscall.__init__(self, x86=x86, x64=x64) |
def compute_time(func):
(func)
def wrapper(*args, **kwargs):
begin = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f'function: {func} computation time: {round((end - begin))}s')
return result
return wrapper |
_module()
class SegFormerHead(BaseDecodeHead):
def __init__(self, feature_strides, embedding_dim, **kwargs):
super(SegFormerHead, self).__init__(input_transform='multiple_select', **kwargs)
assert (len(feature_strides) == len(self.in_channels))
assert (min(feature_strides) == feature_strides... |
def normalize_shape(caffenet_weights):
for layer in caffenet_weights.layer:
for blob in layer.blobs:
shape = (blob.num, blob.channels, blob.height, blob.width)
if (len(blob.data) != np.prod(shape)):
shape = tuple(blob.shape.dim)
if (len(shape) == 1):
... |
def aggregate_mode(mode):
bm25_folder = '/mnt/c/Users/salthamm/Documents/phd/data/coliee2021/task1/bm25/search/{}/separately_para_w_summ_intro/'.format(mode[0])
output_dir = '/mnt/c/Users/salthamm/Documents/phd/data/coliee2021/task1/bm25/aggregate/{}/separately_para_w_summ_intro/'.format(mode[0])
run = read... |
def get_state_dict(net_type: str='alex', version: str='0.1'):
url = (' + f'master/lpips/weights/v{version}/{net_type}.pth')
old_state_dict = torch.hub.load_state_dict_from_url(url, progress=True, map_location=(None if torch.cuda.is_available() else torch.device('cpu')))
new_state_dict = OrderedDict()
fo... |
def get_args():
ap = argparse.ArgumentParser()
ap.add_argument('--scale', dest='scale', type=int, default=224, help='Scale (e.g. 224) for image')
ap.add_argument('--model', dest='model', default='testmodel', help='Model name to load')
ap.add_argument('--port', dest='port', type=int, default=9001, help='... |
def algo_tester(algo: TransformerAlgoBase[(TransformerAlgoImplBase, TransformerConfig)], observation_shape: Shape, action_size: int=2) -> None:
fit_tester(algo, observation_shape, action_size)
from_json_tester(algo, observation_shape, action_size)
load_learnable_tester(algo, observation_shape, action_size)
... |
def parse_file(task_name, log_dir, foldername):
path = os.path.join(log_dir, foldername)
if (task_name in ('allreduce', 'allgather')):
return parse_all_ranks(path)
elif (task_name == 'multicast'):
return parse_all_ranks(path, with_rank0=False)
elif (task_name in ('roundtrip', 'reduce', '... |
class ReparametrizationSampler(ABC, Generic[ProbabilisticModelType]):
def __init__(self, sample_size: int, model: ProbabilisticModelType):
tf.debugging.assert_positive(sample_size)
self._sample_size = sample_size
self._model = model
self._initialized = tf.Variable(False)
def __re... |
class DynamicShapesDataset():
def __init__(self, length=64, seed=42, batch_size=8):
self.length = length
np.random.seed(seed)
sizes = np.random.randint(1, 20, ((length // batch_size),))
self.xs = [np.random.normal(size=(s,)) for s in sizes.repeat(batch_size)]
self.ys = [np.ra... |
def is_ninja_available():
try:
subprocess.check_output('ninja --version'.split())
except Exception:
return False
else:
return True |
def main(args):
if (args.buffer_size < 1):
args.buffer_size = 1
if ((args.max_tokens is None) and (args.max_sentences is None)):
args.max_sentences = 1
assert ((not args.sampling) or (args.nbest == args.beam)), '--sampling requires --nbest to be equal to --beam'
assert ((not args.max_sen... |
class Trainer(object):
def __init__(self, cfg: FairseqConfig, task, model, criterion, quantizer=None):
if isinstance(cfg, Namespace):
logger.warning('argparse.Namespace configuration is deprecated! Automatically converting to OmegaConf')
cfg = convert_namespace_to_omegaconf(cfg)
... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--config', dest='config', default='', type=str, help='3R Scan configuration file name')
parser.add_argument('--split', dest='split', default='', type=str, help='split to run on')
parser.add_argument('--visualise', dest='visualise'... |
def hook_debug(module, input, output):
print(('Hooking ' + module.__class__.__name__))
print('output size:', output.data.size())
return output |
class TestOptions():
def __init__(self):
self.parser = argparse.ArgumentParser()
self.initialized = False
def initialize(self):
self.parser.add_argument('--dataset', type=str, default='paris_streetview', help='The dataset of the experiment.')
self.parser.add_argument('--data_file... |
class _FSMTapeCacheDetectEpsilon_(_FSMTapeCache_):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._visited_states_ = set()
def __deepcopy__(self, memo):
new = super().__deepcopy__(memo)
new._visited_states_ = copy(self._visited_states_)
return... |
def get_global_config(*, raise_exception: bool=True, auto_create: bool=False, return_empty_if_none: bool=False):
config = _get_or_set_config_via_tf_default_graph()
if config:
return config
if _global_config:
return _global_config
import sys
main_mod = sys.modules['__main__']
if (... |
def validate_fi_hetu(df: Union[(str, pd.Series, dd.Series, pd.DataFrame, dd.DataFrame)], column: str='') -> Union[(bool, pd.Series, pd.DataFrame)]:
if isinstance(df, (pd.Series, dd.Series)):
return df.apply(hetu.is_valid)
elif isinstance(df, (pd.DataFrame, dd.DataFrame)):
if (column != ''):
... |
def log_item(tag: str, val: (((((float | int) | bool) | list) | np.ndarray) | torch.Tensor), writer: SummaryWriter, step: Optional[int]=None, nchains: Optional[int]=None) -> None:
if (step is not None):
log_step(tag, step, writer)
tag = check_tag(tag)
if isinstance(val, (Tensor, Array)):
if ... |
def spherical_plot3d(f, urange, vrange, **kwds):
return plot3d(f, urange, vrange, transformation=Spherical('radius', ['azimuth', 'inclination']), **kwds) |
def try_get_nn_module_compiled_mod_and_inputs(*args, **kwargs):
name = get_nn_module_name_from_kwargs(**kwargs)
if (('desc' in kwargs) and ('eval' in kwargs['desc'])):
return
test_name = name
if ('desc' in kwargs):
test_name = '{}_{}'.format(test_name, kwargs['desc'])
test_name = get... |
def train(train_loader, train_table, model, model_bert, opt, bert_config, tokenizer, max_seq_length, num_target_layers, accumulate_gradients=1, check_grad=False, st_pos=0, opt_bert=None, path_db=None, dset_name='train', col_pool_type='start_tok', aug=False):
model.train()
model_bert.train()
ave_loss = 0
... |
class TestRoIDataLoader(unittest.TestCase):
('roi_data.loader.get_minibatch_blob_names', return_value=[u'data'])
('roi_data.loader.get_minibatch', side_effect=get_roidb_blobs)
def test_two_parallel_loaders(self, _1, _2):
train_data = np.random.rand(2, 3, 3).astype(np.float32)
(train_loader, ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.