code stringlengths 101 5.91M |
|---|
class NetworksTest(tf.test.TestCase):
def testGetNetworkFnFirstHalf(self):
batch_size = 5
num_classes = 1000
for net in list(nets_factory.networks_map.keys())[:10]:
with tf.Graph().as_default() as g, self.test_session(g):
net_fn = nets_factory.get_network_fn(net, ... |
def coreset(run_dir: str='./run', datasets_dir: str='./data', dataset: str='amazon_review_polarity', validation: int=0, shuffle: bool=True, arch: str='vdcnn9-maxpool', optimizer: str='sgd', epochs: Tuple[(int, ...)]=(3, 3, 3, 3, 3), learning_rates: Tuple[(float, ...)]=(0.01, 0.005, 0.0025, 0.00125, 0.000625), momentum:... |
def instantiate_factored_mapping(pairs):
part_mappings = [[list(zip(preimg, perm_img)) for perm_img in itertools.permutations(img)] for (preimg, img) in pairs]
return tools.cartesian_product(part_mappings) |
def eval_one_epoch(cfg, model, dataloader, epoch_id, logger, dist_test=False, save_to_file=False, result_dir=None, logger_iter_interval=50):
result_dir.mkdir(parents=True, exist_ok=True)
final_output_dir = ((result_dir / 'final_result') / 'data')
if save_to_file:
final_output_dir.mkdir(parents=True,... |
def waymo_data_prep(root_path, info_prefix, version, out_dir, workers, max_sweeps=5):
from tools.data_converter import waymo_converter as waymo
splits = ['training', 'validation', 'testing']
for (i, split) in enumerate(splits):
load_dir = osp.join(root_path, 'waymo_format', split)
if (split ... |
class COCO_json(object):
def __init__(self, images_dir, save_dir, categories_dict, sets, images_names, meta_dir):
self.images_dir = images_dir
self.save_dir = save_dir
self.categories_dict = categories_dict
self.sets = sets
self.images_names = images_names
self.meta_d... |
class SqueezeViewRemove(pm.SingleStateTransformation):
in_array = pm.PatternNode(nodes.AccessNode)
out_array = pm.PatternNode(nodes.AccessNode)
def expressions(cls):
return [sdutil.node_path_graph(cls.in_array, cls.out_array)]
def can_be_applied(self, state: SDFGState, expr_index: int, sdfg: SDF... |
def write_file(lines, path):
print('Writing:', path)
with open(path, 'w') as f:
for l in lines:
f.write((l + '\n')) |
class BenchmarkResult():
def __init__(self, metric, method, value=None, curve_x=None, curve_y=None, curve_y_std=None, value_sign=None):
self.metric = metric
self.method = method
self.value = value
self.curve_x = curve_x
self.curve_y = curve_y
self.curve_y_std = curve_... |
def plot_line(vis: visdom.Visdom, window_name: str, env: Optional[str]=None, line_label: Optional[str]=None, x: Optional[np.ndarray]=None, y: Optional[np.ndarray]=None, x_label: Optional[str]=None, y_label: Optional[str]=None, width: int=576, height: int=416, draw_marker: bool=False) -> str:
empty_call = (not vis.w... |
class TestSolveLyapunov(object):
cases = [(np.array([[1, 2], [3, 4]]), np.array([[9, 10], [11, 12]])), (np.array([[(1.0 + 1j), 2.0], [(3.0 - 4j), 5.0]]), np.array([[(2.0 - 2j), (2.0 + 2j)], [((- 1.0) - 1j), 2.0]])), (np.array([[1.0, 2.0], [3.0, 5.0]]), np.array([[(2.0 - 2j), (2.0 + 2j)], [((- 1.0) - 1j), 2.0]])), (... |
def score_2afc_dataset(data_loader, func, name=''):
d0s = []
d1s = []
gts = []
for data in tqdm(data_loader.load_data(), desc=name):
d0s += func(data['ref'], data['p0']).data.cpu().numpy().flatten().tolist()
d1s += func(data['ref'], data['p1']).data.cpu().numpy().flatten().tolist()
... |
class ChamferFunction(torch.autograd.Function):
def forward(ctx, xyz1, xyz2):
(dist1, dist2, idx1, idx2) = chamfer.forward(xyz1, xyz2)
ctx.save_for_backward(xyz1, xyz2, idx1, idx2)
return (dist1, dist2)
def backward(ctx, grad_dist1, grad_dist2):
(xyz1, xyz2, idx1, idx2) = ctx.sav... |
def build_debug_graph(inputs):
nr_iters = inputs['features'].shape[0]
feature_shape = [s.value for s in inputs['features'].shape[2:]]
groups_shape = [s.value for s in inputs['groups'].shape[2:]]
with tf.name_scope('debug'):
X_debug_shape = ([nr_iters, None] + feature_shape)
G_debug_shape... |
def roman2romantrain(roman):
if (roman == 'rest'):
return ([0], 1)
return ([(int(roman) - 1)], 0) |
_utils.test(require=ti.extension.sparse, exclude=ti.metal)
def test_no_activate():
x = ti.field(ti.f32)
n = 1024
d = ti.root.dynamic(ti.i, n, chunk_size=32)
d.place(x)
def initialize():
for i in range(n):
x[i] = 1
def func():
ti.no_activate(d)
for i in range((... |
def get_triton_activation_kernel(activation: Optional[Activation]):
return ({Activation.ReLU: relu, Activation.LeakyReLU: leaky_relu, Activation.GeLU: gelu, Activation.GeLUApprox: gelu_approx, Activation.SquaredReLU: squared_relu}[activation] if activation else None) |
(frozen=True)
class ScannerTypeInfo():
type = attrib()
cpp_name = attrib()
serialize = attrib()
deserialize = attrib() |
def test_nonzero_offset_fromarrow_NumpyArray_5():
content = ak.contents.NumpyArray(np.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1]))
assert (to_list(ak._connect.pyarrow.handle_arrow(content.to_arrow()[(- 2):10])) == pyarrow.Array.to_pylist(content.to_arrow()[(- 2):10])) |
.parametrize('seed', [313])
.parametrize('axis', [None, 0, 1, 2, 3, (0, 2), (1, 2, 3)])
.parametrize('keepdims', [False, True])
.parametrize('inshape', [(2, 3, 4, 5), (2, 1, 4, 5)])
.parametrize('op, ctx, func_name', list_ctx_and_func_name(['sum', 'mean', 'max', 'min', 'prod']))
def test_reduction_double_backward(op, s... |
def SuzukiGraph():
from sage.groups.perm_gps.permgroup_named import SuzukiSporadicGroup
g = Graph()
g.add_edges(SuzukiSporadicGroup().orbit((1, 2), 'OnSets'))
g.relabel()
g.name('Suzuki graph')
return g |
def test_horizon_180_365_days(tmp_path: pathlib.Path):
time_horizon = TimeHorizon(datetime.timedelta(days=180), datetime.timedelta(days=365))
labeler = DummyLabeler([2], time_horizon)
events_with_labels: EventsWithLabels = [(event((2000, 1, 3), 2, None), True), (event((2000, 10, 5), 2, None), False), (event... |
def norm_layer1d(norm, num_channels):
if (norm == 'batch'):
return nn.BatchNorm1d(num_channels)
elif (norm == 'instance'):
return nn.InstanceNorm1d(num_channels, affine=True)
elif (norm == 'layer'):
return nn.LayerNorm(num_channels)
else:
raise ValueError(('%s not recogni... |
def teniter(variable: T.Tensor, include_ordinary=True, include_saved=False):
def dedup(state, parent, ten, saved):
if (tensor := state.get(id(ten))):
ordinary = ((not saved) or tensor[1])
saved = (saved or tensor[2])
state[id(ten)] = (ten, ordinary, saved)
else:
... |
class MixedPercisionActivationSearch4Bit(MixedPercisionActivationBaseTest):
def __init__(self, unit_test):
super().__init__(unit_test)
self.expected_config = [1, 4, 1, 1]
def get_kpi(self):
return KPI(192, 1536)
def compare(self, quantized_models, float_model, input_x=None, quantizat... |
def print_model(model):
print(model)
nParams = 0
for w in model.parameters():
nParams += functools.reduce(operator.mul, w.size(), 1)
print(nParams) |
_properties
class ONNXOp(nd.LibraryNode):
implementations = {}
default_implementation = None
default_backward_implementation = None
schema = Property(dtype=ONNXSchema, desc="The operator's ONNX OpSchema", allow_none=True)
backward_implementation = Property(dtype=str, allow_none=True, desc='Which imp... |
class InteractionBlock(torch.nn.Module):
def __init__(self, hidden_channels, num_gaussians, num_filters, cutoff):
super(InteractionBlock, self).__init__()
self.mlp = Sequential(Linear(num_gaussians, num_filters), ShiftedSoftplus(), Linear(num_filters, num_filters))
self.conv = CFConv(hidden_... |
def register_Ns3WeibullRandomVariable_methods(root_module, cls):
cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
cls.add_constructor([])
cls.add_method('GetScale', 'double', [], is_const=True)
cls.add_method('GetShape', 'double', [], is_const=True)
cls.add_method('GetBound', 'double',... |
class Writer(abc.ABC):
def __enter__(self):
self.open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def __del__(self):
self.close()
def close(self):
pass
def open(self):
pass
def reserve(self, entry: str, shape: tuple, d... |
class DiracConv2d(nn.Conv2d, DiracConv):
def __init__(self, in_channels, out_channels, kernel_size, padding=0, dilation=1, bias=True):
super().__init__(in_channels, out_channels, kernel_size, stride=1, padding=padding, dilation=dilation, bias=bias)
self.init_params(out_channels)
def forward(self... |
class ContinuousQFunctionMixin():
def inner_predict_value(self: _ContinuousQFunctionProtocol, x: TorchObservation, action: torch.Tensor) -> torch.Tensor:
return self._q_func_forwarder.compute_expected_q(x, action, reduction='mean').reshape((- 1)) |
def countless_generalized(data, factor):
assert (len(data.shape) == len(factor))
sections = []
mode_of = reduce((lambda x, y: (x * y)), factor)
majority = int(math.ceil((float(mode_of) / 2)))
data += 1
for offset in np.ndindex(factor):
part = data[tuple((np.s_[o::f] for (o, f) in zip(off... |
class Normalize(rf.Module):
def __init__(self, *, param_dims: Union[(Dim, Sequence[Dim])], epsilon: float=1e-06, scale: bool=True, bias: bool=True):
super(Normalize, self).__init__()
self.epsilon = epsilon
if isinstance(param_dims, Dim):
param_dims = [param_dims]
self.sca... |
class Tester(Base):
def __init__(self, ckpt_path):
self.ckpt_path = ckpt_path
super(Tester, self).__init__(log_name='test_logs.txt')
def _make_batch_generator(self, test_set, annot_subset, capture, camera, seq_name):
self.logger.info((('Creating ' + test_set) + ' dataset...'))
te... |
class NodeConfig():
def __init__(self) -> None:
self.sim = 'qemu'
self.ip = '10.0.0.1'
self.prefix = 24
self.cores = 1
self.threads = 1
self.memory = 512
self.disk_image = 'base'
self.mtu = 1500
self.nockp = 0
self.app: tp.Optional[AppC... |
class PrefetchLoader(object):
def __init__(self, loader, img_normalize=None):
self.loader = loader
self.stream = torch.cuda.Stream()
self.img_normalize = img_normalize
def __iter__(self):
loader_it = iter(self.loader)
self.preload(loader_it)
batch = self.next(load... |
def test_indexedoption():
def find_it(array):
for item in array:
if (item is None):
pass
elif (item.x == 3):
return item
return None
array = ak.highlevel.Array([{'x': 1}, {'x': 2}, None, {'x': 3}])
assert (ak.operations.to_list(find_it(... |
def create_function_nnp(inputs, outputs, func_name, func_args, func_kwargs):
if (func_name is None):
return
for (category_name, category) in nnabla.utils.converter.get_category_info().items():
if (func_name in category):
function = category[func_name]
nnp = nnabla_pb2.NNablaProto... |
def print_flags(flags, flags_def):
logging.info('Running training with hyperparameters: \n{}'.format(pprint.pformat(['{}: {}'.format(key, val) for (key, val) in get_user_flags(flags, flags_def).items()]))) |
class BidirectionalSourceEncoder(SourceEncoder):
def __init__(self, input_dim, hidden_dim, rnn_cell_factory):
super(BidirectionalSourceEncoder, self).__init__()
if ((hidden_dim % 2) != 0):
raise ValueError('hidden_dim must be even for BidirectionalSourceEncoder.')
self._hidden_di... |
def _write_separated_file(buf, edge_dic, weight_dic, separator, prefix=''):
dummy_prefix = object()
prefix = (prefix or dummy_prefix)
for (key, edge_val) in edge_dic.items():
for (j, value) in enumerate(edge_val):
elements = [prefix, str(key), str(value), (str(weight_dic[key][j]) + '\n')... |
class ModuleMap(dict):
def __getitem__(self, k):
assert isinstance(k, ast_internal_classes.Module_Node)
if (k not in self):
self[k] = {}
return super().__getitem__(k)
def get(self, k):
return self[k]
def __setitem__(self, k, v) -> None:
assert isinstance(k... |
def simple_attentional_rnn(rnn_input, attention_state_list, initial_state=None):
attention_states = reshape_list2tensor(attention_state_list, len(attention_state_list), FLAGS.sentembed_size)
cell = get_lstm_cell()
dtype = (tf.float16 if FLAGS.use_fp16 else tf.float32)
(rnn_outputs, rnn_state) = seq2seq.... |
def get_model_visualization_name(model_name):
if (('bayesian' in model_name) or ('BBB' in model_name)):
return 'BBB RNN'
if ('variational' in model_name):
return 'Variational RNN'
if (('vanilla' in model_name) or ('baseline' in model_name)):
return 'Baseline RNN'
if ('forest' in ... |
class ResBlockGenerator(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super(ResBlockGenerator, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1)
self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1)
nn.init.xavier... |
def safe_rm(path_to_rm):
if (not os.path.exists(path_to_rm)):
return
if os.path.isdir(path_to_rm):
files_to_rm = [f'{path_to_rm}/{fname}' for fname in os.listdir(path_to_rm)]
dir_to_rm = path_to_rm
else:
files_to_rm = [path_to_rm]
dir_to_rm = None
for file_to_rm i... |
class Classify(nn.Module):
def __init__(self, channels_prev: int, num_classes: int):
super().__init__()
self.pool = nn.AvgPool2d(7)
self.flat = nn.Flatten()
self.fc = nn.Linear(channels_prev, num_classes)
def forward(self, states: Tuple[(Tensor, Tensor)]) -> Tensor:
(x, _... |
def perturb(x):
if (random.random() < (1.0 / 6)):
return (x + 1)
elif (random.random() < (1.0 / 5)):
return (x - 1)
elif (random.random() < (1.0 / 4)):
return (x + 2)
elif (random.random() < (1.0 / 3)):
return (x - 2)
return x |
def lagrange_inversion(a):
n = len(a)
f = sum(((a[i] * (x ** i)) for i in range(len(a))))
h = (x / f).series(x, 0, n).removeO()
hpower = [(h ** 0)]
for k in range(n):
hpower.append((hpower[(- 1)] * h).expand())
b = [mp.mpf(0)]
for k in range(1, n):
b.append((hpower[k].coeff(x... |
def collate_metrics(output_data_batch, name='depth'):
if isinstance(output_data_batch[0], dict):
output_data_batch = [output_data_batch]
metrics_data = []
for (i, output_batch) in enumerate(output_data_batch):
metrics = OrderedDict()
for (key, val) in output_batch[0].items():
... |
def train(model, data, params):
log = Logger(os.path.join(params.logdir, params.logfile), 'w')
num_train_original = atis_data.num_utterances(data.train_data)
log.put(('Original number of training utterances:\t' + str(num_train_original)))
eval_fn = evaluate_utterance_sample
trainbatch_fn = data.get_... |
def print_estimates(estimates_df, truth_df, sample_time_col, truth_query_fn):
for (_, row) in estimates_df.iterrows():
(model, K) = (row['model'], row['K'])
num_users = (480189 if ('Netflix' in model) else (1000990 if ('KDD' in model) else 1823179))
num_items = (17770 if ('Netflix' in model)... |
def non_sphere_GB(location, orientation):
r_vectors = get_boomerang_r_vectors(location, orientation)
U = 0.0
for k in range(len(r_vectors)):
if (r_vectors[k][2] < A):
return 0.0
U += (WEIGHT[k] * r_vectors[k][2])
h = r_vectors[k][2]
U += ((REPULSION_STRENGTH * np.... |
class LineEnd(_PositionToken):
def __init__(self):
super(LineEnd, self).__init__()
self.setWhitespaceChars(ParserElement.DEFAULT_WHITE_CHARS.replace('\n', ''))
self.errmsg = 'Expected end of line'
def parseImpl(self, instring, loc, doActions=True):
if (loc < len(instring)):
... |
def model_setup(model):
assert (len(config.resume_from) > 0)
assert os.path.isdir(config.resume_from)
model.checkpoint_manager = CheckpointManager(model, [])
model.output_dir = config.resume_from
model.last_step = model.checkpoint_manager.load_last_checkpoint()
assert (model.last_step > 0)
r... |
class PiecewiseLinearChannel(Channel):
def __init__(self, name, regions):
self.repr_init()
self.name = name
self.regions = [LinearRegion(**region) for region in regions]
self.n_regions = len(regions)
def sample(self, Z):
X = sum((region.sample(Z) for region in self.region... |
class TestSameColToken(DistanceTokenTester):
def test_execute(self, env, fields, dom, dom_elem):
included = [(101, 5), (99, 5), (100, 0), (105, 0), (99, 1), (80, 40), (101, 1)]
for (left, width) in included:
new_dom = copy.deepcopy(dom)
new_dom['children'][1]['left'] = left
... |
def combine_examples(corpus_ex):
combined_ex = [corpus_ex[0]]
for ex in corpus_ex[1:]:
if (ex.sent_num == combined_ex[(- 1)].sent_num):
current_sent = combined_ex.pop()
target_frame_dict = current_sent.targetframedict.copy()
target_frame_dict.update(ex.targetframedict... |
def calculate_theta_fwhm_cdr_s1(ekev, qnC):
theta_fwhm = (((17.2 - (6.4 * np.sqrt(qnC))) * 1e-06) / (ekev ** 0.85))
return theta_fwhm |
def default_loader(path: str) -> Any:
from torchvision import get_image_backend
if (get_image_backend() == 'accimage'):
return accimage_loader(path)
else:
return pil_loader(path) |
class EigenSparseMatrixPrinter():
def __init__(self, val):
type = val.type
if (type.code == gdb.TYPE_CODE_REF):
type = type.target()
self.type = type.unqualified().strip_typedefs()
tag = self.type.tag
regex = re.compile('\\<.*\\>')
m = regex.findall(tag)[0... |
class DatasetFolder(data.Dataset):
def __init__(self, root, list_path, transform=None, target_transform=None, patch_dataset=False):
self.root = root
self.patch_dataset = patch_dataset
if patch_dataset:
self.txn = []
for path in os.listdir(root):
lmdb_p... |
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--filename', type=str, required=True, help='Local filename of data')
parser.add_argument('--frac-to-take', type=float, required=True, help='How much of the data to store in the new filen... |
_to_string
class StrictUndefined(Undefined):
__slots__ = ()
__iter__ = __str__ = __len__ = __nonzero__ = __eq__ = __ne__ = __bool__ = __hash__ = Undefined._fail_with_undefined_error |
class EnumerateDataset(Dataset):
def __init__(self, dataset):
self.dataset = dataset
def __len__(self):
return len(self.dataset)
def __getitem__(self, idx):
return (idx, self.dataset[idx]) |
def conv_3_3_hook(module, input, output):
global vgg_conv3_3
vgg_conv3_3 = output
return None |
class TestFairseqEncoderModelBase(TestBaseFairseqModelBase):
def setUpClass(cls):
if (cls is TestFairseqEncoderModelBase):
raise unittest.SkipTest('Skipping test case in base')
super().setUpClass()
def setUpModel(self, model_cls, extra_args_setters=None):
self.assertTrue(issu... |
def _c_string_literal(s):
s = s.replace('\\', '\\\\')
s = s.replace('"', '\\"')
s = s.replace('\n', '\\n')
return '"{}"'.format(s) |
def test_save_setup_anndata(adata, save_path):
generic_setup_adata_manager(adata, batch_key='batch', labels_key='labels', protein_expression_obsm_key='protein_expression', protein_names_uns_key='protein_names')
adata.write(os.path.join(save_path, 'test.h5ad')) |
class AverageMeter(object):
def __init__(self):
self.reset()
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val... |
.usefixtures('spark')
def interactions_timestamp_spark_dataset(spark):
events = spark.createDataFrame(pd.DataFrame({'user_id': [0, 0, 1, 1, 1, 2], 'item_id': [0, 1, 0, 2, 3, 1], 'timestamp': [0, 1, 2, 3, 4, 5]}))
return {'interactions': events, 'user_col': 'user_id', 'item_col': 'item_id', 'timestamp_col': 'tim... |
class STGClassificationModel(MLPModel, ModelIOKeysMixin):
def __init__(self, input_dim, nr_classes, hidden_dims, device, batch_norm=None, dropout=None, activation='relu', sigma=1.0, lam=0.1):
super().__init__(input_dim, nr_classes, hidden_dims, batch_norm=batch_norm, dropout=dropout, activation=activation)
... |
((not workspace.C.has_mkldnn), 'Skipping as we do not have mkldnn.')
class TestMKLBasic(test_util.TestCase):
def testFCSpeed(self):
X = (np.random.rand(1, 256, 6, 6).astype(np.float32) - 0.5)
W = (np.random.rand(4096, 9216).astype(np.float32) - 0.5)
b = (np.random.rand(4096).astype(np.float3... |
def _BroadcastComputedParamsSingleHost(devices, model, use_nccl=False):
if (len(devices) == 1):
return
for param_name in model._computed_param_names:
_Broadcast(devices, model, model.net, param_name, use_nccl) |
def f(questions, start):
outs = []
for q in questions:
(question, context) = q.split('[SEP]')
d = pmodel.tokenizer(question, context)
out = pmodel.model.forward(**{k: torch.tensor(d[k]).reshape(1, (- 1)) for k in d})
logits = (out.start_logits if start else out.end_logits)
... |
class LinearScheduler():
def __init__(self, initial_value, final_step, name):
self.final_step = final_step
self.initial_value = initial_value
self.variable = tf.Variable(initial_value, name=name)
self.decayed_ph = tf.placeholder(tf.float32)
self.decay_op = self.variable.assig... |
class ClassAwareSampler(Sampler):
def __init__(self, data_source, num_samples_cls=4):
num_classes = data_source.num_classes
self.class_iter = RandomCycleIter(range(num_classes))
cls_data_list = [list() for _ in range(num_classes)]
for (i, label) in enumerate(data_source.labels):
... |
def test_siblings_get_binary_examples_2d_1(digraph, features_2d, labels):
policy = SiblingsPolicy(digraph, features_2d, labels)
ground_truth_x = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16]]
ground_truth_y = [1, 1, 0, 0, 0, 0, 0, 0]
(x, y, weights) = policy.get_binary_examples(... |
def convert_code_to_features(code, tokenizer, label, args):
code = ' '.join(code.split())
code_tokens = tokenizer.tokenize(code)[:(args.block_size - 2)]
source_tokens = (([tokenizer.cls_token] + code_tokens) + [tokenizer.sep_token])
source_ids = tokenizer.convert_tokens_to_ids(source_tokens)
padding... |
def get_config() -> ml_collections.ConfigDict:
config = ml_collections.ConfigDict()
config.object_category = 'Airplane'
config.in_memory = True
config.batch_size = 32
config.num_points = 1024
config.val_split = 0.2
config.initial_lr = 0.001
config.drop_every = 20
config.decay_factor ... |
class SeparableConv2d_same(nn.Module):
def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False, padding=0):
super(SeparableConv2d_same, self).__init__()
self.depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation, groups=inplanes, bias=bias)
... |
def move_and_detach(ts, device):
def f(t):
if isinstance(t, torch.Tensor):
return t.detach().to(device)
return t
return nested_map(f, ts) |
class TIntIntHI(object):
thisown = _swig_property((lambda x: x.this.own()), (lambda x, v: x.this.own(v)), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
_snap.TIntIntHI_swiginit(self, _snap.new_TIntIntHI(*args))
def __eq__(self, HashKeyDatI):
return _snap.TIn... |
.parametrize('parameter, message', (('userId', 'No such parameter in `GET /users/{user_id}`: `userId`. Did you mean `user_id`?'), ('what?', 'No such parameter in `GET /users/{user_id}`: `what?`.')))
.operations('create_user', 'get_user', 'update_user')
def test_misspelled_parameter(schema_url, parameter, message):
... |
def register_Ns3RlcTag_methods(root_module, cls):
cls.add_constructor([param('ns3::RlcTag const &', 'arg0')])
cls.add_constructor([])
cls.add_constructor([param('ns3::Time', 'senderTimestamp')])
cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
cls.add_method('Ge... |
def test_adjoint_conjugate():
X = np.array([[1j]])
A = interface.aslinearoperator(X)
B = (1j * A)
Y = (1j * X)
v = np.array([1])
assert_equal(B.dot(v), Y.dot(v))
assert_equal(B.H.dot(v), Y.T.conj().dot(v)) |
def test_static_cls():
instance = m.TestProperties()
assert (m.TestProperties.static_cls is m.TestProperties)
assert (instance.static_cls is m.TestProperties)
def check_self(self):
assert (self is m.TestProperties)
m.TestProperties.static_cls = check_self
instance.static_cls = check_self |
def main():
args = get_args()
(trainloader, devloader, testloader, n_classes, n_words) = get_data_loaders(args.data_path, args.task, args.language, args.representation, args.pca_size, args.batch_size)
print(('Language: %s Train size: %d Dev size: %d Test size: %d' % (args.language, len(trainloader.dataset),... |
class CategoricalColumnTransformer(BaseColumnTransformer):
def num_classes(self):
raise NotImplementedError() |
def save_kernels(arch):
m = ti.aot.Module()
m.add_kernel(fill_img, template_args={})
m.add_kernel(block1_deactivate_all, template_args={})
m.add_kernel(activate, template_args={})
m.add_kernel(paint, template_args={})
m.add_kernel(check_img_value, template_args={})
m.add_field('x', x)
m.... |
class GeneralMulAttConvLayer(MessagePassing):
def __init__(self, in_channels, out_channels, improved=False, cached=False, bias=True, **kwargs):
super(GeneralMulAttConvLayer, self).__init__(aggr=cfg.gnn.agg, **kwargs)
self.heads = cfg.gnn.att_heads
self.in_channels = int(((in_channels // self... |
def send_encrypted(channel, message):
cipher = DES.new('')
encrypted_message = cipher.encrypt(message)
channel.send(encrypted_message)
return encrypted_message |
def add_activation_summary(var):
tf.histogram_summary((var.op.name + '/activation'), var)
tf.scalar_summary((var.op.name + '/sparsity'), tf.nn.zero_fraction(var)) |
class TerminalDef(Serialize):
__serialize_fields__ = ('name', 'pattern', 'priority')
__serialize_namespace__ = (PatternStr, PatternRE)
def __init__(self, name, pattern, priority=1):
assert isinstance(pattern, Pattern), pattern
self.name = name
self.pattern = pattern
self.prio... |
def load_dict(filename_):
with open(filename_, 'rb') as f:
ret_dict = pickle.load(f)
return ret_dict |
class BLEUScorer(object):
def __init__(self):
pass
def score(self, hypothesis, corpus, n=1):
count = [0, 0, 0, 0]
clip_count = [0, 0, 0, 0]
r = 0
c = 0
weights = [0.25, 0.25, 0.25, 0.25]
for (hyps, refs) in zip(hypothesis, corpus):
if (type(hyp... |
(derivate=True, coderize=True)
_loss
def custom_gaussian_focal_loss(pred, gaussian_target, pos_inds=None, alpha: float=(- 1), beta: float=4, gamma: float=2, sigmoid_clamp: float=0.0001, ignore_high_fp: float=(- 1.0)):
pred = torch.clamp(pred.sigmoid_(), min=sigmoid_clamp, max=(1 - sigmoid_clamp))
neg_weights = ... |
def test_err(capfd):
msg = 'Something that should not show up in log'
stream = StringIO()
with redirect_stderr(stream):
m.raw_err(msg)
(stdout, stderr) = capfd.readouterr()
assert (stdout == '')
assert (stderr == msg)
assert (stream.getvalue() == '')
stream = StringIO()
with ... |
def global_tempdir_manager():
global _tempdir_manager
with ExitStack() as stack:
(old_tempdir_manager, _tempdir_manager) = (_tempdir_manager, stack)
try:
(yield)
finally:
_tempdir_manager = old_tempdir_manager |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.