code stringlengths 101 5.91M |
|---|
def test_cascade_run():
KEYSIZE = 512
KEYNUM = 10
tl = Timeline(.0)
alice = QKDNode('alice', tl)
bob = QKDNode('bob', tl)
alice.set_seed(0)
bob.set_seed(0)
pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])
pair_cascade_protocols(alice.protocol_stack[1], bob.protocol... |
def test_merge_examples_with_body_examples():
parameter_examples = []
request_body_examples = {'type': 'body', 'examples': [{'foo': 'example1'}, {'foo': 'example2'}, {'foo': 'example3'}]}
result = examples.merge_examples(parameter_examples, request_body_examples)
assert (len(result) == 3)
assert all... |
class PyDown(gdb.Command):
def __init__(self):
gdb.Command.__init__(self, 'py-down', gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
def invoke(self, args, from_tty):
move_in_stack(move_up=False) |
def get_bias_metric_specs() -> List[MetricSpec]:
demographic_categories = ['race', 'gender']
target_categories = ['adjective', 'profession']
cross_dem_target = itertools.product(demographic_categories, target_categories)
return ([MetricSpec(class_name='helm.benchmark.metrics.bias_metrics.BiasMetric', ar... |
def compute_average_precision_detection_wrapper(input_triple, tiou_thresholds=np.linspace(0.05, 0.95, 10)):
(query, ground_truth, prediction) = input_triple
scores = compute_average_precision_detection(ground_truth, prediction, tiou_thresholds=tiou_thresholds)
return (query, scores) |
_module()
class PointRend(TwoStageDetector):
def __init__(self, backbone, rpn_head, roi_head, train_cfg, test_cfg, neck=None, pretrained=None, init_cfg=None):
super(PointRend, self).__init__(backbone=backbone, neck=neck, rpn_head=rpn_head, roi_head=roi_head, train_cfg=train_cfg, test_cfg=test_cfg, pretraine... |
def max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False):
if return_indices:
raise NotImplementedError('return_indices is not yet implemented!')
if (stride is None):
stride = torch.jit.annotate(List[int], [])
return torch.nn.functional.max... |
class Bottleneck(nn.Module):
expansion: int = 4
def __init__(self, c1, c2, s=1, downsample=None) -> None:
super().__init__()
self.conv1 = nn.Conv2d(c1, c2, 1, 1, 0, bias=False)
self.bn1 = nn.BatchNorm2d(c2)
self.conv2 = nn.Conv2d(c2, c2, 3, s, 1, bias=False)
self.bn2 = nn... |
def log_nucleus_multinomial_sample(x, size=1, nucleus_p=np.log(0.95)):
assert (nucleus_p <= 0)
if (len(x) == 1):
return ([0] * size)
inds = np.argsort((- x))
sortedx = x[inds]
c = np.logaddexp.accumulate(sortedx)
last_ind = bisect(c, (nucleus_p + c[(- 1)]))
idxs = []
for i in ran... |
class SE(nn.Module):
def __init__(self, in_planes, se_planes):
super(SE, self).__init__()
self.se1 = nn.Conv2d(in_planes, se_planes, kernel_size=1, bias=True)
self.se2 = nn.Conv2d(se_planes, in_planes, kernel_size=1, bias=True)
def forward(self, x):
out = F.adaptive_avg_pool2d(x,... |
def onehot(indexes, N=None, ignore_index=None):
if (N is None):
N = (indexes.max() + 1)
sz = list(indexes.size())
output = indexes.new().byte().resize_(*sz, N).zero_()
output.scatter_((- 1), indexes.unsqueeze((- 1)), 1)
if ((ignore_index is not None) and (ignore_index >= 0)):
output.... |
def parse_arguments():
parser = argparse.ArgumentParser(description='')
parser.add_argument('--event', help='event file', required=False)
parser.add_argument('--dir', help='event directory', required=False)
return parser.parse_args() |
def conv_bn_no_relu(inp, oup, stride):
return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False), nn.BatchNorm2d(oup)) |
class BiaffineScorer2(nn.Module):
def __init__(self, n_in_a=800, n_in_b=800, n_out=400, n_out_label=1, bias_x=False, bias_y=False, scaling=False, dropout=0.33):
super(BiaffineScorer2, self).__init__()
self.l = MLP(n_in=n_in_a, n_out=n_out, dropout=dropout)
self.r = MLP(n_in=n_in_b, n_out=n_o... |
def test_contextual_confusion_matrix_overlap(expected, observed):
expected_return = (None, 1, 1, 5)
returned = contextual_confusion_matrix(expected, observed, weighted=False)
np.testing.assert_array_equal(np.array(returned), np.array(expected_return)) |
class PReLUParameter(_message.Message):
__metaclass__ = _reflection.GeneratedProtocolMessageType
DESCRIPTOR = _PRELUPARAMETER |
def train(train_loader, model, criterion, optimizer, epoch, use_cuda):
model.train()
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
end = time.time()
bar = Bar('Processing', max=len(train_loader))
for (batch_... |
_BOX_HEADS.register('resnet_c5_head')
def resnet_c5_head(dim_in, spatial_scale):
model = ResNet_C5_Head(dim_in, spatial_scale, norm=get_norm())
if cfg.BACKBONE.RESNET.USE_WS:
model = convert_conv2convws_model(model)
return model |
class DeformRoIPool(nn.Module):
def __init__(self, output_size, spatial_scale=1.0, sampling_ratio=0, gamma=0.1):
super(DeformRoIPool, self).__init__()
self.output_size = _pair(output_size)
self.spatial_scale = float(spatial_scale)
self.sampling_ratio = int(sampling_ratio)
sel... |
def huber_loss(x, delta=1.0):
'Reference:
return tf.where((tf.abs(x) < delta), (tf.square(x) * 0.5), (delta * (tf.abs(x) - (0.5 * delta)))) |
class MobileNetV1(nn.Module):
def __init__(self) -> None:
super().__init__()
self.stage1 = nn.Sequential(ConvBNReLU(3, 8, 3, 2, 1, 0.1), DWConv(8, 16, 1), DWConv(16, 32, 2), DWConv(32, 32, 1), DWConv(32, 64, 2), DWConv(64, 64, 1))
self.stage2 = nn.Sequential(DWConv(64, 128, 2), DWConv(128, 1... |
def main():
frame = np.zeros((200, 500, 3), np.uint8)
count = 0
cvui.init(WINDOW_NAME)
while True:
frame[:] = (49, 52, 49)
if cvui.button(frame, 110, 80, 'Hello, world!'):
count += 1
cvui.printf(frame, 250, 90, 0.4, , 'Button click count: %d', count)
cvui.imsh... |
def _print_keep_alive(seconds_since_start):
print(('Keep alive, current job runs for %dmin\n' % (seconds_since_start / 60))) |
def rho_inverse(elt):
pa = elt.parent()
BR = pa.base_ring().base_ring()
M_BR = Multizetas(BR)
if (elt == pa.zero()):
return M_BR.zero()
(pw, _) = next(iter(elt))
(p, w) = pw
N = ((2 * p) + sum((int(c) for c in w)))
v = elt.homogeneous_to_vector()
w = (v * rho_matrix_inverse(N... |
class BagREDataset(data.Dataset):
def __init__(self, path, rel2id, tokenizer, entpair_as_bag=False, bag_size=None, mode=None):
super().__init__()
self.tokenizer = tokenizer
self.rel2id = rel2id
self.entpair_as_bag = entpair_as_bag
self.bag_size = bag_size
f = open(pat... |
class BlipImageProcessor(BaseImageProcessor):
model_input_names = ['pixel_values']
def __init__(self, do_resize: bool=True, size: Dict[(str, int)]=None, resample: PILImageResampling=PILImageResampling.BICUBIC, do_rescale: bool=True, rescale_factor: Union[(int, float)]=(1 / 255), do_normalize: bool=True, image_m... |
def extract_model_state_dict(ckpt_path, model_name='model', prefixes_to_ignore=[]):
checkpoint = torch.load(ckpt_path, map_location=torch.device('cpu'))
checkpoint_ = {}
if ('state_dict' in checkpoint):
checkpoint = checkpoint['state_dict']
for (k, v) in checkpoint.items():
if (not k.sta... |
def test_resave_pretrain():
test_pt_file = tempfile.NamedTemporaryFile(dir=f'{TEST_WORKING_DIR}/out', suffix='.pt', delete=False)
try:
test_pt_file.close()
pt = pretrain.Pretrain(filename=test_pt_file.name, vec_filename=f'{TEST_WORKING_DIR}/in/tiny_emb.xz')
check_pretrain(pt)
pt2... |
class CreateAIDACONLL(PipelineJob):
def __init__(self, preprocess_jobs: Dict[(str, PipelineJob)], opts):
super().__init__(requires=['data/indexes/redirects_en.ttl.bz2.dict', 'data/indexes/freebase_links_en.ttl.bz2.dict', 'data/indexes/page_ids_en.ttl.bz2.dict', 'data/indexes/disambiguations_en.ttl.bz2.dict'... |
def test_weights(sdfg_name, gpu):
class Module(torch.nn.Module):
def __init__(self):
super(Module, self).__init__()
self.fc1 = nn.Linear(784, 120)
self.fc2 = nn.Linear(120, 32)
self.fc3 = nn.Linear(32, 10)
def forward(self, x):
x = F.relu(s... |
def intersectionAndUnion(imPred, imLab, numClass):
imPred = (imPred * (imLab >= 0))
intersection = (imPred * (imPred == imLab))
(area_intersection, _) = np.histogram(intersection, bins=numClass, range=(1, numClass))
(area_pred, _) = np.histogram(imPred, bins=numClass, range=(1, numClass))
(area_lab,... |
class GCNConv(MessagePassing):
_cached_edge_index: Optional[Tuple[(Tensor, Tensor)]]
_cached_adj_t: Optional[SparseTensor]
def __init__(self, in_channels: int, out_channels: int, improved: bool=False, cached: bool=False, add_self_loops: bool=True, normalize: bool=True, bias: bool=True, **kwargs):
kw... |
def check_Kraus_local_2(c4, c6, P, a1=None, assume_nonsingular=False):
if (not assume_nonsingular):
if (not c4c6_nonsingular(c4, c6)):
return (False, 0, 0)
e = P.ramification_index()
P2 = (P ** e)
c4val = c4.valuation(P)
if (c4val == 0):
if (a1 is None):
(flag... |
def test_getter(nlp_pipeline):
Word.add_property('upos_xpos', getter=(lambda self: f'{self.upos}_{self.xpos}'))
doc = nlp_pipeline(EN_DOC)
assert (EN_DOC_UPOS_XPOS == tuple((tuple((word.upos_xpos for word in sentence.words)) for sentence in doc.sentences))) |
def batchify(TEXT, device, data, bsz):
data = TEXT.numericalize([data.examples[0].text])
nbatch = (data.size(0) // bsz)
data = data.narrow(0, 0, (nbatch * bsz))
data = data.view(bsz, (- 1)).t().contiguous()
return data.to(device) |
(auto_optimize=True, device=dtypes.DeviceType.CPU)
def spmv(A_row: dace.uint32[(M + 1)], A_col: dace.uint32[nnz], A_val: dtype[nnz], x: dtype[N], y: dtype[M]):
for i in range((A_row.size - 1)):
cols = A_col[A_row[i]:A_row[(i + 1)]]
vals = A_val[A_row[i]:A_row[(i + 1)]]
y[i] = (vals x[cols]) |
def complex_flatten(real, imag):
real = tf.keras.layers.Flatten()(real)
imag = tf.keras.layers.Flatten()(imag)
return (real, imag) |
def get_reconciler_common_network_args(env, embedding_dim):
network_args = dict(name='reconciler_common_network', output_dim=embedding_dim, hidden_sizes=(256,), hidden_nonlinearity=tf.nn.relu, output_nonlinearity=None, batch_normalization=False)
return network_args |
def decl_texture_arg(num_dimensions, name):
arg_id = impl.get_runtime().compiling_callable.insert_texture_param(num_dimensions, name)
dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
return TextureSampler(_ti_core.make_texture_ptr_expr(arg_id, num_dimensions, 0, dbg_info), num_dimens... |
def get_rotated_fmnist_loaders(angle, data_path, model_class='LeNet', download=False):
if (model_class == 'MLP'):
shift_tforms = transforms.Compose([RotationTransform(angle), transforms.ToTensor(), ReshapeTransform(((- 1),))])
else:
shift_tforms = transforms.Compose([RotationTransform(angle), tr... |
class ClipPercentile(LoopEntryTransform):
def __init__(self, upper_percentile: float, lower_percentile: float=None, loop_axis=None, entries=(defs.KEY_IMAGES,)) -> None:
super().__init__(loop_axis=loop_axis, entries=entries)
self.upper_percentile = upper_percentile
if (lower_percentile is Non... |
class FSM(nn.Module):
def __init__(self, c1, c2):
super().__init__()
self.conv_atten = nn.Conv2d(c1, c1, 1, bias=False)
self.conv = nn.Conv2d(c1, c2, 1, bias=False)
def forward(self, x: Tensor) -> Tensor:
atten = self.conv_atten(F.avg_pool2d(x, x.shape[2:])).sigmoid()
fea... |
def _generate_dataset(args_namespace):
return generate_dataset(args_namespace.language, *args_namespace.files) |
def parse_args():
desc = 'Tensorflow implementation of StarGAN_v2'
parser = argparse.ArgumentParser(description=desc)
parser.add_argument('--phase', type=str, default='train', help='train or test or refer_test ?')
parser.add_argument('--dataset', type=str, default='celebA-HQ_gender', help='dataset_name'... |
def test_jax_scvi_training(n_latent: int=5, dropout_rate: float=0.1):
adata = synthetic_iid()
JaxSCVI.setup_anndata(adata, batch_key='batch')
model = JaxSCVI(adata, n_latent=n_latent, dropout_rate=dropout_rate)
assert model.module.training
with mock.patch('scvi.module._jaxvae.nn.Dropout', wraps=nn.D... |
def get_include(user=False):
from distutils.dist import Distribution
import os
import sys
virtualenv = (hasattr(sys, 'real_prefix') or (sys.prefix != getattr(sys, 'base_prefix', sys.prefix)))
if virtualenv:
return os.path.join(sys.prefix, 'include', 'site', ('python' + sys.version[:3]))
... |
def check_likelihood_grad_BO(likelihood):
df = simple_run_experiments(get_likelihood_grad_BO, likelihood=likelihood, mz_hat=np.linspace(1, 3, 10), tz0_hat=1)
return df |
def main():
parser = TestOptions()
opts = parser.parse()
domains = [chr(i) for i in range(ord('A'), (ord('Z') + 1))]
print('\n--- load dataset ---')
datasets = ([None] * opts.num_domains)
loaders = ([None] * opts.num_domains)
for i in range(opts.num_domains):
datasets[i] = dataset_si... |
_router.get('/weekly_info', response_model=TotalStatsByWeek, response_description='Get gender statistics per English outlet aggregated WEEKLY between two dates')
def expertwomen_weekly_info(request: Request, begin: str=Query(description='Start date in yyyy-mm-dd format'), end: str=Query(description='End date in yyyy-mm... |
class LevelMapper(object):
def __init__(self, k_min, k_max, canonical_scale=224, canonical_level=4, eps=1e-06):
self.k_min = k_min
self.k_max = k_max
self.s0 = canonical_scale
self.lvl0 = canonical_level
self.eps = eps
def __call__(self, boxlists):
s = torch.sqrt(... |
def test_2layers():
time_dim = Dim(Tensor('time', [batch_dim], dtype='int32'))
(in_dim, hidden_dim, out_dim) = (Dim(7, name='in'), Dim(11, name='hidden'), Dim(13, name='out'))
extern_data = TensorDict({'data': Tensor('data', [batch_dim, time_dim, in_dim], dtype='float32'), 'classes': Tensor('classes', [batc... |
class JuPyMake(JoinFeature):
def __init__(self):
JoinFeature.__init__(self, 'jupymake', [PythonModule('JuPyMake', spkg='jupymake')]) |
def KChainComplexMorphism(morphism):
source = KChainComplex(morphism.domain())
target = KChainComplex(morphism.codomain())
matrix_list = morphism_dictmat(morphism)
return KenzoChainComplexMorphism(__kmorphismchaincomplex_aux1__(matrix_list, source._kenzo, target._kenzo)) |
def test_nhypergeom_rvs_shape():
x = nhypergeom.rvs(22, [7, 8, 9], [[12], [13]], size=(5, 1, 2, 3))
assert (x.shape == (5, 1, 2, 3)) |
def bilerp(vf, p):
(u, v) = p
(s, t) = ((u - 0.5), (v - 0.5))
(iu, iv) = (ti.floor(s), ti.floor(t))
(fu, fv) = ((s - iu), (t - iv))
a = sample(vf, iu, iv)
b = sample(vf, (iu + 1), iv)
c = sample(vf, iu, (iv + 1))
d = sample(vf, (iu + 1), (iv + 1))
return lerp(lerp(a, b, fu), lerp(c, ... |
class TestLabeledRegionsDataset():
def test_init(self):
pass
def test_get_item(self):
pass |
def get_params():
params = []
for i in xrange(1, 801):
p = np.load((('./perceptual_models/hourglass/hourglass_weights_' + str(i)) + '.npy'))
if (len(p.shape) == 4):
p = p.swapaxes(0, 1).swapaxes(0, 2).swapaxes(1, 3)
params.append(p)
return params |
def register_Ns3CallbackImplBase_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
cls.add_method('IsEqual', 'bool', [param('ns3::Pt... |
class Inferer():
def __init__(self, config):
self.config = config
if torch.cuda.is_available():
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
torch.set_num_threads(1)
self.model_preproc = registry.instantiate(registry.l... |
def print_top3_scores(filename):
top3 = get_top3_topics(filename)
for (k, v) in top3:
print('{}\t{}\t{}'.format(topic_map[k], k, v)) |
def get_lr_schedulers(enc_optim, dec_optim, enc_lr_gamma, dec_lr_gamma, enc_scheduler_type, dec_scheduler_type, epochs_per_stage):
milestones = np.cumsum(epochs_per_stage)
max_epochs = milestones[(- 1)]
schedulers = [dt.misc.create_scheduler(scheduler_type=enc_scheduler_type, optim=enc_optim, gamma=enc_lr_g... |
def label2onehot(labels, dim):
batch_size = labels.size(0)
out = torch.zeros(batch_size, dim)
out[(np.arange(batch_size), labels.long())] = 1
return out |
def same_shapes(*xs):
shapes = []
for x in xs:
if isinstance(x, Matrix):
shapes.append(x.get_shape())
elif isinstance(x, list):
shapes.append(tuple(get_list_shape(x)))
elif isinstance(x, Expr):
shapes.append(tuple(x.ptr.get_rvalue_type().shape()))
... |
class csv_dataset(data.Dataset):
def __init__(self, path, tokenizer=None, preprocess_fn=None, delim=',', binarize_sent=False, drop_unlabeled=False, text_key='sentence', label_key='label', **kwargs):
self.is_lazy = False
self.preprocess_fn = preprocess_fn
self.SetTokenizer(tokenizer)
... |
def parse_args():
parser = argparse.ArgumentParser(description='Train a detector')
parser.add_argument('config', help='train config file path')
parser.add_argument('--shape', type=int, nargs='+', default=[40000, 4], help='input point cloud size')
parser.add_argument('--modality', type=str, default='poin... |
class Logger(object):
def __init__(self, filename='Default.log'):
self.terminal = sys.stdout
self.log = open(filename, 'w')
def delink(self):
self.log.close()
def writeTerminalOnly(self, message):
self.terminal.write(message)
def write(self, message):
self.termina... |
def get_dataset(args: DataTrainingArguments, tokenizer: PreTrainedTokenizer, evaluate=False, local_rank=(- 1)):
file_path = (args.eval_data_file if evaluate else args.train_data_file)
if args.line_by_line:
return LineByLineTextDataset(tokenizer=tokenizer, file_path=file_path, block_size=args.block_size)... |
def nets_to_graph_def(nets, shapes=None, **kwargs):
shapes = {}
nets = [copy.deepcopy(net.Proto()) for net in nets]
shapes = copy.deepcopy(shapes)
return protos_to_graph_def(nets, shapes, **kwargs) |
def CntSelfEdges(tspec, *args):
if (type(tspec) == PUNGraph):
return CntSelfEdges_PUNGraph(tspec, *args)
if (type(tspec) == PUndirNet):
return CntSelfEdges_PUndirNet(tspec, *args)
if (type(tspec) == PDirNet):
return CntSelfEdges_PDirNet(tspec, *args)
if (type(tspec) == PNGraph):
... |
class arcsine_gen(rv_continuous):
def _shape_info(self):
return []
def _pdf(self, x):
with np.errstate(divide='ignore'):
return ((1.0 / np.pi) / np.sqrt((x * (1 - x))))
def _cdf(self, x):
return ((2.0 / np.pi) * np.arcsin(np.sqrt(x)))
def _ppf(self, q):
return... |
class Partition6(nn.Module):
LAYER_SCOPES = ['T5ForConditionalGeneration/T5Stack[encoder]/T5Block[18]', 'T5ForConditionalGeneration/T5Stack[encoder]/T5Block[19]', 'T5ForConditionalGeneration/T5Stack[encoder]/T5Block[20]']
TENSORS = []
def __init__(self, layers, tensors, device='cuda:6'):
super().__i... |
def conv1x1(in_plane, out_plane, stride=1):
return nn.Conv2d(in_plane, out_plane, kernel_size=1, stride=stride, padding=0, bias=False) |
def should_stop_early(args, valid_loss):
if (valid_loss is None):
return False
if (args.patience <= 0):
return False
def is_better(a, b):
return ((a > b) if args.maximize_best_checkpoint_metric else (a < b))
prev_best = getattr(should_stop_early, 'best', None)
if ((prev_best ... |
def download(url, folder='.', overwrite=False, verbose=True):
import urllib.request
import os
import sys
def rename_path(downloadpath):
splitfullpath = downloadpath.split(os.path.sep)
fname = splitfullpath[(- 1)]
fnamesplit = fname.split('.')
newname = fnamesplit[0]
... |
def unique(l):
lu = []
for l1 in l:
if (l1 not in lu):
lu.append(l1)
return lu |
def ref_all_gather(x_data, n_devices):
results = []
for i in range(n_devices):
results.append((x_data * i))
return results |
def evaluate(args, model, tokenizer, mode, prefix=''):
eval_task = args.task_name
eval_output_dir = args.output_dir
eval_dataset = load_and_cache_examples(args, eval_task, tokenizer, mode)
if ((not os.path.exists(eval_output_dir)) and (args.local_rank in [(- 1), 0])):
os.makedirs(eval_output_dir... |
def ResNet101_rpn_conv4_frozen_features(model):
return build_generic_detection_model(model, ResNet.add_ResNet101_conv4_body, freeze_conv_body=True) |
def script_qconfig(qconfig):
return QConfig(activation=torch.jit.script(qconfig.activation())._c, weight=torch.jit.script(qconfig.weight())._c) |
class PrefixSet(object):
def __init__(self):
self._set = set()
def train(self, word_s):
for word in word_s:
for index in range(len(word)):
self._set.add(word[:(index + 1)])
def __contains__(self, key):
return (key in self._set) |
class NCESoftmaxLoss(nn.Module):
def __init__(self, nce_t):
super(NCESoftmaxLoss, self).__init__()
self.loss = nn.CrossEntropyLoss(reduction='none')
self.nce_t = nce_t
def forward(self, x_ret, y_ret):
(x, _) = x_ret
(y, _) = y_ret
bsz = x.shape[0]
scores =... |
class SubbandNet(nn.Module):
def __init__(self, _, cfg):
super().__init__()
self.cfg = cfg
self.dim = cfg.dim
self.out_dim = cfg.out_dim
self.hid_dim = cfg.hid_dim
self.bw_span_diag = getattr(cfg, 'bw_span_diag', False)
self.max_bw = float(eval(str(cfg.max_bw)... |
def test_kernel_and_bias_defaults():
gs = GraphSAGE(layer_sizes=[4, 4], n_samples=[2, 2], input_dim=2, multiplicity=1)
for layer in gs._aggs:
assert isinstance(layer.kernel_initializer, tf.initializers.GlorotUniform)
assert isinstance(layer.bias_initializer, tf.initializers.Zeros)
assert... |
def _load_csv(F):
names = F.readline().decode('ascii').strip().split(',')
rec = np.loadtxt(F, skiprows=0, delimiter=',', dtype='a22,f4,f4')
rec.dtype.names = names
return rec |
def main():
parser = argparse.ArgumentParser(description='OGBL-DDI (GNN)')
parser.add_argument('--device', type=int, default=0)
parser.add_argument('--log_steps', type=int, default=1)
parser.add_argument('--use_sage', action='store_true')
parser.add_argument('--num_layers', type=int, default=2)
... |
def align_to_char_level(span_starts, span_ends, token_to_char, subtoken_map=None, new_token_map=None):
char_map = {}
reverse_char_map = {}
for (idx, (start, end)) in enumerate(zip(span_starts, span_ends)):
(new_start, new_end) = (start.copy(), end.copy())
try:
if (subtoken_map is... |
def get(identifier):
if (identifier is None):
return linear
return get_from_module(identifier, globals(), 'activation function') |
def build_activation(act_func, inplace=True):
if (act_func == 'relu'):
return nn.ReLU(inplace=inplace)
elif (act_func == 'relu6'):
return nn.ReLU6(inplace=inplace)
elif (act_func == 'tanh'):
return nn.Tanh()
elif (act_func == 'sigmoid'):
return nn.Sigmoid()
elif (act_... |
def create_projection_head(args, device, use_checkpoint=True):
projection_head = vits.__dict__['DINOHead'](in_dim=args.feat_dim, out_dim=args.mlp_out_dim, nlayers=args.num_mlp_layers)
projection_head.to(device)
if ((args.load_from_head is not None) and (use_checkpoint == True)):
print(f'NOTE: load h... |
def latex_dual(elt):
M = (elt.parent().cartan_type().rank() + 2)
from sage.combinat.tableau import Tableau
from sage.combinat.output import tex_from_array
if (not elt):
return '{\\emptyset}'
tab = [['\\overline{{{}}}'.format((M - elt[0].value))]]
for i in range(1, len(elt)):
if (... |
class Blog(BaseDataset):
__doc__ = f'''
This data originates from blog posts. The raw HTML-documents of the blog posts were
crawled and processed. The prediction task associated with the data is the
prediction of the number of comments in the upcoming 24 hours. In order to simulate
this situation, w... |
def augment_dataset(d, programs):
programs = np.random.permutation(programs).tolist()
for (program_name, apt_name) in tqdm(programs):
augmented_progs_i = []
augmented_progs_i_new_inst = []
augmented_preconds_i = []
state_list_i = []
if (program_name in d.keys()):
... |
def remove_files_patterns(root_dir, patterns, ignores=None, verbose=False):
from itertools import chain
if (ignores is None):
ignores = []
for _f in chain(*[glob.glob(os.path.join(root_dir, pattern)) for pattern in patterns]):
can_remove = True
for ignore in ignores:
if f... |
def get_pseudo_label_DS_for_one_segment(args, sample_gt_path):
step_scores = np.load(sample_gt_path)
video_sid = sample_gt_path.split('/')[(- 2)]
segment_sid = sample_gt_path.split('/')[(- 1)].split('.')[0]
(matched_steps, matched_steps_scores) = find_matching_of_a_segment(step_scores, criteria=args.lab... |
def test_scalar_norm_optimization(rng, config_ocp, y, geometry, F, bcs, u, p):
config_ocp.set('OptimizationRoutine', 'algorithm', 'bfgs')
config_ocp.set('OptimizationRoutine', 'rtol', '1e-3')
u.vector().vec().set(0.001)
u.vector().apply('')
norm_y = ((y * y) * geometry.dx)
tracking_goal = rng.un... |
def extract_class(file_name):
match = re.search('(\\d+)_(.+)\\.jpg', file_name)
if match:
return match.group(2)
else:
match = re.search('(\\d+)_(.+)\\.png', file_name)
if match:
return match.group(2)
return None |
_data_model
class GraphData():
def __init__(self, j: Dict[(str, Any)]) -> None:
dispatches = j['dispatches']
self.dispatches = [Dispatch(x) for x in dispatches] |
class DensityPlot(GraphicPrimitive):
def __init__(self, xy_data_array, xrange, yrange, options):
self.xrange = xrange
self.yrange = yrange
self.xy_data_array = xy_data_array
self.xy_array_row = len(xy_data_array)
self.xy_array_col = len(xy_data_array[0])
GraphicPrimit... |
def drop_out(input, keep_prob, is_train):
if is_train:
out = tf.nn.dropout(input, keep_prob)
else:
keep_prob = 1
out = tf.nn.dropout(input, keep_prob)
return out |
def pil_loader(path: str) -> Image.Image:
with open(path, 'rb') as f:
img = Image.open(f)
return img.convert('RGB') |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.