code stringlengths 101 5.91M |
|---|
class Reference(metaclass=ABCMeta):
def __init__(self, typ: ProperType) -> None:
self._type = typ
def type(self) -> ProperType:
return self._type
def is_primitive(self) -> bool:
return self.type.accept(is_primitive_type)
def is_none_type(self) -> bool:
return isinstance(s... |
class resnet99_avg(nn.Module):
def __init__(self, num_classes=9):
super(resnet99_avg, self).__init__()
self.conv1a = nn.Conv2d(103, 32, kernel_size=3, stride=1, padding=0, groups=1)
self.conv1b = nn.Conv2d(103, 32, kernel_size=3, stride=1, padding=0, groups=1)
self.bn1 = nn.BatchNorm... |
def _get_RFCN_head(is_train, ft_map, rois, num_classes):
num_rfcn_chn = 512
S = 7
conv_new_1 = mx.sym.Convolution(data=ft_map, kernel=(1, 1), num_filter=num_rfcn_chn, name='conv_new_1', lr_mult=3.0)
relu_new_1 = mx.sym.Activation(data=conv_new_1, act_type='relu', name='conv_new_1_relu')
rfcn_cls = m... |
def process_vlsp22(paths, dataset_name, *args):
assert ((dataset_name == 'vi_vlsp22') or (dataset_name == 'vi_vlsp23'))
if (dataset_name == 'vi_vlsp22'):
default_subdir = 'VLSP_2022'
default_make_test_split = False
updated_tagset = False
elif (dataset_name == 'vi_vlsp23'):
de... |
def read_fasta_yield(f):
(name, seq) = ('', '')
count = 0
while True:
line = f.readline()
if (not line):
break
if ('>' == line[0]):
if ((0 != count) or ((0 == count) and (seq != ''))):
if is_fasta(Seq(name, seq, count)):
(yi... |
def get_grammatical_function(attributes):
tree = attributes['parse_tree']
parent = tree.parent()
if (parent is None):
return 'OTHER'
else:
parent_label = parent.label()
if re.match('^(S|FRAG)', parent_label):
return 'SUBJECT'
elif re.match('VP', parent_label):... |
def hamming_calc(TP, POP):
try:
length = POP
return ((1 / length) * (length - sum(TP.values())))
except Exception:
return 'None' |
def train(model, loader, optimizer):
model.train()
for (batch, *args) in loader:
batch = batch.to(model.device)
optimizer.zero_grad()
out = model(batch.x, batch.adj_t, *args)
train_mask = batch.train_mask[:out.size(0)]
loss = criterion(out[train_mask], batch.y[:out.size(0... |
def add_compare_with_cpu_command(subparsers):
subparser = subparsers.add_parser('compare_with_cpu', help='Compare performance between two nntxt.')
subparser.add_argument('-c', '--config', help='path to nntxt', required=True)
subparser.add_argument('-c2', '--config2', help='path to cpu nntxt', required=True)... |
def setup_args():
parser = argparse.ArgumentParser()
parser.add_argument('--seed', type=int, default=9, help='seed for reproducibility')
parser.add_argument('--base_dir', type=str, default='rule_classifier_data/val', help='base directory for the data')
parser.add_argument('--proj_name', type=str, defaul... |
class Mish_VGG(nn.Module):
def __init__(self, vgg_name):
super(Mish_VGG, self).__init__()
self.features = self._make_layers(cfg[vgg_name])
self.classifier = nn.Linear(512, 10)
def forward(self, x):
out = self.features(x)
out = out.view(out.size(0), (- 1))
out = se... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [313])
.parametrize('prob', [0.7, 1.0])
.parametrize('area_ratios', [(0.02, 0.04)])
.parametrize('aspect_ratios', [(0.3, 3.3333)])
.parametrize('replacements', [(2.0, 2.0), (3.0, 4.0)])
.parametrize('n', [1, 3])
.parametrize('share', [True, False])
.parametrize(... |
_kl(Beta, Normal)
def _kl_beta_normal(p, q):
E_beta = (p.concentration1 / (p.concentration1 + p.concentration0))
var_normal = q.scale.pow(2)
t1 = (- p.entropy())
t2 = (0.5 * ((var_normal * 2) * math.pi).log())
t3 = ((((E_beta * (1 - E_beta)) / ((p.concentration1 + p.concentration0) + 1)) + E_beta.po... |
class OfflineRLAlgorithm(object, metaclass=abc.ABCMeta):
def __init__(self, trainer, evaluation_policy, evaluation_env, evaluation_data_collector, replay_buffer, batch_size, max_path_length, num_epochs, num_eval_steps_per_epoch, num_trains_per_train_loop, num_train_loops_per_epoch=1, save_snapshot_freq=1000):
... |
def vgg19_bn(pretrained: bool=False, progress: bool=True, **kwargs: Any) -> VGG:
return _vgg('vgg19_bn', 'E', True, pretrained, progress, **kwargs) |
class BatchUpdateParameterServer(object):
def __init__(self, batch_update_size):
self.model = nn.Linear(in_features, out_features)
self.lock = threading.Lock()
self.future_model = torch.futures.Future()
self.batch_update_size = batch_update_size
self.curr_update_size = 0
... |
def get_extensions():
this_dir = os.path.dirname(os.path.abspath(__file__))
extensions_dir = os.path.join(this_dir, 'maskrcnn', 'csrc')
main_file = glob.glob(os.path.join(extensions_dir, '*.cpp'))
source_cpu = glob.glob(os.path.join(extensions_dir, 'cpu', '*.cpp'))
source_cuda = glob.glob(os.path.jo... |
class SpkIdBrain(sb.Brain):
def compute_forward(self, batch, stage):
batch = batch.to(self.device)
(feats, lens) = self.prepare_features(batch.sig, stage)
embeddings = self.modules.embedding_model(feats, lens)
predictions = self.modules.classifier(embeddings)
return predictio... |
class PyTestChromosomeToAstVisitor(cv.ChromosomeVisitor):
def __init__(self) -> None:
self._module_aliases = ns.NamingScope('module')
self._common_modules: set[str] = set()
self._conversion_results: list[_AstConversionResult] = []
def module_aliases(self) -> ns.NamingScope:
retur... |
class NewUsersSplitter(Splitter):
_init_arg_names = ['test_size', 'drop_cold_items', 'query_column', 'item_column', 'timestamp_column', 'session_id_column', 'session_id_processing_strategy']
def __init__(self, test_size: float, drop_cold_items: bool=False, query_column: str='query_id', item_column: Optional[str... |
class PretrainedWav2VecModel(nn.Module):
def __init__(self, fname):
super().__init__()
device = torch.device('cpu')
checkpoint = torch.load(fname, map_location=device)
self.args = checkpoint['args']
model = Wav2VecModel.build_model(self.args, None)
model.load_state_di... |
class StateFusion(transformation.MultiStateTransformation):
first_state = transformation.PatternNode(sdfg.SDFGState)
second_state = transformation.PatternNode(sdfg.SDFGState)
def annotates_memlets():
return False
def expressions(cls):
return [sdutil.node_path_graph(cls.first_state, cls.s... |
class PlanarPoincareParticle(object):
def __init__(self, m, M, l, gamma, G=1.0, sLambda=None, sGamma=None, Lambda=None, Gamma=None, a=None, e=None):
if (not single_true([sLambda, Lambda, a])):
raise AttributeError('Can only pass one of Lambda, sLambda (specific Lambda, i.e. per unit mass), or a ... |
def test_archive_reuse_case_factory_get_chromosome_mutation_count():
test_case_chromosome_factory = MagicMock(tccf.TestCaseChromosomeFactory)
archive = MagicMock()
chromosome_from_archive = MagicMock()
clone_chromosome_from_archive = MagicMock()
chromosome_from_archive.clone.return_value = clone_chr... |
class Vocabulary():
default_implementation = 'default'
def __init__(self, counter: Dict[(str, Dict[(str, int)])]=None, min_count: Dict[(str, int)]=None, max_vocab_size: Union[(int, Dict[(str, int)])]=None, non_padded_namespaces: Iterable[str]=DEFAULT_NON_PADDED_NAMESPACES, pretrained_files: Optional[Dict[(str, ... |
def compute_histogram_entropy(histograms: torch.Tensor) -> torch.Tensor:
assert (histograms.ndim == 2), f'Wrong shape: {histograms.shape}'
probs = (histograms / histograms.sum(dim=1, keepdim=True))
return ((- 1.0) * (torch.log((probs + 1e-12)) * probs).sum(dim=1)) |
class WaitPrint(threading.Thread):
def __init__(self, t, message):
super().__init__()
self.t = t
self.message = message
self.running = True
def stop(self):
self.running = False
def run(self):
for _ in range(int((self.t // 0.1))):
time.sleep(0.1)
... |
def box_iou_rotated(bboxes1, bboxes2, mode='iou', aligned=False):
assert (mode in ['iou', 'iof'])
mode_dict = {'iou': 0, 'iof': 1}
mode_flag = mode_dict[mode]
rows = bboxes1.size(0)
cols = bboxes2.size(0)
if aligned:
ious = bboxes1.new_zeros(rows)
else:
ious = bboxes1.new_zer... |
def static_loaders(paths, batch_size: int, seed: int=None, areas: list=None, layers: list=None, tier: str=None, neuron_ids: list=None, neuron_n: int=None, exclude_neuron_n=0, neuron_base_seed=None, image_ids=None, image_n=None, image_base_seed=None, cuda: bool=True, normalize: bool=True, include_behavior: bool=False, a... |
class TestGLPKExactBackend(GenericBackendTests):
def backend(self) -> GenericBackend:
return MixedIntegerLinearProgram(solver='GLPK/exact').get_backend() |
def read_point_ply(filename):
pd = PlyData.read(filename)['vertex']
v = np.array(np.stack([pd[i] for i in ['x', 'y', 'z']], axis=(- 1)))
try:
n = np.array(np.stack([pd[i] for i in ['nx', 'ny', 'nz']], axis=(- 1)))
except:
print(f'warning: cannot find normals in file {filename}')
... |
class BertTokenizationTest(CommonTestCases.CommonTokenizerTester):
tokenizer_class = BertTokenizer
def setUp(self):
super(BertTokenizationTest, self).setUp()
vocab_tokens = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest']
self.vocab... |
def cal_true_positive_char(pred, gt):
all_opt = SequenceMatcher(None, pred, gt)
true_positive_char_num = 0
for (opt, _, _, s2, e2) in all_opt.get_opcodes():
if (opt == 'equal'):
true_positive_char_num += (e2 - s2)
else:
pass
return true_positive_char_num |
def normal_init(module, mean=0, std=1, bias=0):
nn.init.normal_(module.weight, mean, std)
if hasattr(module, 'bias'):
nn.init.constant_(module.bias, bias) |
def test_obj_func_returns_scalar():
match = 'The user-provided objective function must return a scalar value.'
with assert_raises(ValueError, match=match):
optimize.minimize((lambda x: x), np.array([1, 1])) |
def _kmeans_single_elkan(X, sample_weight, centers_init, max_iter=300, verbose=False, tol=0.0001, n_threads=1):
n_samples = X.shape[0]
n_clusters = centers_init.shape[0]
centers = centers_init
centers_new = np.zeros_like(centers)
weight_in_clusters = np.zeros(n_clusters, dtype=X.dtype)
labels = ... |
def setup_args_gpu(args):
if ((args.local_rank == (- 1)) or args.no_cuda):
device = torch.device(('cuda' if (torch.cuda.is_available() and (not args.no_cuda)) else 'cpu'))
args.n_gpu = torch.cuda.device_count()
else:
torch.cuda.set_device(args.local_rank)
device = torch.device('c... |
def find_images_and_targets(folder, types=IMG_EXTENSIONS, class_to_idx=None, leaf_name_only=True, sort=True):
labels = []
filenames = []
for (root, subdirs, files) in os.walk(folder, topdown=False):
rel_path = (os.path.relpath(root, folder) if (root != folder) else '')
label = (os.path.basen... |
class ContinuousMLPQFunction(QFunction):
def __init__(self, env_spec, name='ContinuousMLPQFunction', hidden_sizes=(32, 32), action_merge_layer=(- 2), hidden_nonlinearity=tf.nn.relu, hidden_w_init=tf.glorot_uniform_initializer(), hidden_b_init=tf.zeros_initializer(), output_nonlinearity=None, output_w_init=tf.glorot... |
def get_list_of_files(path_or_repo: Union[(str, os.PathLike)], revision: Optional[str]=None, use_auth_token: Optional[Union[(bool, str)]]=None, local_files_only: bool=False) -> List[str]:
path_or_repo = str(path_or_repo)
if os.path.isdir(path_or_repo):
list_of_files = []
for (path, dir_names, fi... |
def format_message(message, status_message):
timestamp = datetime.now().strftime(u'%x %X')
left_delim = (u'<' if status_message else u'')
right_delim = (u'>' if status_message else u'')
return u'[{}] {}{}{}'.format(timestamp, left_delim, message, right_delim) |
class RuleSuperRSK(RuleRSK):
def to_pairs(self, obj1=None, obj2=None, check=True):
from sage.combinat.shifted_primed_tableau import PrimedEntry
itr = None
if (obj2 is None):
try:
itr = obj1._rsk_iter()
except AttributeError:
(obj2, obj1... |
class CUBDataset(Dataset):
def __init__(self, root, cfg, is_train):
self.root = root
self.cfg = cfg
self.is_train = is_train
self.resize_size = cfg.DATA.RESIZE_SIZE
self.crop_size = cfg.DATA.CROP_SIZE
self.image_list = self.remove_1st_column(open(os.path.join(root, 'i... |
def test_graphsage_save_load(tmpdir):
gs = GraphSAGE(layer_sizes=[4, 4], n_samples=[2, 2], input_dim=2, multiplicity=1)
test_utils.model_save_load(tmpdir, gs) |
class CleanEvaluation():
def __init__(self, probabilities, labels, validation=0.1):
assert (validation >= 0)
labels = numpy.squeeze(labels)
assert (len(labels.shape) == 1)
assert (len(probabilities.shape) == 2)
assert (probabilities.shape[0] == labels.shape[0])
assert... |
def test_multiple_rhs():
random = np.random.RandomState(1234)
c = random.randn(4)
r = random.randn(4)
for offset in [0, 1j]:
for yshape in ((4,), (4, 3), (4, 3, 2)):
y = (random.randn(*yshape) + offset)
actual = solve_toeplitz((c, r), b=y)
desired = solve(toep... |
def test_read_file_not_found(agent: Agent):
filename = 'does_not_exist.txt'
content = file_ops.read_file(filename, agent=agent)
assert (('Error:' in content) and (filename in content) and ('no such file' in content)) |
def expected_num_cache_files(num_kernels: int=0) -> int:
if (num_kernels == 0):
return 0
return (num_kernels + 1) |
def test_option_integer():
result = ak.operations.from_json(' [ 1 ,2,null,4, 5]', schema={'type': 'array', 'items': {'type': ['null', 'integer']}})
assert (result.to_list() == [1, 2, None, 4, 5])
assert (str(result.type) == '5 * ?int64')
result = ak.operations.from_json((' [ 1 ,2,null,4, 5]' * 2), schem... |
_cache(maxsize=16384)
def symstr(sym, arrayexprs: Optional[Set[str]]=None, cpp_mode=False) -> str:
if isinstance(sym, SymExpr):
return symstr(sym.expr, arrayexprs, cpp_mode=cpp_mode)
try:
sym = sympy_numeric_fix(sym)
sym = sympy_intdiv_fix(sym)
sym = sympy_divide_fix(sym)
... |
def get_world_size():
return (torch.distributed.get_world_size() if torch.distributed.is_initialized() else 1) |
def train_segmentor(model, dataset, cfg, distributed=False, validate=False, timestamp=None, meta=None):
logger = get_root_logger(cfg.log_level)
dataset = (dataset if isinstance(dataset, (list, tuple)) else [dataset])
data_loaders = [build_dataloader(ds, cfg.data.samples_per_gpu, cfg.data.workers_per_gpu, le... |
class Res2Layer(Sequential):
def __init__(self, block, inplanes, planes, num_blocks, stride=1, avg_down=True, conv_cfg=None, norm_cfg=dict(type='BN'), scales=4, base_width=26, **kwargs):
self.block = block
downsample = None
if ((stride != 1) or (inplanes != (planes * block.expansion))):
... |
class InstrumentationFinder(MetaPathFinder):
_logger = logging.getLogger(__name__)
def __init__(self, original_pathfinder, module_to_instrument: str, tracer: ExecutionTracer, coverage_metrics: set[config.CoverageMetric], dynamic_constant_provider: (DynamicConstantProvider | None)=None) -> None:
self._mo... |
def test_reduceat():
db = np.dtype([('name', 'S11'), ('time', np.int64), ('value', np.float32)])
a = np.empty([100], dtype=db)
a['name'] = 'Simple'
a['time'] = 10
a['value'] = 100
indx = [0, 7, 15, 25]
h2 = []
val1 = indx[0]
for val2 in indx[1:]:
h2.append(np.add.reduce(a['va... |
class GeneralizedMatrixFactorizationModel(keras.Model):
def __init__(self, num_users, num_items, embed_mf_size, is_edge_weight_train, learning_rate=0.01, name='GeneralizedMatrixFactorizationModel', **kwargs):
super().__init__(name=name, **kwargs)
tf.random.set_seed(42)
self.num_users = num_u... |
class DummyOffPolicyAlgo(RLAlgorithm):
def init_opt(self):
def train(self, runner):
def train_once(self, itr, paths):
def optimize_policy(self, samples_data): |
def test_seterr():
entry_err = sc.geterr()
try:
for (category, error_code) in _sf_error_code_map.items():
for action in _sf_error_actions:
geterr_olderr = sc.geterr()
seterr_olderr = sc.seterr(**{category: action})
assert_((geterr_olderr == set... |
class VGGTransformerEncoderTest(TestFairseqEncoderBase):
def setUp(self):
super().setUp()
self.setUpInput(get_dummy_input(T=50, D=80, B=5))
def test_forward(self):
print('1. test standard vggtransformer')
self.setUpEncoder(VGGTransformerEncoder(input_feat_per_channel=80))
... |
.experimental
def test_check_df_errors(data_preparator, long_log_with_features, mapping):
with pytest.raises(ValueError, match='DataFrame is empty'):
data_preparator.check_df(dataframe=long_log_with_features.filter((sf.col('user_idx') > 10)), columns_mapping=mapping)
with pytest.raises(ValueError, match... |
class Timer(object):
_TIMERS = dict()
def __init__(self, name):
self._name = name
self.__tic_time = None
self.__total_duration = 0.0
def __enter__(self):
self.tic()
def __exit__(self, exc_type, exc_val, exc_tb):
self.toc()
def tic(self):
assert (self._... |
def test_ipw_learner_create_train_data_for_opl():
context = np.array([1.0, 1.0]).reshape(1, (- 1))
learner = IPWLearner(n_actions=2)
action = np.array([0])
reward = np.array([1.0])
pscore = np.array([0.5])
(X, sample_weight, y) = learner._create_train_data_for_opl(context=context, action=action,... |
def main():
tool_thoughts = DataLoader.from_args(args, item_name='toolkit thought')
format_example = read_file(args.format_example_file)
output_file = f'{osp.splitext(tool_thoughts._input_path)[0]}_spec.jsonl'
if (generator._stop_at in ['preprocess', 'prompt']):
result = generator(dict(example_t... |
def _calculate_asv_score(model, file_list, gt_root, trgspk, threshold):
results = {}
for (i, cvt_wav_path) in enumerate(tqdm(file_list)):
basename = get_basename(cvt_wav_path)
number = get_number(basename)
gt_wav_path = os.path.join(gt_root, trgspk, (number + '.wav'))
results[bas... |
def test_detect_action_size_from_env() -> None:
env: Union[(gym.Env[(Any, Any)], gymnasium.Env[(Any, Any)])] = gym.make('CartPole-v1')
assert (detect_action_size_from_env(env) == 2)
env = gym.make('Pendulum-v1')
assert (detect_action_size_from_env(env) == 1)
env = gymnasium.make('CartPole-v1')
a... |
def conv1x1(in_channels, out_channels, stride=1):
return nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, padding=0, bias=True) |
def parameter_table(model):
table = PrettyTable(['Modules', 'Parameters'])
total = 0
for (name, parameter) in model.named_parameters():
if (not parameter.requires_grad):
continue
params = parameter.numel()
table.add_row([name, params])
total += params
table.ad... |
def determine_repayment(rng, group, score):
repayment_rate = ((LOAN_REPAY_PROBS[0](score) ** (1 - group)) * (LOAN_REPAY_PROBS[1](score) ** group))
uniform = rng.uniform()
return ((np.log((repayment_rate / (1.0 - repayment_rate))) + np.log((uniform / (1.0 - uniform)))) > 0.0) |
def centroid(vectors: List[np.array]) -> np.array:
centroid = np.stack(vectors).mean(axis=0)
return centroid |
def test_tie_breaking_sample_order_invariance():
vec = CountVectorizer(max_features=1)
vocab1 = vec.fit(['hello', 'world']).vocabulary_
vocab2 = vec.fit(['world', 'hello']).vocabulary_
assert (vocab1 == vocab2) |
class Ibgp(Layer, Graphable):
__masked: Set[int]
def __init__(self):
super().__init__()
self.__masked = set()
self.addDependency('Ospf', False, False)
def __dfs(self, start: Node, visited: List[Node], netname: str='self'):
if (start in visited):
return
sel... |
class Dstc8DataProcessor(object):
def __init__(self, dstc8_data_dir, dataset_config, vocab_file, do_lower_case, max_seq_length=DEFAULT_MAX_SEQ_LENGTH, log_data_warnings=False):
self.dstc8_data_dir = dstc8_data_dir
self._log_data_warnings = log_data_warnings
self._dataset_config = dataset_con... |
def paint(t: ti.f32, tex: ti.types.texture(num_dimensions=2), n: ti.i32):
for (i, j) in pixels:
uv = ti.Vector([(i / res[0]), (j / res[1])])
warp_uv = (uv + (ti.Vector([ti.cos((t + (uv.x * 5.0))), ti.sin((t + (uv.y * 5.0)))]) * 0.1))
c = ti.math.vec4(0.0)
if (uv.x > 0.5):
... |
_node_type()
class Sum(optplan.Function):
type = schema_utils.polymorphic_model_type('function.sum')
functions = types.ListType(optplan.ReferenceType(optplan.Function), default=[])
def __add__(self, obj):
if isinstance(obj, Sum):
return Sum(functions=(self.functions + obj.functions))
... |
class DeepGuidedFilter(nn.Module):
def __init__(self, radius=1, eps=1e-08):
super(DeepGuidedFilter, self).__init__()
self.lr = build_lr_net()
self.gf = FastGuidedFilter(radius, eps)
def forward(self, x_lr, x_hr):
return self.gf(x_lr, self.lr(x_lr), x_hr).clamp(0, 1)
def init_... |
def get_discriminator_optimizer():
module = discriminator_dict[FLAGS.g_model_name.lower()]
(hw, c, nlabel) = hw_dict[FLAGS.dataset.lower()]
D = module(z_dim=FLAGS.d_z_dim, n_label=nlabel, im_size=hw, im_chan=c, embed_size=FLAGS.d_embed_size, nfilter=FLAGS.d_nfilter, nfilter_max=FLAGS.d_nfilter_max, actvn=ac... |
def test_test_case_to_ast_once(simple_test_case):
visitor = tc_to_ast.TestCaseToAstVisitor(ns.NamingScope('module'), set())
simple_test_case.accept(visitor)
simple_test_case.accept(visitor)
assert (ast.unparse(ast.fix_missing_locations(Module(body=visitor.test_case_ast, type_ignores=[]))) == 'int_0 = 5\... |
.parametrize('csr_container', CSR_CONTAINERS)
def test_dbscan_input_not_modified_precomputed_sparse_nodiag(csr_container):
X = np.random.RandomState(0).rand(10, 10)
np.fill_diagonal(X, 0)
X = csr_container(X)
assert all(((row != col) for (row, col) in zip(*X.nonzero())))
X_copy = X.copy()
dbscan... |
def __starts_with(anaphor_cleaned_tokens, antecedent_cleaned_tokens):
for (ana_token, ante_token) in zip(anaphor_cleaned_tokens, antecedent_cleaned_tokens):
if (ana_token != ante_token):
return False
return True |
_pipeline_test
class CustomPipelineTest(unittest.TestCase):
def test_warning_logs(self):
transformers_logging.set_verbosity_debug()
logger_ = transformers_logging.get_logger('transformers.pipelines.base')
alias = 'text-classification'
(_, original_task, _) = PIPELINE_REGISTRY.check_t... |
def changeBipartiteEgoTwoStar(mode, G, A, i):
return (changeStatisticsALAAM.changeTwoStar(G, A, i) if (G.bipartite_node_mode(i) == mode) else 0) |
def get_dataset(split_name='train', **kwargs):
datasets = [get_single_dataset(name='dicta_sign', **kwargs)]
all_data = list(chain.from_iterable([d.data for d in datasets]))
return PoseTextDataset(TextPoseDataset(all_data), split=split_name) |
def bold_extreme_values(data, data_max=(- 1), col_name=None):
(data, err) = data
if (data == err == 0.0):
return '---'
if (data == data_max):
bold = True
else:
bold = False
if ('QD score' in col_name):
if np.isnan(data):
data = np.nan
else:
... |
def mockingjay_100hr(refresh=False, *args, **kwargs):
return mockingjay_logMelBase_T_AdamW_b32_200k_100hr(*args, refresh=refresh, **kwargs) |
def test_validation(skip_remote, dataset):
if (dataset is None):
pytest.skip()
(missing_files, invalid_checksums) = dataset.validate(verbose=True)
assert (missing_files == {key: {} for key in dataset._index.keys() if (not (key == 'version'))})
assert (invalid_checksums == {key: {} for key in dat... |
class ATAE_LSTM(nn.Module):
def __init__(self, embedding_matrix, opt):
super(ATAE_LSTM, self).__init__()
self.opt = opt
self.embed = nn.Embedding.from_pretrained(torch.tensor(embedding_matrix, dtype=torch.float))
self.squeeze_embedding = SqueezeEmbedding()
self.lstm = Dynamic... |
class PReLU_MobileNet(nn.Module):
cfg = [64, (128, 2), 128, (256, 2), 256, (512, 2), 512, 512, 512, 512, 512, (1024, 2), 1024]
def __init__(self, num_classes=10):
super(PReLU_MobileNet, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False)
self.bn... |
def main(command_line=0):
args = sys.argv[1:]
any_failures = 0
if command_line:
from .CmdLine import parse_command_line
(options, sources) = parse_command_line(args)
else:
options = CompilationOptions(default_options)
sources = args
if options.show_version:
sy... |
def test_ricci_community_all_possible_clusterings():
G = nx.karate_club_graph()
for (n1, n2, d) in G.edges(data=True):
d.clear()
orc = OllivierRicci(G, exp_power=1, alpha=0.5)
orc.compute_ricci_flow(iterations=40)
cc = orc.ricci_community_all_possible_clusterings()
cuts = [x[0] for x in ... |
def rnn_helper(inp, length, cell_type=None, direction='forward', name=None, *args, **kwargs):
assert (cell_type is not None)
rnn_func = None
if (cell_type == 'lstm'):
rnn_func = lstm_layer
assert (rnn_func is not None)
assert (direction in ['forward', 'backward', 'bidirectional'])
with t... |
def register_Ns3AodvRoutingTableEntry_methods(root_module, cls):
cls.add_constructor([param('ns3::aodv::RoutingTableEntry const &', 'arg0')])
cls.add_constructor([param('ns3::Ptr< ns3::NetDevice >', 'dev', default_value='0'), param('ns3::Ipv4Address', 'dst', default_value='ns3::Ipv4Address()'), param('bool', 'v... |
def find_backward_implementation(forward_sdfg: SDFG, forward_state: SDFGState, node: nd.Node) -> typing.Optional[BackwardImplementation]:
valid_impls = []
for (impl, args) in BackwardImplementation.extensions().items():
if ('name' not in args):
raise ValueError(f'Expected name in arguments o... |
def generate_ccp_dataset(args):
args.data_root = Path(args.data_root)
args.img_root = (args.data_root / 'photos')
args.pix_ann_root = ((args.data_root / 'annotations') / 'pixel-level')
args.img_ann_root = ((args.data_root / 'annotations') / 'image-level')
args.pix_ann_ids = get_ann_ids(args.pix_ann_... |
def test_update_user(testdir):
testdir.make_petstore_test('\(method="PUT", endpoint="/user/{username}$")\(max_examples=5, deadline=None)\ndef test_(request, case):\n request.config.HYPOTHESIS_CASES += 1\n assert_str(case.path_parameters["username"])\n assert isinstance(case.body, dict)\n assert_requests... |
class ZeroLayer(MyModule):
def __init__(self, stride):
super(ZeroLayer, self).__init__()
self.stride = stride
def forward(self, x):
raise ValueError
def module_str(self):
return 'Zero'
def config(self):
return {'name': ZeroLayer.__name__, 'stride': self.stride}
... |
((device_cc() < 80), 'Device compute capability is insufficient for SM80 tests.')
class Conv2dWgradImplicitGemmF16nhwcF16nhwcF32nhwcTensorOpF32SM80(unittest.TestCase):
def test_Device_Conv2d_Wgrad_Analytic_ImplicitGemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32(self):
math_inst = MathInstruction(instruction_shap... |
class TransformerEncoderLayerImproved(Module):
def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation='relu', d_global2=None):
super(TransformerEncoderLayerImproved, self).__init__()
self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
if (d_global2 ... |
def test_java_options_default_empty():
parser = _get_command_line_parser(['valid-detector'], [], [])
result = parser.parse_args(['run', 'ex1', 'valid-detector'])
assert_equals([], result.java_options) |
class PositionwiseFeedForward(nn.Module):
def __init__(self, d_model: int, d_ff: Optional[int]=128):
super().__init__()
self._linear1 = nn.Linear(d_model, d_ff)
self._linear2 = nn.Linear(d_ff, d_model)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return self._linear2(F.rel... |
def test_ListArray_nbytes():
np_starts = np.array([4, 100, 1])
np_stops = np.array([7, 100, 3, 200])
np_content = np.array([6.6, 4.4, 5.5, 7.7, 3.3, 2.2, 1.1, 8.8])
array = ak.contents.listarray.ListArray(ak.index.Index(np_starts), ak.index.Index(np_stops), ak.contents.numpyarray.NumpyArray(np_content))... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.