code stringlengths 101 5.91M |
|---|
def _get_required_attr(element: Element, attr: str) -> str:
attribute = element.get(attr)
if (attribute is None):
raise MusicXMLError(f"Attribute '{attr}' is required for an '{element.tag}' element.")
return attribute |
def get_user_seqs(data_file):
lines = open(data_file).readlines()
user_seq = []
item_set = set()
for line in lines:
(user, items) = line.strip().split(' ', 1)
items = items.split(' ')
items = [int(item) for item in items]
user_seq.append(items)
item_set = (item_se... |
class BufferReader():
def __init__(self, buffer: bytes):
self.buffer = buffer
self.read_offset = 0
def bytes_left(self):
return (len(self.buffer) - self.read_offset)
def unpack_f(self, s_format: str):
if (not hasattr(ConstStructs, s_format)):
le_format: str = ('<'... |
class AverageOfMaximumScoreEnsembler(PYODScoreEnsembler):
def __init__(self, n_buckets=5, method='static', bootstrap_estimators=False):
self.method = method
self.n_buckets = n_buckets
self.bootstrap_estimators = bootstrap_estimators
def _combine(self, scores):
return aom(scores, ... |
def calculate_matvec_accumulator_range(matrix, vec_dt):
min_weight = matrix.min()
max_weight = matrix.max()
perceptive_field_elems = matrix.shape[0]
min_input = vec_dt.min()
max_input = vec_dt.max()
acc_min = (perceptive_field_elems * min((min_weight * max_input), (min_weight * min_input), (max_... |
def convert_path_to_npy(*, path='train_64x64', outfile='train_64x64.npy'):
assert isinstance(path, str), 'Expected a string input for the path'
assert os.path.exists(path), "Input path doesn't exist"
files = [f for f in listdir(path) if isfile(join(path, f))]
print('Number of valid images is:', len(file... |
def _format(val: Any, output_format: str='standard', errors: str='coarse') -> Any:
val = str(val)
result: Any = []
if (val in NULL_VALUES):
return [np.nan]
if (not validate_it_iva(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
error_re... |
class IRBlock(nn.Module):
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_type='batch', use_se=True):
super(IRBlock, self).__init__()
norm_layer = build_norm(norm_type, dimension=2)
self.bn0 = norm_layer(inplanes)
self.conv1 = nn.Conv2d(inplanes, planes, kernel_s... |
def acos_safe(x: Scalar, epsilon: Scalar=epsilon()) -> Scalar:
x_safe = Max(((- 1) + epsilon), Min((1 - epsilon), x))
return sympy.acos(x_safe) |
def eval_sighan2015_by_model(correct_fn, sighan_path=sighan_2015_path, verbose=True):
TP = 0.0
FP = 0.0
FN = 0.0
TN = 0.0
total_num = 0
start_time = time.time()
with open(sighan_path, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line.star... |
def florisPw(u_stream, tis, xs, ys, yws):
if (curl == True):
fi.floris.farm.set_wake_model('curl')
fi.reinitialize_flow_field(wind_speed=u_stream)
fi.reinitialize_flow_field(turbulence_intensity=tis)
fi.reinitialize_flow_field(layout_array=[xs, ys])
fi.calculate_wake(yaw_angles=yws)
flor... |
def StackedRNN(inners, num_layers, lstm=False, dropout=0, train=True):
num_directions = len(inners)
total_layers = (num_layers * num_directions)
def forward(input, hidden, weight, batch_sizes):
assert (len(weight) == total_layers)
next_hidden = []
if lstm:
hidden = list(z... |
class ResizeShortestEdge(T.Augmentation):
def __init__(self, short_edge_length, max_size=sys.maxsize, sample_style='range', interp=Image.BILINEAR, clip_frame_cnt=1):
super().__init__()
assert (sample_style in ['range', 'choice', 'range_by_clip', 'choice_by_clip']), sample_style
self.is_range... |
class TestDivision(object):
def test_division_int(self):
x = np.array([5, 10, 90, 100, (- 5), (- 10), (- 90), (- 100), (- 120)])
if ((5 / 10) == 0.5):
assert_equal((x / 100), [0.05, 0.1, 0.9, 1, (- 0.05), (- 0.1), (- 0.9), (- 1), (- 1.2)])
else:
assert_equal((x / 100)... |
def test_alias_delay_initialization1(capture):
class B(m.A):
def __init__(self):
super(B, self).__init__()
def f(self):
print('In python f()')
with capture:
a = m.A()
m.call_f(a)
del a
pytest.gc_collect()
assert (capture == 'A.f()')
... |
class RandomSplit(NamedTuple):
train_sentences: List[Sentence]
dev_sentences: List[Sentence]
test_sentences: List[Sentence] |
class PlyProperty(object):
def __init__(self, name, val_dtype):
_check_name(name)
self._name = str(name)
self.val_dtype = val_dtype
def _get_val_dtype(self):
return self._val_dtype
def _set_val_dtype(self, val_dtype):
self._val_dtype = _data_types[_lookup_type(val_dty... |
def build_alphabet(data=None, names=None, name=None):
if ((name is not None) and ((data is not None) or (names is not None))):
raise ValueError('name cannot be specified with any other argument')
if (isinstance(names, (int, Integer)) or (names == Infinity) or ((data is None) and (names is not None))):
... |
def imsave(path, img, channel_first=False, as_uint16=False, auto_scale=True, **kwargs):
best_backend = backend_manager.get_best_backend(path, 'save')
best_backend.imsave(path, img, channel_first=channel_first, as_uint16=as_uint16, auto_scale=auto_scale, **kwargs) |
_module()
class VeryDeepVgg(BaseModule):
def __init__(self, leaky_relu=True, input_channels=3, init_cfg=[dict(type='Xavier', layer='Conv2d'), dict(type='Uniform', layer='BatchNorm2d')]):
super().__init__(init_cfg=init_cfg)
ks = [3, 3, 3, 3, 3, 3, 2]
ps = [1, 1, 1, 1, 1, 1, 0]
ss = [1... |
class SideObstacleSetBBreakoutWorld(RandomSideObstacleBreakoutWorld):
side_obstacle_width_range_start = 15
side_obstacle_width_range_end = 20 |
class FeatureWrapper(torch.utils.data.Dataset):
def __init__(self, data_source, feature_path):
self.data_source = data_source
self.features = torch.load(feature_path)
def __len__(self):
return len(self.data_source)
def __getitem__(self, idx):
item = self.data_source[idx]
... |
def count_parameters(model):
total_params = 0
for (name, parameter) in model.named_parameters():
if (not parameter.requires_grad):
continue
params = parameter.numel()
print(name, params)
total_params += params
print(f'Total Trainable Params: {total_params}')
r... |
class Runtime():
def __init__(self, worker_pool_factory):
self._get_worker_pool = worker_pool_factory
def inline(cls):
return cls(inline_pool_factory)
def run(self, query, args, combiner=union_combiner, randomize=True, chunksize=1, progress=False, profile=False, print_error=True):
wi... |
def are_projectively_equivalent(P, Q, base_ring):
from sage.matrix.constructor import matrix
return (matrix(base_ring, [P, Q]).rank() < 2) |
.xfail(_IS_WASM, reason='cannot start subprocess')
def test_imports_strategies():
good_import = '\n from sklearn.experimental import enable_halving_search_cv\n from sklearn.model_selection import HalvingGridSearchCV\n from sklearn.model_selection import HalvingRandomSearchCV\n '
assert_run_python_sc... |
def script_model_defines_attr(script_model, attr):
script_attr = getattr(script_model, attr, None)
if (script_attr is None):
return False
default_attr = get_function_from_type(torch.jit.RecursiveScriptModule, attr)
if (default_attr is None):
return False
return (script_attr != defaul... |
class CollectionNode(Node):
def __init__(self, tag, value, start_mark=None, end_mark=None, flow_style=None):
self.tag = tag
self.value = value
self.start_mark = start_mark
self.end_mark = end_mark
self.flow_style = flow_style |
def do_structure(cfg):
if isinstance(cfg, CfgNode):
model = build_model(cfg)
else:
model = instantiate(cfg.model)
logger.info(('Model Structure:\n' + str(model))) |
def write_model_card(model_card_dir, src_lang, tgt_lang, model_name):
texts = {'en': "Machine learning is great, isn't it?", 'ru': ' - , ?', 'de': 'Maschinelles Lernen ist groartig, nicht wahr?'}
scores = {'wmt19-de-en-6-6-base': [0, 38.37], 'wmt19-de-en-6-6-big': [0, 39.9]}
pair = f'{src_lang}-{tgt_lan... |
def DrawGLScene():
glClear((GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT))
glLoadIdentity()
glutSwapBuffers() |
def step_decay(optimizer, step, lr, decay_step, gamma):
lr = (lr * (gamma ** (step / decay_step)))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
return lr |
def test_channel_first() -> None:
env = DummyAtari(grayscale=False)
assert env.observation_space.shape
(width, height, channel) = env.observation_space.shape
wrapper = ChannelFirst(env)
(observation, _) = wrapper.reset()
assert (observation.shape == (channel, width, height))
(observation, _,... |
class SemiSupervisedTrainingPlan(TrainingPlan):
def __init__(self, module: BaseModuleClass, n_classes: int, *, classification_ratio: int=50, lr: float=0.001, weight_decay: float=1e-06, n_steps_kl_warmup: Union[(int, None)]=None, n_epochs_kl_warmup: Union[(int, None)]=400, reduce_lr_on_plateau: bool=False, lr_factor... |
def _train_test_metrics(args_namespace):
return train_test_metrics(args_namespace.train_dataset_path, args_namespace.test_dataset_path, args_namespace.output_path, args_namespace.config_path, args_namespace.exclude_slot_metrics, args_namespace.include_errors, args_namespace.verbosity) |
def test_load_csvs_folder_does_not_exist():
error_message = re.escape("The folder 'demo/' cannot be found.")
with pytest.raises(ValueError, match=error_message):
load_csvs('demo/') |
def apply_filters(sentence, filters):
for f in filters:
sentence = f(sentence)
return sentence |
(config_name='config', config_path='conf')
def main(cfg: DictConfig) -> None:
logging.info(('\n' + OmegaConf.to_yaml(cfg)))
train_device = _get_device(cfg.framework.gpu)
env_device = _get_device(cfg.framework.env_gpu)
logging.info(('Using training device %s.' % str(train_device)))
logging.info(('Usi... |
_utils.test(debug=True)
def test_assign_ann():
def func_ann():
a: ti.i32 = 1
b: ti.f32 = a
assert (a == 1)
assert (b == 1.0)
func_ann() |
class SeqCLDataset(th.utils.data.Dataset):
def __init__(self, data: Sequence):
super().__init__()
self.d = data
def __getitem__(self, node_id):
item = self.d.get_tokens(node_id)
neighbours = self.d.neighbours[node_id]
k = np.random.choice(neighbours, 1)
item = sel... |
def s_load(file_obj):
cur_elt = []
for line in file_obj:
if (line == b'\n'):
encoded_elt = b''.join(cur_elt)
try:
pickled_elt = base64.b64decode(encoded_elt)
elt = loads(pickled_elt)
except EOFError:
print('EOF found whi... |
.parametrize('embedding_size,cross_num,hidden_size,sparse_feature_num', [(8, 0, (32,), 2), (8, 1, (32,), 2)])
def test_DCNMix(embedding_size, cross_num, hidden_size, sparse_feature_num):
model_name = 'DCN-Mix'
sample_size = SAMPLE_SIZE
(x, y, feature_columns) = get_test_data(sample_size, sparse_feature_num=... |
def lr_grad(w, X, y, lam=0):
y[(y == 0)] = (- 1)
z = torch.sigmoid((y * X.mv(w)))
return (X.t().mv(((z - 1) * y)) + ((lam * X.size(0)) * w)) |
def register_optimizer_class(cls, name=None):
_init_optimizer_classes_dict()
if (not name):
name = cls.__name__
_check_valid_optimizer(cls)
assert (name.lower() not in _OptimizerClassesDict)
_OptimizerClassesDict[name.lower()] = cls
if name.endswith('Optimizer'):
name = name[:(- ... |
class AttnSkipUpBlock2D(nn.Module):
def __init__(self, in_channels: int, prev_output_channel: int, out_channels: int, temb_channels: int, dropout: float=0.0, num_layers: int=1, resnet_eps: float=1e-06, resnet_time_scale_shift: str='default', resnet_act_fn: str='swish', resnet_pre_norm: bool=True, attn_num_head_chan... |
(Output('anomaly-attribute-options', 'children'), Output('anomaly_exception_modal', 'is_open'), Output('anomaly_exception_modal_content', 'children'), [Input('anomaly-btn', 'n_clicks'), Input('anomaly_exception_modal_close', 'n_clicks')], [State('log-type-select', 'value'), State('attribute-name-options', 'value'), Sta... |
def shift_stats_container(sc, num_of_shifting_factors):
shifting_factor = np.random.random(num_of_shifting_factors)
shifted_sc = shift_statistics(sc, shifting_factor)
return (shifted_sc, shifting_factor) |
def update_plot(policy, max_length=np.inf):
queue.put(['demo', policy.get_param_values(), max_length]) |
def init_params(net):
for m in net.modules():
if (isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d)):
init.kaiming_normal_(m.weight, mode='fan_out')
if (m.bias.data is not None):
init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
... |
class VQVAE(tfk.Model):
def __init__(self, encoder, decoder, codebook_size, beta=0.25):
super(VQVAE, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.quantizer = VectorQuantizerEMA(codebook_size)
self.beta = beta
def quantize(self, x):
if (not s... |
class PythonInliner(ast.NodeTransformer):
def __init__(self, target_id, target_ast):
self.target_id = target_id
self.target_ast = target_ast
def visit_Name(self, node: ast.AST):
if (node.id == self.target_id):
return ast.copy_location(self.target_ast, node)
else:
... |
def random_hex():
r = (lambda : np.random.randint(0, 255))
return ('#%02X%02X%02X' % (r(), r(), r())) |
def get_parent(config: Dict[(str, Any)]) -> Optional[str]:
if (config['load_from'] is None):
return None
return config['load_from'].rsplit('/', maxsplit=1)[0] |
class BaseTransformersCLICommand(ABC):
def register_subcommand(parser: ArgumentParser):
raise NotImplementedError()
def run(self):
raise NotImplementedError() |
def xcorr_slow(x, kernel):
batch = x.size()[0]
out = []
for i in range(batch):
px = x[i]
pk = kernel[i]
px = px.view(1, px.size()[0], px.size()[1], px.size()[2])
pk = pk.view((- 1), px.size()[1], pk.size()[1], pk.size()[2])
po = F.conv2d(px, pk)
out.append(po)... |
def _map_slice_value_raw(v: Union[(None, slice, int, numpy.number, numpy.ndarray, Tensor[T])]) -> Union[(None, slice, int, numpy.number, T)]:
if (v is None):
return None
if isinstance(v, slice):
return slice(_map_slice_value_raw(v.start), _map_slice_value_raw(v.stop), _map_slice_value_raw(v.step... |
class SageNotebookInteractiveShell(SageShellOverride, InteractiveShell):
def init_display_formatter(self):
from sage.repl.rich_output.backend_ipython import BackendIPythonNotebook
backend = BackendIPythonNotebook()
backend.get_display_manager().switch_backend(backend, shell=self) |
_module()
class VFNet(SingleStageDetector):
'Implementation of `VarifocalNet\n (VFNet).<
def __init__(self, backbone, neck, bbox_head, train_cfg=None, test_cfg=None, pretrained=None, init_cfg=None):
super(VFNet, self).__init__(backbone, neck, bbox_head, train_cfg, test_cfg, pretrained, init_cfg) |
def test_get_path_accessible(accessible_path, workspace_root):
workspace = Workspace(workspace_root, True)
full_path = workspace.get_path(accessible_path)
assert full_path.is_absolute()
assert full_path.is_relative_to(workspace_root) |
class ModelArguments():
model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
tokenizer_name: Optional[s... |
def test_orthogonal_procrustes_checkfinite_exception():
np.random.seed(1234)
(m, n) = (2, 3)
A_good = np.random.randn(m, n)
B_good = np.random.randn(m, n)
for bad_value in (np.inf, (- np.inf), np.nan):
A_bad = A_good.copy()
A_bad[(1, 2)] = bad_value
B_bad = B_good.copy()
... |
def srwl_uti_cryst_ASF(_s, _mat='Si'):
fa = None
fa0 = 0
if (_mat == 'Si'):
fa = [6.2915, 2.4386, 3.0353, 32.3337, 1.9891, 0.6785, 1.541, 81.6937, 1.1407]
fa0 = 13.985
else:
raise Exception(strMatDataNotDefined)
s2 = (_s * _s)
if (s2 != 0):
f0 = (((((fa[0] * exp((... |
def nparray(named_tensor):
proto = named_tensor.transformer_metadata.pop()
metadata = {'int_to_float': proto.int_to_float, 'int_list': proto.int_list, 'bool_list': proto.bool_list}
array_shape = tuple(metadata['int_list'])
flat_array = np.frombuffer(named_tensor.data_bytes, dtype=np.float32)
nparray... |
class Table(object):
def __init__(self, dataset, version):
self.dataset = dataset
self.version = version
self.name = f'{self.dataset}_{self.version}'
L.info(f'start building data {self.name}...')
self.data = pd.read_pickle(((DATA_ROOT / self.dataset) / f'{self.version}.pkl'))... |
def get_cpp_decl_type(typename, ensure_temp_safe=True):
if ensure_temp_safe:
typename = TEMP_SAFE_CPP_DECL_TYPE.get(typename, typename)
return typename |
class Fantasizer(GreedyAcquisitionFunctionBuilder[FantasizerModelOrStack]):
def __init__(self, base_acquisition_function_builder: Optional[(AcquisitionFunctionBuilder[SupportsPredictJoint] | SingleModelAcquisitionBuilder[SupportsPredictJoint])]=None, fantasize_method: str='KB'):
tf.debugging.Assert((fantasi... |
class State(Borg):
def __init__(self, session: Optional[SparkSession]=None):
Borg.__init__(self)
if (not hasattr(self, 'logger_set')):
self.logger = logger_with_settings()
self.logger_set = True
if (session is None):
if (not hasattr(self, 'session')):
... |
class DebugPrompts(Prompts):
def in_prompt_tokens(self, cli=None):
return [(Token.Prompt, 'debug: ')]
def continuation_prompt_tokens(self, cli=None, width=None):
return [(Token.Prompt, '.....: ')]
def rewrite_prompt_tokens(self):
return [(Token.Prompt, '-----> ')]
def out_prompt_... |
class IndexVocab(Configurable):
ROOT = 0
def __init__(self, *args, **kwargs):
super(IndexVocab, self).__init__(*args, **kwargs)
self.placeholder = None
def generate_placeholder(self):
if (self.placeholder is None):
self.placeholder = tf.placeholder(tf.int32, shape=[None, ... |
class ResNetABN(nn.Module):
def __init__(self, block, layers, num_classes=10, num_bns=2, first_layer_conv=3):
self.inplanes = 64
self.num_bns = num_bns
self.num_classes = num_classes
super(ResNetABN, self).__init__()
self.conv1 = conv3x3(3, 64, kernel_size=first_layer_conv)
... |
.parametrize(['packet_params', 'expected_params'], [({'nu_line': 0.1, 'next_line_id': 0, 'is_last_line': True}, {'tardis_error': None, 'd_line': 1e+99}), ({'nu_line': 0.2, 'next_line_id': 1, 'is_last_line': False}, {'tardis_error': None, 'd_line': 7.e+17}), ({'nu_line': 0.5, 'next_line_id': 1, 'is_last_line': False}, {... |
def test_trainable_variables():
(trackable_layer, variables, modules, module_variables) = setup_layer_modules_variables()
all_vars = (variables + module_variables)
trainable_variables = [v for v in all_vars if v.trainable]
assert (to_tensor_set(trackable_layer.trainable_variables) == to_tensor_set(train... |
.skip(reason='Covered more efficiently by test_train.test_run_experiment')
def test_experiment_config_parser(tmp_path):
tmp_data_dir = (tmp_path / 'tmpdata')
cfg_fname = os.path.join(Config.get_dir(), 'experiments.json')
cfg = memcnn.experiment.factory.load_experiment_config(cfg_fname, ['cifar10', 'resnet11... |
class NumberConverter(BaseConverter):
weight = 50
def __init__(self, map, fixed_digits=0, min=None, max=None, signed=False):
if signed:
self.regex = self.signed_regex
BaseConverter.__init__(self, map)
self.fixed_digits = fixed_digits
self.min = min
self.max = ... |
def spline_basis(pseudo: torch.Tensor, kernel_size: torch.Tensor, is_open_spline: torch.Tensor, degree: int) -> Tuple[(torch.Tensor, torch.Tensor)]:
return torch.ops.torch_spline_conv.spline_basis(pseudo, kernel_size, is_open_spline, degree) |
class Options():
def __init__(self):
self.parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
self.parser.add_argument('--dataset', default='cifar10', help='folder | cifar10 | mnist ')
self.parser.add_argument('--dataroot', default='', help='path to datas... |
def resize_target(target, size):
new_target = np.zeros((target.shape[0], size, size), np.int32)
for (i, t) in enumerate(target.numpy()):
new_target[(i, ...)] = cv2.resize(t, ((size,) * 2), interpolation=cv2.INTER_NEAREST)
return torch.from_numpy(new_target).long() |
def _get_test_keep_instance_predicate(cfg: CfgNode):
general_keep_predicate = _maybe_create_general_keep_instance_predicate(cfg)
return general_keep_predicate |
class ConvTBC(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, padding=0):
super(ConvTBC, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = _single(kernel_size)
self.padding = _single(padding)
... |
class _TensorMixin(_TensorMixinBase):
def from_tensor(x) -> Tensor:
assert x.get_shape().is_fully_defined()
x_shape = x.get_shape().as_list()
return _t.Tensor(name=str(x.op.name), shape=x_shape, batch_dim_axis=None, dtype=x.dtype.name, placeholder=x)
def template_from_constant(x, name, d... |
def procedure(xloader, teacher, network, criterion, scheduler, optimizer, mode, config, extra_info, print_freq, logger):
(data_time, batch_time, losses, top1, top5) = (AverageMeter(), AverageMeter(), AverageMeter(), AverageMeter(), AverageMeter())
(Ttop1, Ttop5) = (AverageMeter(), AverageMeter())
if (mode =... |
def test_encoder():
img_feat = torch.randn(4, 36, 2048)
seq_size = 20
ques = torch.randperm(seq_size).view(1, seq_size)
ques = ques.unsqueeze(1).repeat(4, 10, 1)
ques_len = torch.LongTensor([6, 5, 4, 3]).unsqueeze(1).repeat(1, 10) |
def test_unmatched_lengths_2d_np_array():
y_true = np.array([[1, 2, 3], [1, 2, 4], [1, 5, 6], [1, 5, 8]])
y_pred = np.array([[1, 2, 3], [1, 2, 4]])
with pytest.raises(AssertionError):
precision(y_true, y_pred) |
class CarlaEngine():
def __init__(self, config, traffic_manager, carla_observers):
self._running = False
self.config = config
self._traffic_manager = traffic_manager
self._carla_process = None
self._carla_simulation = None
self._carla_sensors = []
self._carla_... |
class TestSamplerDeterministic(unittest.TestCase):
def test_to_iterable(self):
sampler = TrainingSampler(100, seed=10)
dataset = DatasetFromList(list(range(100)))
dataset = ToIterableDataset(dataset, sampler)
data_loader = data.DataLoader(dataset, num_workers=0, collate_fn=operator.i... |
class GELU_SENet(nn.Module):
def __init__(self, block, num_blocks, num_classes=10):
super(GELU_SENet, self).__init__()
self.in_planes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._make_laye... |
.openapi_version('3.0')
.operations('success')
def test_process_call_kwargs(testdir, cli, cli_args, mocker, app_type):
module = testdir.make_importable_pyfile(hook='\nimport schemathesis\nimport requests\n\\ndef process_call_kwargs(context, case, kwargs):\n if case.app is not None:\n kwargs["follow_redire... |
(('%s.visualize_utils.mmcv' % __name__))
def test_show_pred_gt(mock_mmcv):
preds = [[0, 0, 1, 0, 1, 1, 0, 1]]
gts = [[0, 0, 1, 0, 1, 1, 0, 1]]
show = True
win_name = 'test'
wait_time = 0
out_file = tempfile.NamedTemporaryFile().name
with pytest.raises(AssertionError):
visualize_utils... |
class ResNet_context(nn.Module):
def __init__(self, num_classes, disable_self_attn, pretrained):
self.num_ch_enc = np.array([128, 256, 512, 1024, 2048])
self.disable_self_attn = disable_self_attn
super(ResNet_context, self).__init__()
self.basedir = os.path.dirname(os.path.abspath(__... |
def level__Tornaria(self):
return self.base_ring()(((abs(self.disc()) / self.omega()) / (self.content() ** self.dim()))) |
def dump_raw_data(contents, file_path):
with open(file_path, 'w') as ouf:
writer = csv.writer(ouf, delimiter='\t', quotechar='"')
for line in contents:
writer.writerow(line) |
def get_server_partition_dataset(data_path, data_name, part_id):
part_name = os.path.join(data_name, ('partition_' + str(part_id)))
path = os.path.join(data_path, part_name)
if (not os.path.exists(path)):
print('Partition file not found.')
exit()
train_path = os.path.join(path, 'train.tx... |
def advect():
for i in range(n_tracer):
p = tracer[i]
v1 = compute_u_full(p)
v2 = compute_u_full((p + ((v1 * dt) * 0.5)))
v3 = compute_u_full((p + ((v2 * dt) * 0.75)))
tracer[i] += (((((2 / 9) * v1) + ((1 / 3) * v2)) + ((4 / 9) * v3)) * dt) |
def test_superb_er():
with tempfile.TemporaryDirectory() as tempdir:
with pseudo_audio([10, 2, 1, 8, 5]) as (wav_paths, num_samples):
class TestER(SuperbER):
def default_config(self) -> dict:
config = super().default_config()
config['prepar... |
class DenseLayer(nn.Module):
def __init__(self, num_input_features, growth_rate, bn_size, norm_layer=BatchNormAct2d, drop_rate=0.0, memory_efficient=False):
super(DenseLayer, self).__init__()
(self.add_module('norm1', norm_layer(num_input_features)),)
(self.add_module('conv1', nn.Conv2d(num_... |
.gpu
def test_pythonmode():
def runs_on_gpu(a: (dace.float64[20] StorageType.GPU_Global), b: (dace.float64[20] StorageType.GPU_Global)):
for i in (dace.map[0:20] ScheduleType.GPU_Device):
b[i] = (a[i] + 1.0)
gpu_a = cupy.random.rand(20)
gpu_b = cupy.random.rand(20)
runs_on_gpu(gpu... |
def extend_phyche_index(original_index, extend_index):
if (0 == len(extend_index)):
return original_index
for key in list(original_index.keys()):
original_index[key].extend(extend_index[key])
return original_index |
class ResnetBlock(nn.Module):
def __init__(self, dim, kernel_size=1, padding_type='zero', norm_layer=nn.BatchNorm2d, use_dropout=False, use_bias=True, act=None):
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, kernel_size, padding_type, norm_layer, use_dropout, use_b... |
def bert_large_uncased_whole_word_maskings_384_4p_bw12_async_pipedream():
return dict(model_type='bert_squad', model_name_or_path='bert-large-uncased-whole-word-masking', do_lower_case=True, output_past=False, stateless_tied=False, explicitly_set_dict={'precompute_attention_mask': True, 'return_dict': False}, do_re... |
class FrameStack(gym.Wrapper):
def __init__(self, env, n_frames):
super().__init__(env)
self.n_frames = n_frames
self.frames = deque([], maxlen=n_frames)
shape = ((n_frames,) + env.observation_space.shape)
self.observation_space = gym.spaces.Box(low=np.min(env.observation_spa... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.