code stringlengths 101 5.91M |
|---|
def seed_test_case0():
var0 = 10
var1 = module0.Simple(var0)
var2 = [1, 2, 3]
var3 = var1.do_something(var2)
assert (var3 == 'not empty!') |
def max_tree_local_maxima(image, connectivity=1, parent=None, tree_traverser=None):
output = np.ones(image.shape, dtype=np.uint64)
if ((parent is None) or (tree_traverser is None)):
(parent, tree_traverser) = max_tree(image, connectivity)
_max_tree._max_tree_local_maxima(image.ravel(), output.ravel(... |
class GVContext(object):
def __init__(self):
self.blockids = {}
self.nextid = 0
self.children = []
self.sources = {}
def add(self, child):
self.children.append(child)
def nodeid(self, block):
if (block not in self.blockids):
self.blockids[block] = ... |
class ResNet3X3(nn.Module):
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 128
super(ResNet3X3, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = mynn.Norm2d(64)
self.relu1 = nn.ReLU(inplace=True)
... |
def test_regular():
array = ak.Array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assert ak.almost_equal(array, array, check_regular=True)
assert ak.almost_equal(array, array, check_regular=False)
assert (not ak.almost_equal(array, ak.to_regular(array), check_regular=True))
assert ak.almost_equal(array, ak.to... |
class PublishFindingsTask():
def __init__(self, experiment_id: str, compiles_base_path: str, review_site_url: str, review_site_user: str='', review_site_password: str=''):
super().__init__()
self.max_files_per_post = 20
self.max_post_size_in_bytes = 7000
self.experiment_id = experime... |
def flatten_grads(var_list, grads):
return tf.concat([tf.reshape(grad, [U.numel(v)]) for (v, grad) in zip(var_list, grads)], 0) |
class SymforceUtilTest(TestCase):
def test_symbolic_eval(self) -> None:
def f(x: T.Scalar, y: sf.V1, z: sf.V2, w: sf.M22, r: sf.Rot3) -> T.Scalar:
return (x, y, z, w, r)
(x, y, z, w, r) = util.symbolic_eval(f)
self.assertIsInstance(x, sf.Symbol)
self.assertIsInstance(y, s... |
def extract_id_from_mp3_path(path) -> str:
fname = os.path.basename(path)
return fname.replace('.mp3', '') |
def generate_match_method(byte_array, template):
s = StringIO()
fields = template.fields()
field_types = [f.c_type() for f in fields]
field_names = [f.name for f in fields]
args = ((', ' + ', '.join((('%s: &mut %s' % (t, n)) for (t, n) in zip(field_names, field_types)))) if fields else '')
s.wri... |
def simple_renderer(rn, verts, faces, yrot=np.radians(120)):
color = colors['pink']
rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3))
albedo = rn.vc
rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([(- 200), (- 100), (- 100)]), yrot), vc=albedo, light_co... |
def count_flops_given_config(net_config, image_size=224):
flops = 0
flops += count_conv_flop(((image_size + 1) // 2), 3, net_config['first_conv']['out_channels'], 3, 1)
fsize = ((image_size + 1) // 2)
for block in net_config['blocks']:
mb_conv = (block['mobile_inverted_conv'] if ('mobile_inverte... |
class HistnormEvaluator(BasicEvaluator):
def evaluate(self, predict, ground_truth):
(correct, dist) = super().evaluate(predict, ground_truth)
return (correct, (dist / len(ground_truth))) |
class ModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
(group, base_ring, k, ep, n) = canonical_parameters(group, base_ring, k, ep, n)
return super().__classcall__(cls, group=group, base_ring... |
def interpolate(sparse_points, dense_points, nn_num=1, GPU_id=None):
if ((GPU_id is not None) and cal_knn.FAISS_INSTALLED):
knn_module = cal_knn.FaissNN
else:
knn_module = cal_knn.Open3dNN
knn = knn_module(GPU_id=GPU_id)
knn.train(sparse_points)
return knn.search(dense_points, nn_num... |
class GeneralizedRCNNWithTTA(nn.Module):
def __init__(self, cfg, model, tta_mapper=None, batch_size=3):
super().__init__()
if isinstance(model, DistributedDataParallel):
model = model.module
assert isinstance(model, GeneralizedRCNN), 'TTA is only supported on GeneralizedRCNN. Got... |
def _preprocess_zero_mean_unit_range(inputs):
return (((2.0 / 255.0) * tf.to_float(inputs)) - 1.0) |
class Set_object_intersection(Set_object_binary):
def __init__(self, X, Y, category=None):
if (category is None):
category = Sets()
if any(((S in Sets().Finite()) for S in (X, Y))):
category = category.Finite()
if any(((S in Sets().Enumerated()) for S in (X, Y))):
... |
def StopImmediate():
global _immediate_mode
global _immediate_root_folder
if (not IsImmediate()):
return
with WorkspaceGuard(_immediate_workspace_name):
ResetWorkspace()
shutil.rmtree(_immediate_root_folder)
_immediate_root_folder = ''
_immediate_mode = False |
def check(opt, type_model, encoding=config.encoding, assume_inhabited=False):
logger.info('Checking refinement of %r', opt.name)
encoding = smtinterp.lookup(encoding)
smt = encoding(type_model)
asm = smt.conjunction(opt.asm)
premise = ((asm.aux + asm.safe) + asm.value)
if (asm.defined or asm.non... |
def build_conv_model(model_name, batch_size):
model_gen_map = conv_model_generators()
assert (model_name in model_gen_map), (('Model ' + model_name) + ' not found')
(model, input_size) = model_gen_map[model_name]('NCHW', None)
input_shape = [batch_size, 3, input_size, input_size]
if (model_name == '... |
class BlockRounding(torch.autograd.Function):
def forward(self, x, forward_bits, backward_bits, mode, small_block='None', block_dim='B'):
self.backward_bits = backward_bits
self.mode = mode
if (forward_bits == (- 1)):
return x
self.small_block = small_block
self.b... |
def _check_numclasscheckhook(detector, config_mod):
dummy_runner = Mock()
dummy_runner.model = detector
def get_dataset_name_classes(dataset):
if isinstance(dataset, (list, tuple)):
dataset = dataset[0]
while ('dataset' in dataset):
dataset = dataset['dataset']
... |
class Langermann(Benchmark):
def __init__(self, dimensions=2):
Benchmark.__init__(self, dimensions)
self._bounds = list(zip(([0.0] * self.N), ([10.0] * self.N)))
self.global_optimum = [[2., 1.006096]]
self.fglob = (- 5.1621259)
def fun(self, x, *args):
self.nfev += 1
... |
def has_leading_dir(paths):
common_prefix = None
for path in paths:
(prefix, rest) = split_leading_dir(path)
if (not prefix):
return False
elif (common_prefix is None):
common_prefix = prefix
elif (prefix != common_prefix):
return False
ret... |
def accuracy_evaluation(input_net, dataset_loader, working_device):
input_net = input_net.eval()
correct_acc = 0
total_acc = 0
prefetcher = DataPreFetcher(dataset_loader)
(image, label) = prefetcher.next()
with tqdm(total=len(dataset_loader)) as pbar:
while (image is not None):
... |
_spec_function('natural_qa')
def get_natural_qa_spec(mode: str) -> RunSpec:
scenario_spec = ScenarioSpec(class_name='helm.benchmark.scenarios.natural_qa_scenario.NaturalQAScenario', args={'mode': mode})
adapter_spec = get_generation_adapter_spec(input_noun=('Question' if (mode == 'closedbook') else None), outpu... |
class CrossEntropy2d(nn.Module):
def __init__(self, ignore_label=255):
super(CrossEntropy2d, self).__init__()
self.ignore_label = ignore_label
def forward(self, predict, target, weight=None):
assert (not target.requires_grad)
assert (predict.dim() == 4)
assert (target.dim... |
class VQNoDiscModel(VQModel):
def __init__(self, ddconfig, lossconfig, n_embed, embed_dim, ckpt_path=None, ignore_keys=[], image_key='image', colorize_nlabels=None):
super().__init__(ddconfig=ddconfig, lossconfig=lossconfig, n_embed=n_embed, embed_dim=embed_dim, ckpt_path=ckpt_path, ignore_keys=ignore_keys,... |
def k_center_greedy_slow(X, s, b):
n = X.shape[0]
p = np.setdiff1d(np.arange(n), s, assume_unique=True).tolist()
sel = list(s)
for i in range(b):
D = scipy.spatial.distance.cdist(X[sel], X[p], metric='euclidean')
j = np.argmax(np.min(D, axis=0))
u = p[j]
sel.append(u)
... |
def test_data_iterator(files, seq_len):
load_records_np(files=files, seq_len=seq_len)
test_restore_state(files=files, seq_len=seq_len) |
def GuttmanLambdaA_calc(TP, FP, FN, TN):
try:
n = (((TP + FP) + FN) + TN)
part1 = (max(TP, FN) + max(FP, TN))
part2 = max((TP + FP), (FN + TN))
return ((part1 - part2) / (n - part2))
except Exception:
return 'None' |
class BaseOptions():
def initialize(self, parser):
parser.add_argument('--name', type=str, required=True, help='name of the experiment. It decides where to store samples and models')
parser.add_argument('--easy_label', type=str, default='')
parser.add_argument('--num_gpus', type=int, default... |
class XLMProphetNetPreTrainedModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def process_kron(kron_dir):
txt_files = []
for f in os.listdir(kron_dir):
filename = os.fsdecode(f)
if filename.endswith('.txt'):
txt_files.append(filename)
elif filename.endswith('.dat'):
return utils.load_graph_list(os.path.join(kron_dir, filename))
G_list =... |
class UF1(Metric):
def __init__(self, eps=1e-08, device=torch.device('cuda')):
super(UF1, self).__init__()
self.f1 = 0.0
self.evalb = 0.0
self.n = 0.0
self.eps = eps
self.tp = 0.0
self.fp = 0.0
self.fn = 0.0
self.device = device
def __call_... |
def easy_dtype(ndtype, names=None, defaultfmt='f%i', **validationargs):
try:
ndtype = np.dtype(ndtype)
except TypeError:
validate = NameValidator(**validationargs)
nbfields = len(ndtype)
if (names is None):
names = ([''] * len(ndtype))
elif isinstance(names, b... |
_properties
class InterstateEdge(object):
assignments = Property(dtype=dict, desc="Assignments to perform upon transition (e.g., 'x=x+1; y = 0')", from_string=_assignments_from_string, to_string=_assignments_to_string)
condition = CodeProperty(desc='Transition condition', default=CodeBlock('1'))
def __init_... |
def get_cnt_sents(texts):
cnt_all_sent = 0
for text in texts:
cnt_all_sent += len(nltk.sent_tokenize(text))
return cnt_all_sent |
def generate_ann(root_path, split, image_infos):
dst_image_root = osp.join(root_path, 'dst_imgs', split)
if (split == 'training'):
dst_label_file = osp.join(root_path, 'train_label.txt')
elif (split == 'test'):
dst_label_file = osp.join(root_path, 'test_label.txt')
os.makedirs(dst_image_... |
def correct_time_related_info(arch_index: int, arch_infos: Dict[(Text, ArchResults)]):
train_per_epoch_time = list(arch_infos['12'].query('darcyflow', 777).train_times.values())
train_per_epoch_time = (sum(train_per_epoch_time) / len(train_per_epoch_time))
(eval_ori_test_time, eval_x_valid_time) = ([], [])
... |
class SpectrogramDataset(Dataset, SpectrogramParser):
def __init__(self, audio_paths: list, transcripts: list, sos_id: int, eos_id: int, config: DictConfig, spec_augment: bool=False, dataset_path: str=None, audio_extension: str='pcm') -> None:
super(SpectrogramDataset, self).__init__(feature_extract_by=conf... |
class ResidualBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
... |
def create_area_light(location: Tuple[(float, float, float)]=(0.0, 0.0, 5.0), rotation: Tuple[(float, float, float)]=(0.0, 0.0, 0.0), size: float=5.0, color: Tuple[(float, float, float, float)]=(1.0, 0.9, 0.8, 1.0), strength: float=1000.0, name: Optional[str]=None) -> bpy.types.Object:
if (bpy.app.version >= (2, 80... |
class layer_norm(object):
def __init__(self, name='layer_norm'):
self.name = name
def __call__(self, x):
return tf.contrib.layers.layer_norm(x, scope=self.name) |
class DropPath(nn.Module):
def __init__(self, drop_prob: float=0.0, scale_by_keep: bool=True):
super(DropPath, self).__init__()
self.drop_prob = drop_prob
self.scale_by_keep = scale_by_keep
def forward(self, x):
return drop_path(x, self.drop_prob, self.training, self.scale_by_kee... |
def create_reverse_dependency_map():
cache = {}
all_modules = (list(PATH_TO_TRANFORMERS.glob('**/*.py')) + list(PATH_TO_TESTS.glob('**/*.py')))
all_modules = [str(mod.relative_to(PATH_TO_REPO)) for mod in all_modules]
direct_deps = {m: get_module_dependencies(m, cache=cache) for m in all_modules}
so... |
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(1, 6, (3, 3))
self.conv2 = nn.Conv2d(6, 16, (3, 3))
self.fc1 = nn.Linear(((16 * 6) * 6), 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(se... |
class AdjustDefByDirectives(CythonTransform, SkipDeclarations):
def visit_ModuleNode(self, node):
self.directives = node.directives
self.in_py_class = False
self.visitchildren(node)
return node
def visit_CompilerDirectivesNode(self, node):
old_directives = self.directives... |
def expected_calibration_error(y_hat: Prediction, y: Tensor, n_bins: int=10) -> Tensor:
if ((y_hat.soft is None) or (y_hat.hard is None)):
return torch.as_tensor(float('nan'))
batch_size = y_hat.soft.size(0)
if (batch_size == 0):
return torch.as_tensor(float('nan'))
(acc_binned, conf_bin... |
def main():
seed = 1234
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
if (args.dataset[0] == 'deepfashion'):
ds = pd.read_csv('./Anno/df_info.csv')
from dataset import DeepFashionDataset as DataManager
elif (args.dataset[0] == 'fld'):
ds = ... |
class SNRHomogeneousBlocks(SNRBase):
def __init__(self, patch_size: int=3, stride: Optional[int]=None, **kwargs: Any) -> None:
super().__init__(**kwargs)
self.patch_size = patch_size
self.stride = (self.patch_size if (not stride) else stride)
def get_snr_value(self, img: np.array) -> Tup... |
def _make_deprecate(meth):
new_name = meth.__name__
old_name = new_name[:(- 1)]
def deprecated_init(*args, **kwargs):
warnings.warn('nn.init.{} is now deprecated in favor of nn.init.{}.'.format(old_name, new_name), stacklevel=2)
return meth(*args, **kwargs)
deprecated_init.__doc__ = '\n ... |
class Label(object):
def __init__(self, field_id, text):
self.field_id = field_id
self.text = text
def __str__(self):
return self()
def __unicode__(self):
return self()
def __html__(self):
return self()
def __call__(self, text=None, **kwargs):
if ('for... |
class SemiMarkovConditionalRandomField(torch.nn.Module):
def __init__(self, num_tags: int, default_tag: int, max_span_width: int, outside_span_tag: int=None, loss_type: str='logloss', false_positive_penalty: float=1.0, false_negative_penalty: float=1.0) -> None:
super().__init__()
self.num_tags = nu... |
.parametrize('cfg_file', ['../configs/textrecog/sar/sar_r31_parallel_decoder_academic.py'])
def test_disable_text_recog_aug_test(cfg_file):
tmp_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
config_file = os.path.join(tmp_dir, cfg_file)
cfg = Config.fromfile(config_file)
test = cfg.da... |
def infect(person_sex, relation_type, relation_sex):
infection_probability_month = {'f': {'parent': {'f': 0., 'm': 0.}, 'sibling': {'f': 0., 'm': 0.}, 'partner': {'*': 0.}, 'child': {'*': 0.}}, 'm': {'parent': {'f': 0., 'm': 0.}, 'sibling': {'f': 0., 'm': 0.}, 'partner': {'*': 0.}, 'child': {'*': 0.}}, '*': {'*': {... |
def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):
label_map = {label: i for (i, label) in enumerate(label_list, 1)}
features = []
for (ex_index, example) in enumerate(examples):
textlist = example.text_a.split(' ')
labellist = example.label
tokens = [... |
def get_score(submission_folder='../env'):
submission_path = os.path.join(submission_folder, 'submission.csv')
submission = pd.read_csv(submission_path)
test_data = pd.read_csv('answer.csv')
mae = (sum(abs((submission['SalePrice'] - test_data['SalePrice']))) / len(test_data['SalePrice']))
return mae |
def find_incoming_edges(node, dfg):
if isinstance(dfg, SDFG):
result = []
for state in dfg.nodes():
result.extend(list(state.in_edges(node)))
return result
else:
return list(dfg.in_edges(node)) |
class InPlaceABNSyncWrapper(nn.Module):
def __init__(self, *args, **kwargs):
super(InPlaceABNSyncWrapper, self).__init__()
self.bn = InPlaceABNSync(*args, **kwargs)
def forward(self, input):
return self.bn(input) |
def test_plot_lcs():
model_dir = (dir_path + 'models/')
model_files = [e for e in Path(model_dir).glob('*/*.pt')]
for mf in model_files:
cmd = f'python run.py --plot_lcs --dump_dir tests/dump/ --model_files {mf}'
call_cmd(cmd) |
class ResNet(nn.Module):
def __init__(self, last_stride=2, block=Bottleneck, layers=(3, 4, 6, 3)):
super().__init__()
self.inplanes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.maxpool = nn.MaxPool2d(ker... |
def run_zeroshot(fw_name, quesion_json, article_json, model, gpu, retriver='None'):
if (not os.path.exists(fw_name)):
if (retriver == 'bm25'):
print('Use BM25 retrieved dialogue')
retrieved = json.load(open('../../retriever/output_retriever_rank_bm25.json'))
retrieve_arti... |
def pjit(fun: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[(int, Sequence[int])]=(), donate_argnums: Union[(int, Sequence[int])]=(), backend: Optional[str]=None):
del backend
return jax_pjit(fun, in_axis_resources, out_axis_resources, static_argnums=static_argnums, donate_argnums=donat... |
def get_world_size():
if ('WORLD_SIZE' in os.environ):
return int(os.environ['WORLD_SIZE'])
else:
if (not dist.is_available()):
return 1
if (not dist.is_initialized()):
return 1
return dist.get_world_size() |
def add_eval_lm_args(parser):
group = parser.add_argument_group('LM Evaluation')
add_common_eval_args(group)
group.add_argument('--output-word-probs', action='store_true', help='if set, outputs words and their predicted log probabilities to standard output')
group.add_argument('--output-word-stats', act... |
()
def test_information_retrieval_challenge_a(information_retrieval_agents: Agent, monkeypatch: pytest.MonkeyPatch, patched_api_requestor: MockerFixture, level_to_run: int, challenge_name: str) -> None:
information_retrieval_agent = information_retrieval_agents[(level_to_run - 1)]
run_interaction_loop(monkeypat... |
def detnet_fpn_backbone(backbone_name, pretrained):
backbone = detnet.__dict__[backbone_name](pretrained=pretrained)
in_channels_stage2 = (backbone.inplanes // 4)
in_channels_list = [in_channels_stage2, (in_channels_stage2 * 2), (in_channels_stage2 * 4), (in_channels_stage2 * 4), (in_channels_stage2 * 4)]
... |
def add_with_offset(index, data, offset, valids=None):
ids = ((np.arange(data.shape[0]) + offset) + index.ntotal)
if (valids is not None):
data = data[valids]
ids = ids[valids]
index.add_with_ids(data, ids) |
def _build(opt):
dpath = os.path.join(opt['datapath'], 'empatheticdialogues')
version = '1.1'
if (not build_data.built(dpath, version_string=version)):
print((('[building data: ' + dpath) + ']'))
if build_data.built(dpath):
build_data.remove_dir(dpath)
build_data.make_dir... |
def quat_from_two_vectors(v0: np.ndarray, v1: np.ndarray) -> np.quaternion:
v0 = (v0 / np.linalg.norm(v0))
v1 = (v1 / np.linalg.norm(v1))
c = v0.dot(v1)
if (c < ((- 1) + 1e-08)):
c = max(c, (- 1))
m = np.stack([v0, v1], 0)
(_, _, vh) = np.linalg.svd(m, full_matrices=True)
... |
.node
class Pgemm(dace.sdfg.nodes.LibraryNode):
implementations = {'MKLMPICH': ExpandPgemmMKLMPICH, 'MKLOpenMPI': ExpandPgemmMKLOpenMPI, 'ReferenceMPICH': ExpandPgemmReferenceMPICH, 'ReferenceOpenMPI': ExpandPgemmReferenceOpenMPI}
default_implementation = None
m = dace.properties.SymbolicProperty(allow_none... |
class TFAlbertForPreTraining(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class SpatialOffsetBlock(nn.Module):
def __init__(self, ch_in, ch_ref, ks):
super(SpatialOffsetBlock, self).__init__()
nhidden = 64
self.offset0 = SpatialOffset(ch_in, ks)
self.norm_ref = nn.InstanceNorm2d(ch_ref, affine=False)
def forward(self, x, ref):
x_sigma = torch.s... |
def add_weight_decay(weight_decay: float, filter_fn: Optional[FilterFn]=None) -> optax.GradientTransformation:
def init_fn(_) -> AddWeightDecayState:
return AddWeightDecayState()
def update_fn(updates: optax.Updates, state: AddWeightDecayState, params: optax.Params) -> Tuple[(optax.Updates, AddWeightDec... |
def test_pyro_bayesian_train_sample_mixin_with_local():
adata = synthetic_iid()
BayesianRegressionModel.setup_anndata(adata)
mod = BayesianRegressionModel(adata, per_cell_weight=True)
mod.train(max_epochs=2, batch_size=128, lr=0.01, train_size=1)
assert (list(mod.module.guide.state_dict()['locs.line... |
def coeff_repr(c):
try:
return c._latex_coeff_repr()
except AttributeError:
pass
if isinstance(c, (int, float)):
return str(c)
s = latex(c)
if ((s.find('+') != (- 1)) or (s.find('-') != (- 1))):
return ('(%s)' % s)
return s |
class FindDependenciesLdd():
def __init__(self):
self.cmd = ['ldd']
try:
st = call(self.cmd, stdout=PIPE, stderr=PIPE)
except OSError:
raise RuntimeError(('command %s cannot be run' % self.cmd))
def get_dependencies(self, file):
p = Popen((self.cmd + [file... |
def test_coverage_entry_add():
assert ((CoverageEntry(2, 1) + CoverageEntry(3, 7)) == CoverageEntry(5, 8)) |
def download_temp_file(url, local_path=None, untar=False):
if (local_path is None):
local_path = url.rsplit('/', 1)[(- 1)]
local_path = os.path.join(temp_directory(), local_path)
mkdir_p(os.path.dirname(local_path))
if (not os.path.isfile(local_path)):
print('Downloading {:s} to {:s}...'... |
def read_html_template(path):
with open(path) as f:
template = f.read()
return template |
def _iglob(path_glob):
rich_path_glob = RICH_GLOB.split(path_glob, 1)
if (len(rich_path_glob) > 1):
assert (len(rich_path_glob) == 3), rich_path_glob
(prefix, set, suffix) = rich_path_glob
for item in set.split(','):
for path in _iglob(''.join((prefix, item, suffix))):
... |
def main(install_dir):
INSTALLED_DIR = os.path.join(ROOT_DIR, install_dir)
if (not os.path.exists(INSTALLED_DIR)):
raise ValueError(f'Provided install dir {INSTALLED_DIR} does not exist')
scipy_test_files = get_test_files(SCIPY_DIR)
installed_test_files = get_test_files(INSTALLED_DIR)
for te... |
def tdm_td3_experiment(variant):
import railrl.samplers.rollout_functions as rf
import railrl.torch.pytorch_util as ptu
from railrl.data_management.obs_dict_replay_buffer import ObsDictRelabelingBuffer
from railrl.exploration_strategies.base import PolicyWrappedWithExplorationStrategy
from railrl.st... |
def download_coco(path, overwrite=False):
_DOWNLOAD_URLS = [(' '10ad623668ab00c62c096f0ed636d6aff41faca5'), (' '8551ee4bb5860311e79dace7e79cb91e432e78b3'), (' '4950dc9d00dbe1c933ee0170fd2a41')]
os.makedirs(path)
for (url, checksum) in _DOWNLOAD_URLS:
filename = download(url, path=path, overwrite=ove... |
def test_case5():
url = (brokerIp + '/ngsi-ld/v1/entities/')
headers = {'Content-Type': 'application/json', 'Accept': 'application/ld+json'}
r = requests.post(url, data=json.dumps(ld_data.subdata5), headers=headers)
print(r.status_code)
assert (r.status_code == 201) |
_utils.test()
def test_parent_exceeded():
val = ti.field(ti.f32)
m = 7
n = 3
blk1 = ti.root.dense(ti.i, m)
blk2 = blk1.dense(ti.j, n)
blk2.place(val)
assert (val.snode.parent() == blk2)
assert (val.snode.parent(2) == blk1)
assert (val.snode.parent(3) == ti.root)
assert (val.snode... |
def SGD_S2(W_2, Y, V, S_2, gamma):
V = V.T
return (gamma * (S_2.dot(np.transpose(V)) - W_2.dot(Y)).dot(V)) |
def func_set_import_onnx_opset(opset):
opset = opset[len('opset_'):]
target_func_list = []
source_func_list = []
for (nnabla_func, impl_funcs) in _onnx_func_info.items():
for onnx_func in impl_funcs:
_opset = onnx_func.split('')[1]
if (_opset <= opset):
ta... |
def two_layer(x, FLAGS):
x_ravel = tf.reshape(x, [(- 1), FLAGS['dimension']])
W_fc1 = weight_variable('W_fc1', [FLAGS['dimension'], FLAGS['num_hidden']])
b_fc1 = bias_variable('b_fc1', [FLAGS['num_hidden']])
W = tf.get_variable('W_fc2', initializer=tf.truncated_normal([FLAGS['num_hidden'], FLAGS['num_cl... |
def get_loaders(dataset, label_class, batch_size):
if (dataset in ['cifar10', 'fashion']):
if (dataset == 'cifar10'):
ds = torchvision.datasets.CIFAR10
transform = transform_color
coarse = {}
trainset = ds(root='data', train=True, download=True, transform=tran... |
class KernelLossBase():
def __init__(self, quantum_kernel: KernelMatrixBase) -> None:
self._quantum_kernel = quantum_kernel
def compute(self):
raise NotImplementedError |
class BLEURTAligner(Aligner):
def __init__(self, aggr_type, checkpoint, device, *args, **kwargs):
Aligner.__init__(self, aggr_type=None)
state_dict = torch.load(checkpoint)
config = transformers.BertConfig()
bleurt_model = BleurtModel(config)
bleurt_model.load_state_dict(stat... |
class Set_object_binary(Set_object, metaclass=ClasscallMetaclass):
def __classcall__(cls, X, Y, *args, **kwds):
if (not isinstance(X, Set_object)):
X = Set(X)
if (not isinstance(Y, Set_object)):
Y = Set(Y)
return type.__call__(cls, X, Y, *args, **kwds)
def __init_... |
class NRTRModalityTransform(nn.Module):
def __init__(self, input_channels=3, input_height=32):
super().__init__()
self.conv_1 = nn.Conv2d(in_channels=input_channels, out_channels=32, kernel_size=3, stride=2, padding=1)
self.relu_1 = nn.ReLU(True)
self.bn_1 = nn.BatchNorm2d(32)
... |
def test_regulararray_localindex():
v2_array = ak.operations.from_numpy(np.arange(((2 * 3) * 5)).reshape(2, 3, 5), regulararray=True, highlevel=False)
assert (to_list(ak._do.local_index(v2_array, 0)) == [0, 1])
assert (ak._do.local_index(v2_array.to_typetracer(), 0).form == ak._do.local_index(v2_array, 0).f... |
def get_kernelf(config, context={}):
return _from_config(config, classes=classes, context=context) |
def floyd_warshall(A):
n = A.shape[0]
D = np.zeros((n, n), dtype=np.int16)
for i in range(n):
for j in range(n):
if (i == j):
pass
elif (A[(i, j)] == 0):
D[(i, j)] = 510
else:
D[(i, j)] = 1
for k in range(n):
... |
def adjust_pixel_dataset2(hi, wi, H, W):
wi = (W - wi)
if (wi < 0):
wi = (wi + W)
return (hi, wi) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.