code stringlengths 101 5.91M |
|---|
class OrderedSetPartition(ClonableArray, metaclass=InheritComparisonClasscallMetaclass):
def __classcall_private__(cls, parts=None, from_word=None, check=True):
if ((parts is None) and (from_word is None)):
P = OrderedSetPartitions([])
return P.element_class(P, [])
W = Words(... |
class Normalize(object):
def __init__(self, mean, std, inplace=False):
self.mean = mean
self.std = std
self.inplace = inplace
def __call__(self, tensor):
return F.normalize(tensor, self.mean, self.std, self.inplace)
def __repr__(self):
return (self.__class__.__name__ ... |
def group_dicts_by_first_key(list_of_dicts: List[Dict[(str, float)]]) -> Dict[(str, List[Dict[(str, float)]])]:
first_key = get_first_key_of_dictionary(list_of_dicts[0])
final_grouped = defaultdict(list)
for inner_dict in list_of_dicts:
final_grouped[inner_dict[first_key]].append(inner_dict)
ret... |
def yield_top_down_sequence(tree, transition_scheme=TransitionScheme.TOP_DOWN_UNARY):
if tree.is_preterminal():
(yield Shift())
return
if tree.is_leaf():
return
if (transition_scheme is TransitionScheme.TOP_DOWN_UNARY):
if (len(tree.children) == 1):
labels = []
... |
def run_export_bbox_cams(args, cfg, data_dict, save_path=None):
verbose = (args.block_num <= 1)
if verbose:
print('Export bbox and cameras...')
if (save_path is None):
save_path = args.export_bbox_and_cams_only
(xyz_min, xyz_max) = compute_bbox_by_cam_frustrm(args=args, cfg=cfg, **data_d... |
class DIPNet(nn.Module):
def __init__(self, depth, base, decoder_block_num, norm=nn.InstanceNorm3d, encoder_norm=nn.Identity, use_skip=False):
super(DIPNet, self).__init__()
self.encoder = CNNEncoder(depth, base, encoder_norm)
self.decoder = CNNDecoder(depth, base, decoder_block_num, norm=no... |
def load_filepaths_and_text(filename, split='|'):
with open(filename, encoding='utf-8') as f:
filepaths_and_text = [line.strip().split(split) for line in f]
return filepaths_and_text |
def test_dependent_symbol():
outer_sdfg = dace.SDFG('map_fission_with_dependent_symbol')
outer_sdfg.add_symbol('fidx', dace.int32)
outer_sdfg.add_symbol('lidx', dace.int32)
outer_sdfg.add_array('A', (2, 10), dtype=dace.int32)
outer_sdfg.add_array('B', (2, 10), dtype=dace.int32)
inner_sdfg = dace... |
def main(args):
params = set_params(args.data, args.task)
train_dataset = UncertainTripleDataset(params.data_dir, 'train.tsv')
train_test_dataset = UncertainTripleDataset(params.data_dir, 'train.tsv')
dev_dataset = UncertainTripleDataset(params.data_dir, 'val.tsv')
test_dataset = UncertainTripleData... |
def _get_codegen_gemm_opts(ashape, astride, bshape, bstride, cshape, cstride):
opt = get_gemm_opts(astride, bstride, cstride)
bopt = get_batchmm_opts(ashape, astride, bshape, bstride, cshape, cstride)
opt['M'] = ashape[(- 2)]
opt['N'] = bshape[(- 1)]
opt['K'] = ashape[(- 1)]
if opt['swap']:
... |
def replace_message_content(content: str, replacements: List[Dict[(str, str)]]) -> str:
for replacement in replacements:
pattern = re.compile(replacement['regex'])
content = pattern.sub(replacement['replacement'], content)
return content |
def absolute_variable_scope(scope: str, **kwargs) -> tf.variable_scope:
return tf.variable_scope(tf.VariableScope(name=scope, **kwargs), auxiliary_name_scope=False) |
class ResBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super(ResBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1, bias=False)
self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1, bias=False)
self.relu = nn.ReLU(True... |
class ControlC(Callback):
def quit_all():
import sys
sys.exit(0)
def __init__(self, quit_and_do, action=quit_all):
super(ControlC, self).__init__()
if (type(quit_and_do) != bool):
raise ValueError('In KeyBoardInterrupt, quit_and_do arguemnt must be a bool.')
s... |
def _seg_21():
return [(8178, 'M', u''), (8179, 'M', u''), (8180, 'M', u''), (8181, 'X'), (8182, 'V'), (8183, 'M', u''), (8184, 'M', u''), (8185, 'M', u''), (8186, 'M', u''), (8187, 'M', u''), (8188, 'M', u''), (8189, '3', u' '), (8190, '3', u' '), (8191, 'X'), (8192, '3', u' '), (8203, 'I'), (8204, 'D', u''), (820... |
class Speech2Text2Processor():
def __init__(self, feature_extractor, tokenizer):
if (not isinstance(feature_extractor, SequenceFeatureExtractor)):
raise ValueError(f'`feature_extractor` has to be of type {SequenceFeatureExtractor.__class__}, but is {type(feature_extractor)}')
if (not isi... |
_module()
class PascalContextDataset59(CustomDataset):
CLASSES = ('aeroplane', 'bag', 'bed', 'bedclothes', 'bench', 'bicycle', 'bird', 'boat', 'book', 'bottle', 'building', 'bus', 'cabinet', 'car', 'cat', 'ceiling', 'chair', 'cloth', 'computer', 'cow', 'cup', 'curtain', 'dog', 'door', 'fence', 'floor', 'flower', 'f... |
class D_NLayers(nn.Module):
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d):
super(D_NLayers, self).__init__()
if (type(norm_layer) == functools.partial):
use_bias = (norm_layer.func != nn.BatchNorm2d)
else:
use_bias = (norm_layer != nn.Bat... |
_task('speech_pretraining')
class AudioPretrainingTask(FairseqTask):
def add_args(parser):
parser.add_argument('data', help='path to data directory')
parser.add_argument('--sample-rate', default=16000, type=int, help='target sample rate. audio files will be up/down sampled to this rate')
par... |
_task('sentence_ranking')
class SentenceRankingTask(FairseqTask):
def add_args(parser):
parser.add_argument('data', metavar='FILE', help='file prefix for data')
parser.add_argument('--num-classes', type=int, help='number of sentences to be ranked')
parser.add_argument('--init-token', type=in... |
class TestSuiteLineCoverageFunction(TestSuiteCoverageFunction):
def compute_coverage(self, individual) -> float:
results = self._run_test_suite_chromosome(individual)
merged_trace = analyze_results(results)
tracer = self._executor.tracer
return compute_line_coverage(merged_trace, tra... |
def register_types(module):
root_module = module.get_root()
module.add_class('Address', import_from_module='ns.network')
module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network')
module.add_class('AttributeConstructionList', import_from_module='... |
class PackagingTest(TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._temporary_files = []
def temp(self):
t = NamedTemporaryFile()
name = t.name
if IS_WINDOWS:
t.close()
else:
self._temporary_files.app... |
def convert_clone_examples_to_features(item):
(example, example_index, tokenizer, args) = item
if ((args.model_type in ['t5', 'codet5']) and args.add_task_prefix):
source_str = '{}: {}'.format(args.task, example.source)
target_str = '{}: {}'.format(args.task, example.target)
else:
so... |
def _to_complete_list(poly, length):
L = poly.coefficients(sparse=False)
return (L + ([poly.base_ring().zero()] * (length - len(L)))) |
.parametrize('seed', [313])
.parametrize('seed_num_arrays', [314])
.parametrize('ij_indexing', [True, False])
.parametrize('num_arrays', [2, 3, 4, 5])
.parametrize('ctx, func_name', list_context('Meshgrid'))
def test_meshgrid(seed, seed_num_arrays, ij_indexing, num_arrays, ctx, func_name):
from nbla_test_utils impo... |
class A000108(SloaneSequence):
def __init__(self):
SloaneSequence.__init__(self, offset=0)
def _repr_(self):
return 'Catalan numbers: C(n) = binomial(2n,n)/(n+1) = (2n)!/(n!(n+1)!). Also called Segner numbers.'
def _eval(self, n):
return combinat.catalan_number(n) |
def test_edvr_model():
model_cfg = dict(type='EDVR', generator=dict(type='EDVRNet', in_channels=3, out_channels=3, mid_channels=8, num_frames=5, deform_groups=2, num_blocks_extraction=1, num_blocks_reconstruction=1, center_frame_idx=2, with_tsa=False), pixel_loss=dict(type='L1Loss', loss_weight=1.0, reduction='sum'... |
def test_multiple_modes_sequentially():
arr = np.array([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]])
modes = ['reflect', 'wrap']
expected = sndi.gaussian_filter1d(arr, 1, axis=0, mode=modes[0])
expected = sndi.gaussian_filter1d(expected, 1, axis=1, mode=modes[1])
assert_equal(expected, sndi.g... |
_config
def task_mlm_itm_webvid():
exp_name = 'mlm_itm'
datasets = ['webvid']
loss_names = _loss_names({'itm': 1, 'mlm': 1})
batch_size = 1024
max_epoch = 10
max_image_len = (- 1) |
class FairseqDecoder(nn.Module):
def __init__(self, dictionary):
super().__init__()
self.dictionary = dictionary
def forward(self, prev_output_tokens, encoder_out):
raise NotImplementedError
def get_normalized_probs(self, net_output, log_probs, sample):
if (hasattr(self, 'ada... |
class NonStaticControlFlowGuard():
def __init__(self, status: NonStaticControlFlowStatus):
self.status = status
def __enter__(self):
self.prev = self.status.is_in_non_static_control_flow
self.status.is_in_non_static_control_flow = True
def __exit__(self, exc_type, exc_val, exc_tb):
... |
class CNNLayer(nn.Module):
def __init__(self, obs_shape, hidden_size, use_orthogonal, activation_id, kernel_size=3, stride=1):
super(CNNLayer, self).__init__()
active_func = [nn.Tanh(), nn.ReLU(), nn.LeakyReLU(), nn.ELU()][activation_id]
init_method = [nn.init.xavier_uniform_, nn.init.orthog... |
def batch_fc_normalization_layer(input_layer, dimension):
(mean, variance) = tf.nn.moments(input_layer, axes=[0])
beta = tf.get_variable('beta', dimension, tf.float32, initializer=tf.constant_initializer(0.0, tf.float32))
gamma = tf.get_variable('gamma', dimension, tf.float32, initializer=tf.constant_initia... |
def get_model_name(cfg):
name = '{model}_{num_layers}'.format(model=cfg.MODEL, num_layers=cfg.POSE_RESNET.NUM_LAYERS)
deconv_suffix = ''.join(('d{}'.format(num_filters) for num_filters in cfg.POSE_RESNET.NUM_DECONV_FILTERS))
full_name = '{height}x{width}_{name}_{deconv_suffix}'.format(height=cfg.NETWORK.IMA... |
def calculate_loss_array(x_mean, x, z_mu, z_var, z_0, z_k, ldj, args):
if (args.input_type == 'binary'):
loss = binary_loss_array(x_mean, x, z_mu, z_var, z_0, z_k, ldj)
elif (args.input_type == 'multinomial'):
loss = multinomial_loss_array(x_mean, x, z_mu, z_var, z_0, z_k, ldj, args)
else:
... |
def do_env(env, text, titleline, counter, format):
(label, titleline) = get_label(titleline)
titleline = titleline.strip()
if titleline:
titleline = (': ' + titleline)
template = '\n===== ${env.capitalize()} ${counter} ${titleline} =====\n% if label:\nlabel{${label}}\n% endif\n${text}\n\n'
r... |
class Siamese(pl.LightningModule):
def __init__(self, train_dataset: Dataset, dev_dataset: Dataset, input_dim, hidden_dim, batch_size, verbose=True, same_weights=True, compare_by: str='cosine'):
super().__init__()
self.l1 = torch.nn.Linear(input_dim, hidden_dim, bias=True).double()
if (not s... |
def search_func(xloader, network, criterion, scheduler, w_optimizer, a_optimizer, epoch_str, print_freq, algo, logger):
(data_time, batch_time) = (AverageMeter(), AverageMeter())
(base_losses, base_top1, base_top5) = (AverageMeter(), AverageMeter(), AverageMeter())
(arch_losses, arch_top1, arch_top5) = (Ave... |
def add_distributed_training_args(parser):
group = parser.add_argument_group('Distributed training')
group.add_argument('--distributed-world-size', type=int, metavar='N', default=max(1, torch.cuda.device_count()), help='total number of GPUs across all nodes (default: all visible GPUs)')
group.add_argument('... |
class Triangle():
def __init__(self, a, b, c, color=0):
self._a = a
self._b = b
self._c = c
self._color = color
def str(self):
return ('%s %s %s %s' % (self._a, self._b, self._c, self._color))
def set_color(self, color):
self._color = color
def get_vertice... |
def get_keyframe_data(boxes_and_labels):
def sec_to_frame(sec):
return ((sec - 900) * FPS)
keyframe_indices = []
keyframe_boxes_and_labels = []
count = 0
for video_idx in range(len(boxes_and_labels)):
sec_idx = 0
keyframe_boxes_and_labels.append([])
for sec in boxes_a... |
class UniversalCyclotomicFieldElement(FieldElement):
def __init__(self, parent, obj):
self._obj = obj
FieldElement.__init__(self, parent)
def __bool__(self):
return bool(self._obj)
def __reduce__(self):
return (self.parent(), (str(self),))
def __eq__(self, other):
... |
def list_all_keys(client, bucket, prefix, max_keys=None):
objects = client.list_objects(Bucket=bucket, Prefix=prefix, Delimiter=prefix)
if (objects.get('Contents') == None):
return []
keys = list(map((lambda x: x['Key']), objects.get('Contents', [])))
truncated = objects['IsTruncated']
next_... |
_LAYERS.register_module()
class ConvAudio(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, op='concat', stride=1, padding=0, dilation=1, groups=1, bias=False):
super().__init__()
kernel_size = _pair(kernel_size)
stride = _pair(stride)
padding = _pair(padding)
... |
def nodes_builder(model: GraphModule, module_dict: Dict, to_numpy: Callable) -> Tuple[(List, List, List, Dict)]:
inputs = []
outputs = []
nodes = []
output_nodes = []
fx_node_2_graph_node = {}
for node in model.graph.nodes:
framework_attr = dict(node.kwargs)
node_has_activation =... |
class Distributed(object):
def __init__(self, num_workers=1, backend='multiprocessing', verbose=False):
self.client = Parallel(n_jobs=num_workers, backend='multiprocessing', prefer='processes')
self.num_workers = num_workers
self.verbose = verbose
if self.verbose:
print(s... |
def TrivialBundle(X, rank=1):
if (not is_ToricVariety(X)):
raise ValueError('not a toric variety')
base_ring = X.base_ring()
filtrations = {ray: FilteredVectorSpace(rank, 0, base_ring=base_ring) for ray in X.fan().rays()}
from . import klyachko
return klyachko.Bundle(X, filtrations, check=Tr... |
class MethodAveragePrecision(Enum):
EVERY_POINT_INTERPOLATION = 1
ELEVEN_POINT_INTERPOLATION = 2 |
def parse_args():
parser = argparse.ArgumentParser(description='Script that converts part of a wikipedia dump to silver standard trees')
parser.add_argument('--output_file', default='vi_wiki_tokenized.txt', help='Where to write the tokenized lines')
parser.add_argument('--lang', default='vi', help='Which la... |
def use_original_bracket(text: str):
return text.replace('-lrb-', '(').replace('-rrb-', ')').replace('-LRB-', '(').replace('-RRB-', ')').replace('-lsb-', '[').replace('-rsb-', ']').replace('-LSB-', '[').replace('-RSB-', ']') |
class AutoModelForVision2Seq(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def _int64_list_feature(values):
if (not isinstance(values, collections.Iterable)):
values = [values]
return tf.train.Feature(int64_list=tf.train.Int64List(value=values)) |
def check_slot_inform(value_label, inform_label, label_maps):
value = inform_label
if (value_label == inform_label):
value = value_label
elif is_in_list(inform_label, value_label):
value = value_label
elif is_in_list(value_label, inform_label):
value = value_label
elif (infor... |
class mumps_struc_c_4(ctypes.Structure):
_fields_ = [('sym', mumps_int), ('par', mumps_int), ('job', mumps_int), ('comm_fortran', mumps_int), ('icntl', (mumps_int * 40)), ('cntl', (mumps_real * 15)), ('n', mumps_int), ('nz_alloc', mumps_int), ('nz', mumps_int), ('irn', mumps_pint), ('jcn', mumps_pint), ('a', mumps_... |
class ConcatCell(BaseMergeCell):
def __init__(self, in_channels, out_channels, **kwargs):
super(ConcatCell, self).__init__((in_channels * 2), out_channels, **kwargs)
def _binary_op(self, x1, x2):
ret = torch.cat([x1, x2], dim=1)
return ret |
def bench3():
desc = "Some basic arithmetic with very large Rational numbers: '(2/3)^100001 * (17/19)^100001"
t = cputime()
a = ((QQ((2, 3)) ** 100001) * (QQ((17, 19)) ** 100001))
return (desc, cputime(t)) |
def test_ListOffsetArray_NumpyArray():
a = ak.contents.listoffsetarray.ListOffsetArray(ak.index.Index(np.array([1, 4, 4, 6])), ak.contents.numpyarray.NumpyArray(np.array([6.6, 1.1, 2.2, 3.3, 4.4, 5.5, 7.7])))
assert (a.to_typetracer().form == a.form)
assert (a.to_typetracer().form.type == a.form.type)
a... |
def Res101_Deeplab(num_classes=21):
model = ResNet(Bottleneck, [3, 4, 23, 3], num_classes)
return model |
def format_checker_each_file(category, input_data_path):
print('[I] Checking', category.upper(), 'category')
try:
input_data = read_json_line(input_data_path)
except:
input_data = None
print('[ERROR] check your file format, should be .jsonl')
assert (len(input_data) == 500), 'che... |
class Generator(nn.Module):
def __init__(self, z_dim, shared_dim, img_size, g_conv_dim, g_spectral_norm, attention, attention_after_nth_gen_block, activation_fn, conditional_strategy, num_classes, initialize, G_depth, mixed_precision):
super(Generator, self).__init__()
self.in_dims = [512, 256, 128]... |
class SingularFunctionFactory():
def __getattr__(self, name):
if name.startswith('_'):
raise AttributeError(("Singular Function Factory has no attribute '%s'" % name))
try:
return singular_function(name)
except NameError:
if name.endswith('__lib'):
... |
def generate_test(filename):
[sp_min, sp_max, ap_min, ap_max] = np.load('data/timbre_model/min_max_record.npy')
condi = get_condition(filename)
(sp, raw_sp) = generate_timbre(0, sp_max, sp_min, condi, None)
plt.imshow(np.log(np.transpose(sp)), aspect='auto', origin='bottom', interpolation='none')
pl... |
def preprocess_function(examples, tokenizer, lowercase, **kwargs):
if lowercase:
examples['input'] = [example.lower() for example in examples['input']]
model_inputs = tokenizer(text=examples['input'], max_length=MAX_LENGTH, padding='max_length', truncation=True, return_tensors='pt')
labels = tokeniz... |
def test_yolact_head_loss():
s = 550
img_metas = [{'img_shape': (s, s, 3), 'scale_factor': 1, 'pad_shape': (s, s, 3)}]
train_cfg = mmcv.Config(dict(assigner=dict(type='MaxIoUAssigner', pos_iou_thr=0.5, neg_iou_thr=0.4, min_pos_iou=0.0, ignore_iof_thr=(- 1), gt_max_assign_all=False), smoothl1_beta=1.0, allow... |
def clean_ro_cui(df: Union[(pd.DataFrame, dd.DataFrame)], column: str, output_format: str='standard', inplace: bool=False, errors: str='coerce', progress: bool=True) -> pd.DataFrame:
if (output_format not in {'compact', 'standard'}):
raise ValueError(f'output_format {output_format} is invalid. It needs to b... |
def data_generator(train_arguments, test_arguments):
train_generator = datagenerator(**train_arguments)
test_generator = datagenerator(**test_arguments)
return (train_generator, test_generator) |
def determineMaxWindowSize(dtype, limit=None):
vmem = psutil.virtual_memory()
maxSize = math.floor(math.sqrt((vmem.available / np.dtype(dtype).itemsize)))
if ((limit is None) or (limit >= maxSize)):
return maxSize
else:
return limit |
def test_columnar_convert_column_default_selected_columns():
converter = ColumnarConverter(name='x', default_type='foo', type_column=None, column_defaults={'before': 123}, selected_columns={'before': 'after'}, transform_columns={})
(ids, columns, type_info) = converter.convert({'x': _EMPTY_DF, 'y': _EMPTY_DF})
... |
def combine_dicts(d1, d2):
comb = d1
for k in d2:
if (k not in comb):
comb[k] = d2[k]
else:
for val in d2[k]:
if (val not in comb[k]):
comb[k].append(val)
return comb |
def convert_to_cancer_stage(row):
stage_list = []
for (idx, number) in enumerate(row):
diameter_cm = ((number / (math.pi / 6)) ** (1.0 / 3.0))
if (diameter_cm < 3):
stage = 1
elif ((diameter_cm >= 3) and (diameter_cm < 4)):
stage = 2
elif ((diameter_cm >= ... |
def getTreeBuilder(treeType, implementation=None, **kwargs):
treeType = treeType.lower()
if (treeType not in treeBuilderCache):
if (treeType == 'dom'):
from . import dom
if (implementation is None):
from xml.dom import minidom
implementation = mini... |
def separate_branch(config_path: str) -> Tuple[(str, str)]:
segments = config_path.split('')
if (len(segments) == 1):
return (segments[0], 'master')
elif (len(segments) == 2):
return (segments[0], segments[1])
else:
raise ValueError(f'Multiple branches in the config path {config_... |
def WeakTableaux(k, shape, weight, representation='core'):
if (representation == 'core'):
return WeakTableaux_core(k, shape, weight)
elif (representation == 'bounded'):
return WeakTableaux_bounded(k, shape, weight)
elif (representation == 'factorized_permutation'):
return WeakTableau... |
def main(argv):
parser = OptionParser(usage='Usage: %prog [options] modulename\nUtility script to create a basic template for a new ns-3 module')
(options, args) = parser.parse_args()
if (len(args) != 1):
parser.print_help()
return 1
modname = args[0].lower()
if (False in [word.isaln... |
def _test_pow_int_base_int_exp(dt_base, dt_exp):
z = ti.field(dt_base, shape=())
def func(x: dt_base, y: dt_exp):
z[None] = (x ** y)
for x in range((- 5), 5):
for y in range(0, 10):
func(x, y)
assert (z[None] == (x ** y)) |
def _keep_fields(base, keep_names, usemask=True, asrecarray=False):
newdtype = [(n, base.dtype[n]) for n in keep_names]
output = np.empty(base.shape, dtype=newdtype)
output = recursive_fill_fields(base, output)
return _fix_output(output, usemask=usemask, asrecarray=asrecarray) |
class MultiPolynomialFunctor(ConstructionFunctor):
rank = 9
def __init__(self, vars, term_order):
Functor.__init__(self, Rings(), Rings())
self.vars = vars
self.term_order = term_order
def _apply_functor(self, R):
from sage.rings.polynomial.polynomial_ring_constructor import ... |
class LaionDataset(BaseDataset):
def __init__(self, vis_processor, text_processor, location):
super().__init__(vis_processor=vis_processor, text_processor=text_processor)
self.inner_dataset = wds.DataPipeline(wds.ResampledShards(location), wds.tarfile_to_samples(handler=wds.warn_and_continue), wds.s... |
def get_parser():
parser = argparse.ArgumentParser(description='reads text from stdin and outputs normalized, lid-filtered version to stdout')
parser.add_argument('--fasttext-model', help='path to fasttext model', default='lid.187.bin')
parser.add_argument('--lang', help='language id', required=True)
pa... |
class FusedBatchNormalizationBackward(PythonFunction):
def __init__(self, ctx, axes=[], decay_rate=0.9, eps=1e-05, batch_stat=True, nonlinearity='relu'):
super(FusedBatchNormalizationBackward, self).__init__(ctx)
self._func = _F.FusedBatchNormalization(ctx, axes, decay_rate, eps, batch_stat, nonline... |
def check_compatibility(urllib3_version, chardet_version):
urllib3_version = urllib3_version.split('.')
assert (urllib3_version != ['dev'])
if (len(urllib3_version) == 2):
urllib3_version.append('0')
(major, minor, patch) = urllib3_version
(major, minor, patch) = (int(major), int(minor), int... |
def tensor_init_for_desc(name: str, desc: data.Data, zeros=False) -> str:
return f'''Tensor {name} = torch::{('zeros' if zeros else 'empty')}(
{{{', '.join((str(s) for s in desc.shape))}}},
torch::TensorOptions()
.dtype(torch::{typeclass_to_torch_cpp_type(desc.dtype)})
.device(torch::{('kCUD... |
.core
def test_sum_pandas(df):
res = pd.DataFrame()
cv = KFolds(n_folds=2, seed=1337, session_id_column='session_id', query_column='user_id')
for (_, test) in cv.split(df):
res = res.append(test, ignore_index=True)
res = res.sort_values(['user_id', 'item_id']).reset_index(drop=True)
assert a... |
def spawn_2D_maze(map, border_tile, border_size=(1, 1), base_pos=5, maze_height=3):
blocks = []
item = get_tile(border_tile)
for h in range(maze_height):
for j in range((- border_size[0]), 0):
for i in range((- border_size[1]), (len(map[0]) + border_size[1])):
blocks.appe... |
def receive_user_input(config_generator: YamlGenerator):
bot_name = input('Input bot name: ')
config_generator.add_bot_name(bot_name)
while True:
task_name = input('Input a task name: ')
if task_name:
config_generator.add_task(task_name)
entity_names = input("Input en... |
def my_py_nested_call(t1, t2, dst, world_size, hops):
next_dst = ((dst + 1) % world_size)
if (hops > 0):
return rpc.rpc_sync(worker_name(next_dst), my_py_nested_call, args=(t1, t2, next_dst, world_size, (hops - 1)))
else:
return rpc.rpc_sync(worker_name(next_dst), my_py_add, args=(t1, t2)) |
def conv3d_args_preprocessor(args, kwargs):
converted = []
if (len(args) > 5):
raise TypeError('Layer can receive at most 4 positional arguments.')
if (len(args) == 5):
if (isinstance(args[2], int) and isinstance(args[3], int) and isinstance(args[4], int)):
kernel_size = (args[2]... |
def multihead_callback_re_init(model):
for layer in model.layers:
if (layer.name.find('multihead') >= 0):
layer.bias.assign(layer.bias_initializer(layer.bias.shape))
layer.kernel.assign(layer.kernel_initializer(layer.kernel.shape)) |
def default_collate(batch):
elem = batch[0]
elem_type = type(elem)
if isinstance(elem, torch.Tensor):
out = None
if (torch.utils.data.get_worker_info() is not None):
numel = sum([x.numel() for x in batch])
storage = elem.storage()._new_shared(numel)
out = ... |
class CksumTestCase(unittest.TestCase):
def test_cksum_bytes(self):
cksum = CksumAlgorithm()
cksum.update(b'The quick brown fox jumps over the lazy dog\n')
self.assertEqual(cksum.hexdigest(), '')
def test_cksum_string(self):
cksum = CksumAlgorithm()
cksum.update('The quic... |
def download_glue():
data_dir = os.path.join(DATA_DIR, 'glue_data')
subprocess.call(['python', 'data/download/download_glue_data.py', '--data_dir', data_dir, '--tasks', 'all']) |
class GradientCheckerOptimizer(torch.optim.AdamW):
def step(self, *args, **kwargs):
for group in self.param_groups:
for p in group['params']:
assert (p.grad is not None), f'grad is None for: {p}'
super().step(*args, **kwargs) |
def join_lines(lines_enum):
primary_line_number = None
new_line = []
for (line_number, line) in lines_enum:
if ((not line.endswith('\\')) or COMMENT_RE.match(line)):
if COMMENT_RE.match(line):
line = (' ' + line)
if new_line:
new_line.append(li... |
class Block(nn.Module):
def __init__(self, dim, head, reduction_ratio=1, mlp_ratio=4, dpr=0.0):
super().__init__()
self.norm1 = nn.LayerNorm(dim)
self.attn = Attention(dim, head, reduction_ratio)
self.drop_path = (DropPath(dpr) if (dpr > 0.0) else nn.Identity())
self.norm2 = ... |
def load_mimic_dataset(diag_or_proc_param, note_category_param, icd_seq_num_param):
note_events_df = generate_notes_df(note_category_param)
(diagnoses_icd, procedures_icd) = load_diag_procs(icd_seq_num_param)
(diagnoses_dict, procedures_dict) = generate_dicts(diagnoses_icd, procedures_icd)
(diagnoses_df... |
def test_sieve():
assert (Sieve.generate_primes(50) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47])
assert (len(Sieve.generate_primes(1009)) == 169) |
class MixtureBatchNorm2d(nn.BatchNorm2d):
def __init__(self, k, num_channels, eps=1e-05, momentum=0.1, track_running_stats=True):
super(MixtureBatchNorm2d, self).__init__(num_channels, eps=eps, momentum=momentum, affine=False, track_running_stats=track_running_stats)
self.k = k
self.weight_ ... |
def get_dtype_size(dtype):
if (dtype == torch.bool):
return (1 / 8)
bit_search = re.search('[^\\d](\\d+)$', str(dtype))
if (bit_search is None):
raise ValueError(f'`dtype` is not a valid dtype: {dtype}.')
bit_size = int(bit_search.groups()[0])
return (bit_size // 8) |
class GotoLocationAction(BaseAction):
valid_actions = {'MoveAhead', 'RotateLeft', 'RotateRight', 'LookUp', 'LookDown', 'Teleport', 'TeleportFull'}
def get_reward(self, state, prev_state, expert_plan, goal_idx):
if (state.metadata['lastAction'] not in self.valid_actions):
(reward, done) = (se... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.