code stringlengths 101 5.91M |
|---|
class CoordConv2d(nn.Module):
def __init__(self, in_channels, out_channels, **kwargs):
super().__init__()
in_size = (in_channels + 1)
self.conv = nn.Conv2d(in_size, out_channels, **kwargs)
def forward(self, x):
ret = AddCoords()(x)
ret = self.conv(ret)
return ret |
class DecodeLayer(nn.Module):
def __init__(self, vocabs, inference_layers, embed_dim, ff_embed_dim, num_heads, token_size, rel_size, dropout):
super(DecodeLayer, self).__init__()
self.inference_core = Transformer(inference_layers, embed_dim, ff_embed_dim, num_heads, dropout, with_external=True)
... |
def build_fake_yaml2():
fake_yaml = '\n model:\n name: fake_yaml\n framework: tensorflow\n inputs: x\n outputs: op_to_store\n device: cpu\n evaluation:\n accuracy:\n metric:\n topk: 1\n tuning:\n strategy:\n ... |
class DictMetaDataInfo(object):
def __init__(self, input_element):
self.type = type(input_element)
random_key = list(input_element.keys())[0]
if hasattr(input_element, random_key):
self.class_fn = CustomDict
else:
self.class_fn = dict
self.length = len... |
def add_clip_prediction(predictions: Dict[(int, Dict[(int, Tensor)])], class_preds: Tensor, frames: Tensor, video_index: int, merge_predictions_type: str='max') -> None:
prev_class_preds = predictions[video_index][frames]
class_preds = class_preds.to(dtype=prev_class_preds.dtype)
if (merge_predictions_type ... |
def score_pair_to_csv(rep1_dict: dict, rep2_dict: dict, filename: str, metrics: list) -> None:
rep1 = load_embedding(rep1_dict['dataset'], rep1_dict['architecture'], rep1_dict['seed'], rep1_dict['step'], rep1_dict['layer'])
rep2 = load_embedding(rep2_dict['dataset'], rep2_dict['architecture'], rep2_dict['seed']... |
def test_split_by_num_for_UI_bigraph():
e_list = [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 1], [1, 2], [1, 3], [1, 4], [2, 2], [2, 3], [2, 4], [3, 3], [3, 4], [4, 4]]
g = dhg.BiGraph(5, 5, e_list)
train_num = 3
(train_adj, test_adj) = split_by_num_for_UI_bigraph(g, train_num)
assert (len(train_ad... |
def test_ssd_neck():
with pytest.raises(AssertionError):
SSDNeck(in_channels=[8, 16], out_channels=[8, 16, 32], level_strides=[2], level_paddings=[2, 1])
with pytest.raises(AssertionError):
SSDNeck(in_channels=[8, 16], out_channels=[8], level_strides=[2], level_paddings=[2])
with pytest.rais... |
def CheckArgs(args):
if (args.c_fa <= 0):
raise Exception('--c-fa must be greater than 0')
if (args.c_miss <= 0):
raise Exception('--c-miss must be greater than 0')
if ((args.p_target <= 0) or (args.p_target >= 1)):
raise Exception('--p-target must be greater than 0 and less than 1')... |
class HighwayState():
ego_reaction_threshold = 8
ego_crash_threshold = 11
def __init__(self, ego_position, ego_speed, ego_acceleration, other_xs, other_speeds, other_accelerations):
self.ego_position = ego_position
self.ego_speed = ego_speed
self.ego_acceleration = ego_acceleration
... |
class ResNeXt101_64x4d(nn.Module):
def __init__(self, num_classes=1000):
super(ResNeXt101_64x4d, self).__init__()
self.num_classes = num_classes
self.features = resnext101_64x4d_features
self.avg_pool = nn.AvgPool2d((7, 7), (1, 1))
self.last_linear = nn.Linear(2048, num_class... |
class LoadImage():
def __call__(self, results):
warnings.simplefilter('once')
warnings.warn('`LoadImage` is deprecated and will be removed in future releases. You may use `LoadImageFromWebcam` from `mmdet.datasets.pipelines.` instead.')
if isinstance(results['img'], str):
results... |
class PreResNet20ImageNette():
base = PreResNet
args = list()
kwargs = {'depth': 20, 'planes': [4, 8, 16], 'input_size': 160}
transform_train = transforms.Compose([transforms.RandomCrop(160, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.4914, 0.4822, ... |
def broyden(g, x_init, J_inv_init, max_steps=50, cvg_thresh=1e-05, dvg_thresh=1, eps=1e-06):
x = x_init.clone().detach()
J_inv = J_inv_init.clone().detach()
ids_val = torch.ones(x.shape[0]).bool()
gx = g(x, mask=ids_val)
update = (- J_inv.bmm(gx))
x_opt = x.clone()
gx_norm_opt = torch.linalg... |
class TestSimulatorsJob(QiskitTestCase):
def test_multiple_execution(self):
taskcount = 10
target_tasks = [(lambda : None) for _ in range(taskcount)]
job_id = str(uuid.uuid4())
backend = FakeRueschlikon()
with mocked_executor() as (SimulatorJob, executor):
for ind... |
def download_objects365v2(url, dir, unzip=True, delete=False, threads=1):
def download_single(url, dir):
if ('train' in url):
saving_dir = (dir / Path('train_zip'))
mkdir_or_exist(saving_dir)
f = (saving_dir / Path(url).name)
unzip_dir = (dir / Path('train'))
... |
def compute_predictions_log_probs(all_examples, all_features, all_results, n_best_size, max_answer_length, output_prediction_file, output_nbest_file, output_null_log_odds_file, start_n_top, end_n_top, version_2_with_negative, tokenizer, verbose_logging):
_PrelimPrediction = collections.namedtuple('PrelimPrediction'... |
class DatasetConfig():
_zpy_init
def __init__(self, sim_name: str, **kwargs):
self._sim = None
self._config = {}
unique_sim_filters = {'project': _project['id'], 'name': sim_name}
sims = get(f'{_base_url}/api/v1/sims/', params=unique_sim_filters, headers=auth_header(_auth_token))... |
def gpu_info() -> list:
gpus = [line for line in _run_cmd(['nvidia-smi', '-L']) if line]
gpu_infos = [re.match('GPU ([0-9]+): ([^(]+) \\(UUID: ([^)]+)\\)', gpu).groups() for gpu in gpus]
gpu_infos = [dict(zip(['idx', 'name', 'uuid'], info)) for info in gpu_infos]
gpu_count = len(gpus)
lines = _run_c... |
class TFRemBertForSequenceClassification(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def get_config():
parser = ArgumentParser()
parser = common_config(parser)
parser.add_argument('--fit_gde', default=False, type=str_to_bool, help='Whether to fit GDE on normal data.')
parser.add_argument('--align', default=True, type=str_to_bool, help='align')
parser.add_argument('--dims', default=[... |
def save_experiment_config(args, config, logger=None):
config_path = os.path.join(args.experiment_path, 'config.yaml')
os.system(('cp %s %s' % (args.config, config_path)))
print_log(f'Copy the Config file from {args.config} to {config_path}', logger=logger) |
def get_parser():
parser = argparse.ArgumentParser(description='Decoupling Graph Convolution Network with DropGraph Module')
parser.add_argument('--work-dir', default='./work_dir/temp', help='the work folder for storing results')
parser.add_argument('-model_saved_name', default='')
parser.add_argument('... |
_task('winogrande')
class WinograndeTask(WSCTask):
def setup_task(cls, args, **kwargs):
assert (args.criterion == 'winogrande'), 'Must set --criterion=winogrande'
vocab = cls.load_dictionary(os.path.join(args.data, 'dict.txt'))
print('| dictionary: {} types'.format(len(vocab)))
retur... |
def assert_exactly_one(lst):
assert (sum((int(bool(el)) for el in lst)) == 1), ', '.join((str(el) for el in lst)) |
def make_json(scale=1):
with open('conf/rigidcloth/scale/scale.json', 'r') as f:
config = json.load(f)
config['cloths'][0]['transform']['scale'] = scale
def save_config(config, file):
with open(file, 'w') as f:
json.dump(config, f)
save_config(config, 'conf/rigidcloth/scale/s... |
def split_strings(strings, start, chr_lens):
return [strings[(i - start):(j - start)] for (i, j) in zip(([start] + chr_lens[:(- 1)]), chr_lens)] |
def build_transforms(cfg, is_train=True):
normalize_transform = T.Normalize(mean=cfg.INPUT.PIXEL_MEAN, std=cfg.INPUT.PIXEL_STD)
if is_train:
transform = T.Compose([T.Resize(cfg.INPUT.SIZE_TRAIN), T.RandomHorizontalFlip(p=cfg.INPUT.PROB), T.Pad(cfg.INPUT.PADDING), T.RandomCrop(cfg.INPUT.SIZE_TRAIN), Rand... |
def llama2_completion(pipeline, caption):
prompt = create_qg_prompt(caption)
sequences = pipeline(prompt, do_sample=False, num_beams=5, num_return_sequences=1, max_length=512)
output = sequences[0]['generated_text'][len(prompt):]
output = output.split('\n\n')[0]
return output |
def get_next_batch_new(dataloader, device):
data_dict = dataloader.__next__()
return data_dict.to(device) |
def get_model_key(base_model_key: str, dataset_key: str, train_key: str):
if (train_key is None):
return base_model_key
else:
return 'B_{}__D_{}__T_{}'.format(base_model_key, dataset_key, train_key) |
def test_kernel_expand_multi_d():
D = 3
k_base = list(fk.base_kernels(3))
k_expanded = grammar.expand_kernels(3, k_base)
assert (len(k_expanded) > len(k_base)) |
def test_format_results():
if (not torch.cuda.is_available()):
pytest.skip('test requires GPU and torch+cuda')
root_path = 'tests/data/nuscenes/'
ann_file = 'tests/data/nuscenes/nus_infos_mono3d.coco.json'
class_names = ['car', 'truck', 'trailer', 'bus', 'construction_vehicle', 'bicycle', 'motor... |
_model('s2t_transformer')
class S2TTransformerModel(FairseqEncoderDecoderModel):
def __init__(self, encoder, decoder):
super().__init__(encoder, decoder)
def add_args(parser):
parser.add_argument('--conv-kernel-sizes', type=str, metavar='N', help='kernel sizes of Conv1d subsampling layers')
... |
def register_model(name, dataclass=None):
def register_model_cls(cls):
if (name in MODEL_REGISTRY):
return MODEL_REGISTRY[name]
if (not issubclass(cls, BaseFairseqModel)):
raise ValueError('Model ({}: {}) must extend BaseFairseqModel'.format(name, cls.__name__))
MODEL... |
def environment_creation(args):
path = args.input
output_path = args.output
files = os.listdir(path)
augmentor = StyleAugmentor()
unloader = transforms.ToPILImage()
for (j, scan) in enumerate(files):
if os.path.isdir(((path + '/') + scan)):
print('scan:', scan, 'progress:', j... |
def test_actionAngleTorus_Isochrone_actions():
from galpy.actionAngle import actionAngleIsochrone, actionAngleTorus
from galpy.potential import IsochronePotential
ip = IsochronePotential(normalize=1.0, b=1.2)
aAI = actionAngleIsochrone(ip=ip)
tol = (- 6.0)
aAT = actionAngleTorus(pot=ip, tol=tol)... |
def _timestamp_type_check(df_column):
_is_pd_datetime = pd.api.types.is_datetime64_any_dtype(df_column.dtypes)
if (_is_pd_datetime is not True):
logging.warning('Datetime column should be datetime64 dtype. You can manually modify the dtype, or set repair=True when initialize TSDataset.')
return ... |
def train_dmc_redq(args):
train_env = dc.envs.load_dmc(**vars(args))
test_env = dc.envs.load_dmc(**vars(args))
obs_shape = train_env.observation_space.shape
action_shape = train_env.action_space.shape
max_action = train_env.action_space.high[0]
agent = dc.redq.REDQAgent(obs_shape[0], action_shap... |
class GpuWaitResetCollector(DecorrelatingStartCollector):
mid_batch_reset = False
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.need_reset = np.zeros(len(self.envs), dtype=np.bool)
self.temp_observation = buffer_method(self.step_buffer_np.observation, 'copy'... |
def DistributedFairseqModel(args, model):
assert isinstance(model, BaseFairseqModel)
if (args.ddp_backend == 'c10d'):
if c10d_status.is_default:
ddp_class = parallel.DistributedDataParallel
elif c10d_status.has_c10d:
ddp_class = parallel._DistributedDataParallelC10d
... |
class VectorFieldGDE_dev(torch.nn.Module):
def __init__(self, dX_dt, func_f, func_g):
super(VectorFieldGDE_dev, self).__init__()
if (not isinstance(func_f, torch.nn.Module)):
raise ValueError('func must be a torch.nn.Module.')
if (not isinstance(func_g, torch.nn.Module)):
... |
class ReconstractMaskedImageFromSceneGraphLoss(nn.Module):
def __init__(self, triple_dim, image_dim, num_img_patches=50, num_triple=15, sg_only=False):
super().__init__()
self.image_dim = image_dim
if sg_only:
self.register_buffer('attn_mask', self.build_attention_mask(tri_length... |
def get_vars_maybe_avg(namespace, var_names, training, polyak_decay):
vars = []
for vn in var_names:
vars.append(get_var_maybe_avg(namespace, vn, training, polyak_decay))
return vars |
def _worker_fn(rank, world_size, main_fn, args_dict):
torch.cuda.set_device(rank)
dist.init_process_group(backend='nccl', rank=rank, world_size=world_size)
if (rank != 0):
sys.stdout = open('/dev/null', 'w')
main_fn(**args_dict)
dist.destroy_process_group() |
def f_score(precision, recall, beta=1):
score = (((1 + (beta ** 2)) * (precision * recall)) / (((beta ** 2) * precision) + recall))
return score |
class MIFCNet(nn.Module):
def __init__(self, n_input, n_units):
super().__init__()
assert (n_units >= n_input)
self.linear_shortcut = nn.Linear(n_input, n_units)
self.block_nonlinear = nn.Sequential(nn.Linear(n_input, n_units), nn.BatchNorm1d(n_units), nn.ReLU(), nn.Linear(n_units, n... |
def bond_features(bond: Chem.rdchem.Bond) -> List[Union[(bool, int, float)]]:
if (bond is None):
fbond = ([1] + ([0] * (BOND_FDIM - 1)))
else:
bt = bond.GetBondType()
fbond = [0, (bt == Chem.rdchem.BondType.SINGLE), (bt == Chem.rdchem.BondType.DOUBLE), (bt == Chem.rdchem.BondType.TRIPLE)... |
class Pitenis2020(dataset.Dataset):
name = 'pitenis2020'
url = '
hash = '4b1cbbcf1795b078db6cd72686b6e326dcc65ef3a47bbb1'
files = [{'name': 'pitenis2020gr.csv', 'language': 'gr', 'type': 'training', 'platform': 'twitter'}]
license = 'UNKNOWN'
def process(cls, tmp_file_path, dataset_folder, api_c... |
class PersonanliProcessor(DataProcessor):
def get_train_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'train.tsv')), 'train')
def get_dev_examples(self, data_dir):
return self._create_examples(self._read_tsv(os.path.join(data_dir, 'test.tsv')), 'tes... |
def sent_tuples_in_list(sent_tuple1, list_of_sent_tuples, keep_polarity=True):
(holder1, target1, exp1, pol1) = sent_tuple1
if (len(holder1) == 0):
holder1 = frozenset(['_'])
if (len(target1) == 0):
target1 = frozenset(['_'])
for (holder2, target2, exp2, pol2) in list_of_sent_tuples:
... |
def dobldobl_membertest(wsys, gpts, dim, point, evatol=1e-06, memtol=1e-06, verbose=True, tasks=0):
from phcpy.interface import store_dobldobl_witness_set
from phcpy.phcpy2c3 import py2c_witset_dobldobl_membertest as membtest
store_dobldobl_witness_set(len(wsys), dim, wsys, gpts)
nvr = (len(point) // 4)... |
def test_summarize(model, X):
d1 = model.distributions[0]
d2 = model.distributions[1]
model.summarize(X)
assert_array_almost_equal(model._xw_sum, [[0., 1.895245], [2.635103, 3.469387]], 4)
assert_array_almost_equal(model._xw_starts_sum, [0.136405, 1.863595], 4)
assert_array_almost_equal(model._x... |
class Publisher():
def __init__(self):
self._broker = _Broker()
def publish(self, event, *args, **kwargs):
return self._broker.dispatch(event, *args, **kwargs) |
def main():
output_dir_train = (os.path.dirname(args.input_csv) + '/train/ids')
output_dir_test = (os.path.dirname(args.input_csv) + '/test/ids')
with open(args.input_csv, 'r') as f:
lines = f.read().splitlines()
(x_train, x_test) = train_test_split(lines, train_size=(args.train_percentage / 100... |
def build_vocab(vocab_root_path, train_all_text, text_min_count):
print('building vocab,train')
vocab = []
for text in train_all_text:
words = text.split(' ')
for word in words:
if (word not in vocab):
vocab.append(word)
freq = dict(zip(vocab, [0 for i in rang... |
def assets_dir():
return path.abspath(path.join(path.dirname(path.abspath(__file__)), '../assets')) |
def save_json(content, path, indent=4, **json_dump_kwargs):
with open(path, 'w') as f:
json.dump(content, f, indent=indent, **json_dump_kwargs) |
class AlbertTokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
def __init__(self, vocab_file, do_lower_case=True, remove_space=True, keep_accents=False, bos_token='[C... |
_metaclass(abc.ABCMeta)
class TrainingHook(tf.train.SessionRunHook, Configurable):
def __init__(self, params, model_dir, run_config):
tf.train.SessionRunHook.__init__(self)
Configurable.__init__(self, params, tf.contrib.learn.ModeKeys.TRAIN)
self._model_dir = model_dir
self._run_conf... |
def set_restricted_game_conversations_for_all_workers(trainer: Trainer, delegate_policy_id: PolicyID, agent_id_to_restricted_game_specs: Dict[(AgentID, List[StrategySpec])], load_policy_spec_fn):
def _set_conversions(worker: RolloutWorker):
def _set_restricted_env_convertions(restricted_env):
as... |
class SequenceClip(BaseLoader):
def __init__(self, split, name, starting_frame, regex='*.jpg', lmdb_env=None):
super(SequenceClip, self).__init__(split, osp.join(get_seq_path(split), name), regex, lmdb_env=lmdb_env)
self.starting_frame = starting_frame
def __str__(self):
return "< class:... |
class LevitOnnxConfig(OnnxConfig):
torch_onnx_minimum_version = version.parse('1.11')
def inputs(self) -> Mapping[(str, Mapping[(int, str)])]:
return OrderedDict([('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'})])
def atol_for_validation(self) -> float:
return 0.000... |
def _score_ngrams(target_ngrams, prediction_ngrams):
intersection_ngrams_count = 0
for ngram in six.iterkeys(target_ngrams):
intersection_ngrams_count += min(target_ngrams[ngram], prediction_ngrams[ngram])
target_ngrams_count = sum(target_ngrams.values())
prediction_ngrams_count = sum(prediction... |
class DownsamplingConvBlock(nn.Module):
def __init__(self, n_filters_in, n_filters_out, stride=2, normalization='none'):
super(DownsamplingConvBlock, self).__init__()
ops = []
if (normalization != 'none'):
ops.append(nn.Conv3d(n_filters_in, n_filters_out, stride, padding=0, strid... |
_criterion('composite_loss')
class CompositeLoss(FairseqCriterion):
def add_args(parser):
parser.add_argument('--underlying-criterion', type=str, metavar='VAL', required=True, help='underlying criterion to use for the composite loss')
def build_underlying_criterion(args, task):
saved_criterion =... |
def get_results(df, restraints):
new_df = df
for key in restraints.keys():
new_df = new_df[(new_df[key] == restraints[key])]
val_f1_rows = new_df[pd.notnull(new_df['best_val_f1'])]
(l_max, l_min, avg) = sample(val_f1_rows)
return (l_max, l_min, avg) |
def powerset(iterable):
s = list(iterable)
return chain.from_iterable((combinations(s, r) for r in range((len(s) + 1)))) |
class GRU(KerasLayer):
def __init__(self, output_dim, activation='tanh', inner_activation='hard_sigmoid', return_sequences=False, go_backwards=False, W_regularizer=None, U_regularizer=None, b_regularizer=None, input_shape=None, **kwargs):
super(GRU, self).__init__(None, output_dim, activation, inner_activat... |
def diagonal_gaussian_kl(mu0, log_std0, mu1, log_std1):
(var0, var1) = (torch.exp((2 * log_std0)), torch.exp((2 * log_std1)))
pre_sum = (((0.5 * (((((mu1 - mu0) ** 2) + var0) / (var1 + EPS)) - 1)) + log_std1) - log_std0)
all_kls = torch.sum(pre_sum, axis=1)
return torch.mean(all_kls) |
def _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False):
def check_size(idx):
if (isinstance(max_positions, float) or isinstance(max_positions, int)):
return (size_fn(idx) <= max_positions)
elif isinstance(max_positions, dict):
idx_size = size_fn(i... |
def generate_upload_workflow(base_workflow_name, os_type, btype, cu_version, *, filter_branch=None):
d = {'name': f'{base_workflow_name}_upload', 'context': 'org-member', 'requires': [base_workflow_name]}
if (btype == 'wheel'):
d['subfolder'] = ('' if (os_type == 'macos') else (cu_version + '/'))
if... |
def get_color(score: float, min_value: Union[(float, int)], max_value: Union[(float, int)], cmap: Colormap, return_alpha: bool=True, return_string: bool=True):
scaled_value = ((score - min_value) / (max_value - min_value))
color = cmap(scaled_value)
if return_alpha:
color = ((color[0] * 255), (color... |
def bi_cudnn_rnn_encoder(cell_type, hidden_size, num_layers, dropout_rate, inputs, input_lengths, is_train, output_layer=None):
if (cell_type == 'lstm'):
RnnLayer = CudnnLstm
elif (cell_type == 'gru'):
RnnLayer = CudnnGru
else:
raise ValueError()
layer = RnnLayer(n_units=hidden_s... |
class GPTJForCausalLM(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def register_tracer(line_: str) -> None:
line_ = line_.strip()
usage = 'Usage: %flow register_tracer <module.path.to.tracer_class>'
tracer_cls = _resolve_tracer_class(line_)
if (tracer_cls is None):
warn(usage)
return
_deregister_tracers_for(tracer_cls)
tracer_cls.instance()
... |
def train_one_epoch(model: torch.nn.Module, data_loader: Iterable, optimizer: torch.optim.Optimizer, device: torch.device, epoch: int, loss_scaler, log_writer=None, args=None):
model.train(True)
metric_logger = misc.MetricLogger(delimiter=' ')
metric_logger.add_meter('lr', misc.SmoothedValue(window_size=1,... |
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.flatten = nn.Flatten()
self.linear_relu_stack = nn.Sequential(nn.Linear((28 * 28), 16), nn.ReLU(), nn.Linear(16, 16), nn.ReLU(), nn.Linear(16, 10))
def forward(self, data):
x = self.fla... |
def GR(epsilon):
return ((epsilon ** 2) / (((- 0.5) * np.log((1 + (((2 / np.pi) * np.log((1 + epsilon))) ** 2)))) + (((2 / np.pi) * np.arctan(((2 / np.pi) * np.log((1 + epsilon))))) * np.log((1 + epsilon))))) |
.parametrize('data,allow_nan', itertools.product([(np.array([2, 3, 4]), np.array([1, 2, 3, 5, np.nan])), (np.array(['a', 'b', 'c']), np.array(['q', 'a', 'nan']))], [True, False]))
def test_NaNLabelEncoder(data, allow_nan):
(fit_data, transform_data) = data
encoder = NaNLabelEncoder(warn=False, add_nan=allow_nan... |
.parametrize('loader_parameters', [{'path_data': [str(Path(__data_testing_dir__, 'microscopy_png'))], 'target_suffix': [['_seg-myelin-manual', '_seg-axon-manual']], 'extensions': ['.png'], 'roi_params': {'suffix': None, 'slice_filter_roi': None}, 'contrast_params': {'contrast_lst': []}}])
def test_bids_df_microscopy_pn... |
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, batchNorm, in_planes, out_planes, stride, downsample, padding, dilation):
super(BasicBlock, self).__init__()
self.conv1 = conv_bn_relu(batchNorm=batchNorm, in_planes=in_planes, out_planes=out_planes, kernel_size=3, stride=stride, padd... |
class MarkerPose(torch.nn.Module):
def __init__(self, superpoint, ellipsegnet, imresize, crop_sz, Params):
super(MarkerPose, self).__init__()
self.superpoint = superpoint
self.ellipsegnet = ellipsegnet
self.imresize = imresize
self.crop_sz = crop_sz
self.mid = ((crop_... |
def prepare_df(json_obj):
traceEvents = json_obj['traceEvents']
for traceEvent in traceEvents:
if ('cat' in traceEvent):
traceEvent['cat'] = traceEvent['cat'].lower()
if ('dur' in traceEvent):
traceEvent['dur'] = int(traceEvent['dur'])
else:
traceEvent... |
def _contraction_Cautun2020(r, M_DMO, Mbar, fbar):
func_M_DM_contract = (lambda M: ((M_DMO * 1.023) * (((M_DMO / (1.0 - fbar)) / (M + Mbar)) ** (- 0.54))))
M_DM = fixed_point(func_M_DM_contract, M_DMO)
return (((M_DM / M_DMO) * M_DMO) / (r ** 2.0)) |
class Compose(object):
def __init__(self, augmentations):
self.augmentations = augmentations
def __call__(self, img, mask):
assert (img.size == mask.size)
for a in self.augmentations:
(img, mask) = a(img, mask)
return (np.array(img), np.array(mask, dtype=np.uint8)) |
def load_county_level(data_dir='data', preprocess=True, discard=False):
print('loading county-level data...')
if (not ('county_data_abridged.csv' in os.listdir(data_dir))):
df = data.load_county_data(data_dir=data_dir, cached=False, preprocess=preprocess, discard=discard)
else:
df = data.loa... |
class UpSampling2D(ZooKerasLayer):
def __init__(self, size=(2, 2), dim_ordering='th', input_shape=None, **kwargs):
super(UpSampling2D, self).__init__(None, size, dim_ordering, (list(input_shape) if input_shape else None), **kwargs) |
class Mixed_4a(nn.Module):
def __init__(self):
super(Mixed_4a, self).__init__()
self.branch0 = nn.Sequential(BasicConv2d(160, 64, kernel_size=1, stride=1), BasicConv2d(64, 96, kernel_size=3, stride=1))
self.branch1 = nn.Sequential(BasicConv2d(160, 64, kernel_size=1, stride=1), BasicConv2d(64... |
def get_final_text(pred_text, orig_text, do_lower_case, verbose_logging=False):
def _strip_spaces(text):
ns_chars = []
ns_to_s_map = collections.OrderedDict()
for (i, c) in enumerate(text):
if (c == ' '):
continue
ns_to_s_map[len(ns_chars)] = i
... |
class ROIPooler(nn.Module):
def __init__(self, output_size, scales, sampling_ratio, pooler_type, canonical_box_size=224, canonical_level=4):
super().__init__()
if isinstance(output_size, int):
output_size = (output_size, output_size)
assert (len(output_size) == 2)
assert ... |
def test_degenerate_gauss_emits_parent(archive_fixture):
(archive, x0) = archive_fixture
parent_sol = (x0 * 5)
archive.add_single(parent_sol, 1, np.array([0, 0]))
emitter = GaussianEmitter(archive, sigma=0, x0=x0, batch_size=2)
solutions = emitter.ask()
assert (solutions == np.expand_dims(parent... |
class history(object):
def __init__(self, num_objectives):
self.num_objectives = num_objectives
self.pareto = pareto.Pareto(num_objectives=self.num_objectives)
self.num_runs = int(0)
self.total_num_search = int(0)
self.fx = np.zeros((MAX_SEARCH, self.num_objectives), dtype=fl... |
def write_data_to_h5(data: np.ndarray, filename: Union[(str, Path)], compression='gzip', compression_level=9, dtype='uint8', verbose=False):
with h5py.File((filename if isinstance(filename, str) else str(filename)), 'w', libver='latest') as f:
if (data.dtype != dtype):
logging.warning(f'Found da... |
class HopperEnv(mujoco_env.MujocoEnv, utils.EzPickle):
def __init__(self, xml_file='hopper.xml', forward_reward_weight=1.0, ctrl_cost_weight=0.001, healthy_reward=1.0, terminate_when_unhealthy=True, healthy_state_range=((- 100.0), 100.0), healthy_z_range=(0.7, float('inf')), healthy_angle_range=((- 0.2), 0.2), rese... |
def conv_init(conv):
nn.init.kaiming_normal_(conv.weight, mode='fan_out')
nn.init.constant_(conv.bias, 0) |
class ActNorm(AffineConstantFlow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.data_dep_init_done = False
def forward(self, x):
if (not self.data_dep_init_done):
assert ((self.s is not None) and (self.t is not None))
self.s.data = (... |
class l1_rate_sparsity():
def __init__(self, Lambda=1e-05):
self.Lambda = Lambda
self.__name__ = 'l1_rate_sparsity'
def __call__(self, spk_out):
return (self.Lambda * torch.sum(spk_out)) |
class AnisotropicReadoutExperiment(AnisotropicExperiment):
def defineParameters(self):
aniP = super().defineParameters()
expP = {'seed': 3, 'trials': 25, 'stepsPerTrial': 110, 'isReset': True, 'refractoryDelay': 2, 'voltageTau': 10.24, 'currentTau': 10.78, 'thresholdMant': 1000, 'reservoirConnProb':... |
def airnet50_1x64d_r16(**kwargs):
return get_airnet(blocks=50, base_channels=64, ratio=16, model_name='airnet50_1x64d_r16', **kwargs) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.