code stringlengths 101 5.91M |
|---|
def rcEvaluator(rules: Iterable[Rule], labelSettings: LabelSettings=_lsString) -> RCEvaluator:
return libpymod._rcEvaluator(_wrap(libpymod._VecRule, rules), labelSettings) |
def get_grad(params):
if isinstance(params, torch.Tensor):
params = [params]
params = list(filter((lambda p: (p.grad is not None)), params))
grad = [p.grad.data.cpu().view((- 1)) for p in params]
return torch.cat(grad) |
class NLIReader(object):
LABEL_MAP = {'entailment': 0, 'neutral': 1, 'contradiction': 2}
def __init__(self, lowercase=True, filter_length=0):
self.lowercase = lowercase
self.filter_length = (filter_length if (filter_length is not None) else 0)
def build(lowercase=True, filter_length=0):
... |
def build_dataset(dataset_list, transforms, dataset_catalog, is_train=True):
if (not isinstance(dataset_list, (list, tuple))):
raise RuntimeError('dataset_list should be a list of strings, got {}'.format(dataset_list))
datasets = []
for dataset_name in dataset_list:
data = dataset_catalog.ge... |
_sz(2)
def linear(x):
(fw, to_dtype, eps) = set_framework_dependencies(x)
return (((x + 1) * to_dtype((((- 1) <= x) & (x < 0)))) + ((1 - x) * to_dtype(((0 <= x) & (x <= 1))))) |
class Pip_resnet18(nn.Module):
def __init__(self, resnet, num_nb, num_lms=68, input_size=256, net_stride=32):
super(Pip_resnet18, self).__init__()
self.num_nb = num_nb
self.num_lms = num_lms
self.input_size = input_size
self.net_stride = net_stride
self.conv1 = resnet... |
def test_operator_new_delete(capture):
class SubAliased(m.AliasedHasOpNewDelSize):
pass
with capture:
a = m.HasOpNewDel()
b = m.HasOpNewDelSize()
d = m.HasOpNewDelBoth()
assert (capture == '\n A new 8\n B new 4\n D new 32\n ')
sz_alias = str(m.Alia... |
class MobileNetV3(object):
__shared__ = ['norm_type']
def __init__(self, scale=1.0, model_name='small', feature_maps=[5, 6, 7, 8, 9, 10], conv_decay=0.0, norm_type='bn', norm_decay=0.0, extra_block_filters=[[256, 512], [128, 256], [128, 256], [64, 128]], lr_mult_list=[1.0, 1.0, 1.0, 1.0, 1.0], freeze_norm=False... |
class ROIBoxHead(torch.nn.Module):
def __init__(self, cfg, in_channels, BBAM=False):
super(ROIBoxHead, self).__init__()
self.BBAM = BBAM
self.feature_extractor = make_roi_box_feature_extractor(cfg, in_channels)
self.predictor = make_roi_box_predictor(cfg, self.feature_extractor.out_c... |
_end_docstrings(INIT_TOKENIZER_DOCSTRING)
class PreTrainedTokenizerBase(SpecialTokensMixin, PushToHubMixin):
vocab_files_names: Dict[(str, str)] = {}
pretrained_vocab_files_map: Dict[(str, Dict[(str, str)])] = {}
pretrained_init_configuration: Dict[(str, Dict[(str, Any)])] = {}
max_model_input_sizes: Di... |
def pose_net(image, name):
with tf.variable_scope(name) as scope:
is_BN = False
pose_conv1 = conv2d(image, 512, 3, 1, relu=True, bn=is_BN, name='pose_conv1')
pose_conv2 = conv2d(pose_conv1, 512, 3, 1, relu=True, bn=is_BN, name='pose_conv2')
pose_conv3 = conv2d(pose_conv2, 256, 3, 1, ... |
def sort_batch_by_length(tensor: torch.Tensor, sequence_lengths: torch.Tensor):
(sorted_sequence_lengths, permutation_index) = sequence_lengths.sort(0, descending=True)
sorted_tensor = tensor.index_select(0, permutation_index)
index_range = Variable(torch.arange(0, len(sequence_lengths)).long()).cuda()
... |
class Policy():
def get_priority(self, now: float, seq_group: SequenceGroup) -> float:
invalidInputError(False, 'base class not implemented')
def sort_by_priority(self, now: float, seq_groups: List[SequenceGroup]) -> List[SequenceGroup]:
return sorted(seq_groups, key=(lambda seq_group: self.get_... |
def get_config(_):
agent = sprite.Sprite(x=0.5, y=0.5, shape='circle', scale=0.04, c0=0.33, c1=1.0, c2=0.66)
annulus_vertices = shapes.annulus_vertices(inner_radius=0.08, outer_radius=0.3)
agent_annulus = sprite.Sprite(x=0.5, y=0.5, shape=annulus_vertices, scale=1.0, c0=0.6, c1=1.0, c2=1.0)
max_predator... |
def main(opts):
n2bb = _compute_all_nbb(opts.img_dir, opts.conf_th, opts.max_bb, opts.min_bb, opts.nproc)
with open(f'{opts.img_dir}/nbb_th{opts.conf_th}_max{opts.max_bb}_min{opts.min_bb}.json', 'w') as f:
json.dump(n2bb, f)
corrupts = [f for (f, n) in n2bb.items() if (n is None)]
if corrupts:
... |
class BaseEnv(gym.Env):
def __init__(self, config: EnvContext):
super().__init__()
self.record = config.get('record', False)
self.replay_suffix = config.get('replay_suffix', '')
self.print_log = config.get('detailed_log', False)
self.seed(config['random_seed'])
self.s... |
('mmdet.apis.single_gpu_test', MagicMock)
('mmdet.apis.multi_gpu_test', MagicMock)
.parametrize('EvalHookParam', (EvalHook, DistEvalHook))
def test_evaluation_hook(EvalHookParam):
dataloader = DataLoader(torch.ones((5, 2)))
with pytest.raises(TypeError):
EvalHookParam(dataloader=MagicMock(), interval=(-... |
def _fixed_padding(kernel_size, dilation):
kernel_size_effective = (kernel_size + ((kernel_size - 1) * (dilation - 1)))
pad_total = (kernel_size_effective - 1)
pad_beg = (pad_total // 2)
pad_end = (pad_total - pad_beg)
return [pad_beg, pad_end, pad_beg, pad_end] |
class VanStage(nn.Module):
def __init__(self, config: VanConfig, in_channels: int, hidden_size: int, patch_size: int, stride: int, depth: int, mlp_ratio: int=4, drop_path_rate: float=0.0):
super().__init__()
self.embeddings = VanOverlappingPatchEmbedder(in_channels, hidden_size, patch_size, stride)
... |
class TestNetSpec(unittest.TestCase):
def load_net(self, net_proto):
f = tempfile.NamedTemporaryFile(mode='w+', delete=False)
f.write(str(net_proto))
f.close()
return caffe.Net(f.name, caffe.TEST)
def test_lenet(self):
net_proto = lenet(50)
self.assertEqual(net_pr... |
def autocrop(inputs, cropping):
if (cropping is None):
return inputs
else:
ndim = inputs[0].ndim
if (not all(((input.ndim == ndim) for input in inputs))):
raise ValueError('Not all inputs are of the same dimensionality. Got {0} inputs of dimensionalities {1}.'.format(len(inpu... |
class AdaptiveBasicBlock(nn.Module):
expansion = 1
def __init__(self, bottleneck_settings, stride=1, downsample=None):
super(AdaptiveBasicBlock, self).__init__()
(conv1_in_ch, conv1_out_ch) = bottleneck_settings['conv1']
self.conv1 = conv3x3(conv1_in_ch, conv1_out_ch, stride)
sel... |
class FScoreQuantity(MonitoredQuantity):
def __init__(self, average='macro', threshold=0.5, **kwargs):
self.average = average
self.threshold = threshold
super(FScoreQuantity, self).__init__(**kwargs)
def initialize(self):
(self.total_f_score, self.examples_seen) = (0.0, 0)
de... |
class OnnxStableDiffusionInpaintPipeline(metaclass=DummyObject):
_backends = ['torch', 'transformers', 'onnx']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch', 'transformers', 'onnx'])
def from_config(cls, *args, **kwargs):
requires_backends(cls, ['torch', 'transformers... |
class Trainer(TrainerBase):
def __init__(self, args, train_loader=None, val_loader=None, test_loader=None, train=True):
super().__init__(args, train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, train=train)
from gqa_model import VLT5GQA, VLBartGQA
model_kwargs = {}
... |
def extra_bitex(ted_data_path, lsrc_lang, ltrg_lang, target_token, output_data_path):
def get_ted_lang(lang):
long_langs = ['pt-br', 'zh-cn', 'zh-tw', 'fr-ca']
if (lang[:5] in long_langs):
return lang[:5]
elif (lang[:4] == 'calv'):
return lang[:5]
elif (lang i... |
class VideoDiffFramesDataset_FullBGID(Dataset):
def __init__(self, datapath, idspath, img_size, num_frames, limit):
super().__init__()
self.limit = limit
self.boarden = 0.4
self.lower_bound = max(0, (self.limit - self.boarden))
self.upper_bound = min(1, (self.limit + self.boa... |
def configure_model(model, eps, momentum, reset_stats, no_stats):
for m in model.modules():
if (isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d)):
m.train()
m.eps = eps
m.momentum = momentum
if reset_stats:
m.reset_running_stats()... |
def merge_registries(a, b):
for i in b:
a[i] = (merge_lists(a[i], b[i]) if (i in a) else b[i])
return a |
class RSU7(nn.Module):
def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
super(RSU7, self).__init__()
self.rebnconvin = REBNCONV(in_ch, out_ch, dirate=1)
self.rebnconv1 = REBNCONV(out_ch, mid_ch, dirate=1)
self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
self.rebnconv2 ... |
class LayoutLMv2TokenizerFast(metaclass=DummyObject):
_backends = ['tokenizers']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tokenizers']) |
def parse_args():
parser = argparse.ArgumentParser(description='Gather benchmarked models metric')
parser.add_argument('root', type=str, help='root path of benchmarked models to be gathered')
parser.add_argument('txt_path', type=str, help='txt path output by benchmark_filter')
parser.add_argument('--out... |
class Sum(_Reduce):
def __init__(self, dim, keepdim=False):
super().__init__(dim, keepdim, 'sum')
def from_onnx(parameters=None, attributes=None):
if (attributes is None):
attributes = {}
keepdim = _identify_bool_attributes_with_defaults(attributes, 'keepdims', 1)
ret... |
def ignore_mkt_data_buffer_decorator(func):
def wrapper_mkt_data_buffer_decorator(self, raw_state):
raw_state_copy = deepcopy(raw_state)
for i in range(len(raw_state)):
raw_state[i]['parsed_mkt_data'] = raw_state_copy[i]['parsed_mkt_data'][(- 1)]
raw_state[i]['parsed_volume_d... |
def build_model2(X_train, y_train, X_valid, y_valid, max_len, max_features, embed_size, embedding_matrix, lr=0.0, lr_d=0.0, spatial_dr=0.0, dense_units=128, conv_size=128, dr=0.2, patience=3, fold_id=1):
file_path = f'best_model_fold_{fold_id}.hdf5'
check_point = ModelCheckpoint(file_path, monitor='val_acc', ve... |
class PRNet_PAF_Vis_Shape(nn.Module):
def __init__(self, in_channels=3, out_channels=3, kernal_size_paf=3):
super().__init__()
size = 16
self.mask_conv = nn.Sequential(*padding_same_conv2d(256, 1, in_channels, kernel_size=3, stride=1), nn.BatchNorm2d(in_channels, eps=0.001, momentum=0.001), ... |
def ldcnn(bands=60, frames=31, n_classes=10, filters=80, L=57, W=6, fully_connected=5000, dropout=0.25):
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Input, Concatenate
from keras.regularizers import l2
import keras.layers
input_shape = (bands, fram... |
(before=[init], after=[post])
def con_train_e2e_test():
USR.set('dataset', 'data/e2e_aligned/')
USR.set('decoder', 'crf')
USR.set('L', '8')
USR.set('layers', '2')
USR.set('min_epochs', '8')
USR.set('posterior_reg', '1')
command = ('%(S_python_itrptr)s %(S_python_dir)s/train.py --data %(U_dat... |
class MaxTimeCriteria(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class TestMeanTeacherHook(TestCase):
def setUp(self):
self.temp_dir = tempfile.TemporaryDirectory()
def tearDown(self):
self.temp_dir.cleanup()
def test_mean_teacher_hook(self):
device = ('cuda:0' if torch.cuda.is_available() else 'cpu')
model = ToyModel2().to(device)
... |
class QDQBertForNextSentencePrediction(metaclass=DummyObject):
_backends = ['pytorch_quantization', 'torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['pytorch_quantization', 'torch']) |
def test_formants(waveform):
formants = waveform.formants()
assert isinstance(formants, dict) |
class SPAdaINResBlock(nn.Module):
def __init__(self, input_nc, planes, norm=nn.InstanceNorm1d, conv_kernel_size=1, padding=0):
super(SPAdaINResBlock, self).__init__()
self.spadain1 = SPAdaIN(norm=norm, input_nc=input_nc, planes=planes)
self.relu = nn.ReLU()
self.conv1 = nn.Conv1d(pla... |
class SpatialZeroPadding(Layer):
def __init__(self, pad_left, pad_right, pad_top, pad_bottom, bigdl_type='float'):
super(SpatialZeroPadding, self).__init__(None, bigdl_type, pad_left, pad_right, pad_top, pad_bottom) |
class TestGetData(unittest.TestCase):
('Too long')
def test_get_data(self):
target_dir = tempfile.mkdtemp()
get_data(target_dir)
self.assertFalse(os.path.isfile(os.path.join(target_dir, 'data.zip')))
self.assertTrue(os.path.isdir(os.path.join(target_dir, 'data')))
expecte... |
def main(n_splits=10, random_state=1):
logger = util.get_logger('log.txt')
logger.info('timestamp: {}'.format(datetime.now()))
start = time.time()
df = pd.read_csv('OnlineNewsPopularity.csv')
logger.info('\ntime to read in data...{:.3f}s'.format((time.time() - start)))
columns = list(df.columns)... |
class BNNeck3(nn.Module):
def __init__(self, input_dim, class_num, feat_dim, return_f=False):
super(BNNeck3, self).__init__()
self.return_f = return_f
self.reduction = nn.Conv2d(input_dim, feat_dim, 1, bias=False)
self.bn = nn.BatchNorm1d(feat_dim)
self.bn.bias.requires_grad_... |
class save_file_path(_ParseType):
def __call__(self, string: str) -> pathlib.Path:
if (not string.isprintable()):
msg = f"'{string}' must only contain printable characters."
raise argparse.ArgumentTypeError(msg)
path = pathlib.Path(string)
return path |
def create_weighted_lora_adapter(pipe, adapters, weights, adapter_name='default'):
pipe.unet.add_weighted_adapter(adapters, weights, adapter_name)
if isinstance(pipe.text_encoder, PeftModel):
pipe.text_encoder.add_weighted_adapter(adapters, weights, adapter_name)
return pipe |
class InceptConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding):
super(InceptConv, self).__init__()
self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
self.bn ... |
def test_timer_run():
timer = mmcv.Timer()
time.sleep(1)
assert (abs((timer.since_start() - 1)) < 0.01)
time.sleep(1)
assert (abs((timer.since_last_check() - 1)) < 0.01)
assert (abs((timer.since_start() - 2)) < 0.01)
timer = mmcv.Timer(False)
with pytest.raises(mmcv.TimerError):
... |
def get_test_module(test_file):
test_module_path = get_module_path(test_file)
test_module = importlib.import_module(test_module_path)
return test_module |
def convert_yuv420_to_rgb(frame: Tuple[(np.ndarray, np.ndarray, np.ndarray)], device: torch.device, max_val: int) -> Tensor:
out = to_tensors(frame, device=str(device), max_value=max_val)
out = yuv_420_to_444(tuple((c.unsqueeze(0).unsqueeze(0) for c in out)), mode='bicubic')
return ycbcr2rgb(out) |
_module()
class CheckpointHook(Hook):
def __init__(self, interval=(- 1), by_epoch=True, save_optimizer=True, out_dir=None, max_keep_ckpts=(- 1), save_last=True, sync_buffer=False, file_client_args=None, **kwargs):
self.interval = interval
self.by_epoch = by_epoch
self.save_optimizer = save_o... |
def SO_Tokenizer_wrapper(tokens):
end_of_sent_punc_split_tokens = Split_End_of_Sentence_Punc(tokens)
dot_split_tokens = []
for token in end_of_sent_punc_split_tokens:
multiple_dot_splitted_result = Split_On_Multiple_Dot(token)
if (len(multiple_dot_splitted_result) == 0):
dot_spli... |
def test_str(doc):
assert (m.str_from_string().encode().decode() == 'baz')
assert (m.str_from_bytes().encode().decode() == 'boo')
assert (doc(m.str_from_bytes) == 'str_from_bytes() -> str')
class A(object):
def __str__(self):
return 'this is a str'
def __repr__(self):
... |
class FixedSampler(object):
def __init__(self, perm_len):
assert (perm_len > 0)
self._perm_len = perm_len
def __call__(self, perm_len=None):
perm_len = (self._perm_len if (perm_len is None) else perm_len)
return np.arange(perm_len) |
class Generator_toy(torch.nn.Module):
def __init__(self, hidden_dim):
super(Generator_toy, self).__init__()
self.all_layers = nn.Sequential(nn.Linear(2, hidden_dim), nn.ReLU(True), nn.Linear(hidden_dim, hidden_dim), nn.ReLU(True), nn.Linear(hidden_dim, hidden_dim), nn.ReLU(True), nn.Linear(hidden_di... |
def test_class():
ann_str = _make_annotation_str_for_obj(Foo)
assert (ann_str == 'Type[{prefix}.Foo]'.format(prefix=__name__)), ('got %s' % ann_str)
assert (_make_annotation_str_for_obj((Foo, Foo())) == 'Tuple[Type[{prefix}.Foo], {prefix}.Foo]'.format(prefix=__name__))
assert (_make_annotation_str_for_o... |
def training_step(global_iter, model, phase, device, optimizer, loss_fn):
assert (phase in ['train', 'val'])
(batch, positives_mask, negatives_mask) = next(global_iter)
batch = {e: batch[e].to(device) for e in batch}
if (phase == 'train'):
model.train()
else:
model.eval()
optimiz... |
def load_bf16_model(path, model):
from .bfloat16 import BF16Model
return BF16Model._load(path, model) |
def compute_errors(ground_truth, pre):
l1 = np.mean(np.abs((ground_truth - pre)))
mse = np.mean(((ground_truth - pre) ** 2))
if (mse == 0):
PSNR = 100
else:
PSNR = (20 * math.log10((255.0 / math.sqrt(mse))))
gx = (pre - np.roll(pre, (- 1), axis=1))
gy = (pre - np.roll(pre, (- 1),... |
def cds_matchback(cat, xcat, colRA='RA', colDec='DEC', selection='best', epoch=None, colpmRA='pmra', colpmDec='pmdec'):
if (selection != 'all'):
selection = 'best'
if (selection == 'all'):
raise NotImplementedError("selection='all' CDS cross-match not currently implemented")
if (epoch is Non... |
def train_robosuite(args):
(train_env, from_pixels) = create_robosuite_env(args.env)
(test_env, from_pixels) = create_robosuite_env(args.env)
if (not from_pixels):
encoder = IdentityEncoder(train_env.observation_space.shape[0])
else:
raise NotImplementedError
agent = super_sac.Agent(... |
class ExplicitEnum(str, Enum):
def _missing_(cls, value):
raise ValueError(f'{value} is not a valid {cls.__name__}, please select one of {list(cls._value2member_map_.keys())}') |
def customized_resnet18(pretrained: bool=False, class_num=10, progress: bool=True) -> ResNet:
res18 = ResNet(BasicBlock, [2, 2, 2, 2], class_num=class_num)
res18.bn1 = nn.GroupNorm(num_groups=32, num_channels=64)
res18.layer1[0].bn1 = nn.GroupNorm(num_groups=32, num_channels=64)
res18.layer1[0].bn2 = nn... |
class PrepareForNet(object):
def __init__(self):
pass
def __call__(self, sample):
image = np.transpose(sample['image'], (2, 0, 1))
sample['image'] = np.ascontiguousarray(image).astype(np.float32)
if ('mask' in sample):
sample['mask'] = sample['mask'].astype(np.float32... |
def filter_tests(output_file, filters):
if (not os.path.isfile(output_file)):
print('No test file found.')
return
with open(output_file, 'r', encoding='utf-8') as f:
test_files = f.read().split(' ')
if ((len(test_files) == 0) or (test_files == [''])):
print('No tests to filte... |
def lnprob(p):
lnprior = prior(p)
if (lnprior == (- np.inf)):
return (- np.inf)
for (key, pconn) in pconns.items():
pconn.send(('LNPROB', p))
lnps = np.empty(n_chunks)
for (i, pconn) in enumerate(pconns.values()):
lnps[i] = pconn.recv()
s = np.sum(lnps)
return (s + ln... |
def test_model(dataset_loaders, model, stat_names, train_func, args, inference_func=None):
test_model_path = args.test_model
print(('Testing model loaded from %s' % test_model_path))
model.load_state_dict(torch.load(test_model_path))
with torch.no_grad():
test_stats = train_func(data_loader=data... |
def data_transforms(dataset_type='train', normlize_type='-1-1'):
transforms = {'train': Compose([ReSize(size=10.0), Reshape(), Normalize(normlize_type), RandomScale(), RandomCrop(), Retype()]), 'val': Compose([ReSize(size=10.0), Reshape(), Normalize(normlize_type), Retype()])}
return transforms[dataset_type] |
class SmallExact(Solver):
def __init__(self, init_dataset, poslabels, env, budget_per_round=1, poolsize=1000, device='cpu'):
super(SmallExact, self).__init__()
self.cur_dataset = init_dataset
self.used = set()
self.budget_per_round = budget_per_round
self.poslabels = poslabel... |
def make_vgg_layer(in_channels, out_channels, num_blocks, conv_cfg=None, norm_cfg=None, act_cfg=dict(type='ReLU'), dilation=1, with_norm=False, ceil_mode=False):
layers = []
for _ in range(num_blocks):
layer = ConvModule(in_channels=in_channels, out_channels=out_channels, kernel_size=3, dilation=dilatio... |
def get_parser():
parser = argparse.ArgumentParser(description='RIASS')
parser.add_argument('-year', dest='year', default='2017')
parser.add_argument('-imsize', dest='imsize', default=480, type=int)
parser.add_argument('-batch_size', dest='batch_size', default=10, type=int)
parser.add_argument('-num... |
def build_evaluator(task: str, metric_configs: List[Union[(str, Dict[(str, dict)])]], validate_index: int=0):
if (task == 'graph_vertex_classification'):
return GraphVertexClassificationEvaluator(metric_configs, validate_index)
elif (task == 'hypergraph_vertex_classification'):
return Hypergraph... |
def load_data(train_filename, valid_filename, test_filename, delimiter='\t', col_names=['user_id', 'item_id', 'rating']):
train_data = pd.read_csv(train_filename, delimiter=delimiter, header=None, names=col_names)
train_data['user_id'] = (train_data['user_id'] - 1)
train_data['item_id'] = (train_data['item_... |
class Seq2SeqForecaster(BasePytorchForecaster):
def __init__(self, past_seq_len, future_seq_len, input_feature_num, output_feature_num, lstm_hidden_dim=64, lstm_layer_num=2, teacher_forcing=False, normalization=True, decomposition_kernel_size=0, dropout=0.1, optimizer='Adam', loss='mse', lr=0.001, metrics=['mse'], ... |
def recursive_indicators(condition_func, x, default_indicator=False):
if (condition_func is None):
condition_func = recursive_generic_condition_func
the_indicators = recursive_apply(condition_func, (lambda _: default_indicator), x, backup_func=(lambda _: default_indicator))
return the_indicators |
def all_reduce(py_dict, op='sum', group=None):
world_size = get_world_size()
if (world_size == 1):
return py_dict
if (group is None):
group = _get_global_gloo_group()
if (dist.get_world_size(group) == 1):
return py_dict
py_key = list(py_dict.keys())
py_key_tensor = pyobj2... |
def test_recursive_find_duplicates_dir_integration(cnn):
expected_duplicates = {str(Path('lvl1/ukbench00120.jpg')): [('ukbench00120_hflip.jpg', 0.9891392), (str(Path('lvl1/lvl2b/ukbench00120_resize.jpg')), 0.), (str(Path('lvl1/lvl2a/ukbench00120_rotation.jpg')), 0.)], 'ukbench00120_hflip.jpg': [(str(Path('lvl1/lvl2... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, previous_dilation=1, norm_layer=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = norm_layer(plane... |
def _activation_to_string(activation, precision=2):
return (_num_to_string(activation, precision) + 'B') |
def run_mat(source_root_dir, target_root_dir, imname, cname):
eng = matlab.engine.start_matlab()
eng.convert_data(source_root_dir, target_root_dir, imname, cname, FINE_HEIGHT, FINE_WIDTH)
eng.quit() |
_model
def vgg13(pretrained: bool=False, **kwargs: Any) -> VGG:
model_args = dict(**kwargs)
return _create_vgg('vgg13', pretrained=pretrained, **model_args) |
class MeanZero(MeanFunction):
def __init__(self):
pass
def gpml_function(self):
return '{}'
def is_thunk(self):
return True
def id(self):
return 'Zero'
def param_vector(self):
return np.array([])
def latex(self):
return '{\\emptyset}'
def synta... |
class RockPaperScissorsMed(RockPaperScissors):
def compute_labels(cls, limit=20):
all_labels = string.ascii_lowercase[:limit]
train = []
dev = []
train_vocab = set()
for i in range(0, (len(all_labels) - 5), 2):
(a, b, c, d, e) = all_labels[i:(i + 5)]
f... |
def get_harmonics_to_noise_ratio(waveform, sample_rate, min_pitch=75.0, silence_threshold=0.1, periods_per_window=4.5):
assert (min_pitch > 0), 'Min pitch needs to be > 0'
assert (0 <= silence_threshold <= 1), 'Silence threshold need to be in [0, 1]'
hop_length_seconds = (periods_per_window / (4.0 * min_pit... |
def network_weight_zero_init(net: nn.Module):
with torch.no_grad():
for m in net.modules():
if isinstance(m, nn.Conv2d):
device = m.weight.device
(in_channels, out_channels, k1, k2) = m.weight.shape
m.weight[:] = ((torch.randn(m.weight.shape, devic... |
class VAE(nn.Module):
def __init__(self, args):
super(VAE, self).__init__()
self.args = args
self.q_z_layers_pre = nn.ModuleList()
self.q_z_layers_gate = nn.ModuleList()
self.q_z_layers_pre.append(nn.Linear(np.prod(self.args.input_size), 300))
self.q_z_layers_gate.app... |
def compute_f1_all(pred_entities, gt_entities):
origins = []
founds = []
rights = []
for (i, _) in enumerate(pred_entities):
origins.extend(gt_entities[i])
founds.extend(pred_entities[i])
rights.extend([pre_entity for pre_entity in pred_entities[i] if (pre_entity in gt_entities[i... |
def write_current_fig(pprefix):
log.info(f'write {pprefix}.png')
plt.savefig(f'{pprefix}.png', dpi=140)
log.info(f'write {pprefix}.pdf')
plt.savefig(f'{pprefix}.pdf') |
class CustomDataParallel(nn.DataParallel):
def __getattr__(self, key):
try:
return super().__getattr__(key)
except AttributeError:
return getattr(self.module, key) |
class LookupDataPool():
def __init__(self) -> None:
self.pool: dict = {}
def add(self, lookup: LookupData, update: bool=False, case_sensitive: bool=True) -> None:
if (not isinstance(lookup, LookupData)):
raise TypeError('lookup has to be instance of LookupData')
if ((lookup.n... |
def _canonicalize(smi_str):
return rdkit_general_ops.return_canoncailised_smiles_str(rdkit_general_ops.get_molecule(smi_str, kekulize=False), kekuleSmiles=False) |
def set_forget_bias_to_one(bias):
n = bias.size(0)
(start, end) = ((n // 4), (n // 2))
bias.data[start:end].fill_(1.0) |
class ResLayer(nn.Sequential):
def __init__(self, block, inplanes, planes, num_blocks, stride=1, avg_down=False, conv_cfg=None, norm_cfg=dict(type='BN'), downsample_first=True, **kwargs):
self.block = block
downsample = None
if ((stride != 1) or (inplanes != (planes * block.expansion))):
... |
def assert_fx_safe(condition: bool, message: str) -> torch.Tensor:
if (torch.jit.is_scripting() or is_fx_tracing()):
return torch.zeros(1)
return _do_assert_fx_safe(condition, message) |
def read_ims(auto_src, gold_src):
auto = coreference_reading.read_conll_doc(auto_src, None, True, False, False, True)
gold = coreference_reading.read_conll_matching_files(auto, gold_src)
return (auto, gold) |
class PASS2ACT(object):
def __init__(self, nlp) -> None:
super(PASS2ACT, self).__init__()
self.nlp = nlp
def pass2act(self, doc, rec=False):
parse = self.nlp(doc)
newdoc = ''
for sent in parse.sents:
subjpass = ''
subj = ''
verb = ''
... |
class LocalJobArgs(JobArgs):
def __init__(self, platform, namespace, job_name):
super().__init__(platform, namespace, job_name)
def initilize(self):
self.distribution_strategy = DistributionStrategy.LOCAL
self.enable_elastic_scheduling = False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.