code stringlengths 101 5.91M |
|---|
def resnet101s16(pretrained=False, finetune_layers=(), s16_feats=('layer4',), s8_feats=('layer2',), s4_feats=('layer1',), **kwargs):
model = ResNetS16(finetune_layers, s16_feats, s8_feats, s4_feats, Bottleneck, [3, 4, 23, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['... |
class CustomDatasetDataLoader():
def __init__(self, opt):
self.opt = opt
dataset_class = find_dataset_using_name(opt.dataset_mode)
self.dataset = dataset_class(opt)
print(('dataset [%s] was created' % type(self.dataset).__name__))
self.dataloader = torch.utils.data.DataLoader... |
def score_labels_majority_vote(instances, gold_label_key='tags', treat_tie_as='O', span_level=True):
(tp, fp, fn) = (0, 0, 0)
for instance in instances:
maj_vote = _get_label_majority_vote(instance, treat_tie_as)
if span_level:
score = _score_sequence_span_level(maj_vote, instance[go... |
class InitialBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, padding=0, bias=False, relu=True):
super().__init__()
if relu:
activation = nn.ReLU()
else:
activation = nn.PReLU()
self.main_branch = nn.Conv2d(in_channels, (out_chann... |
class UNet3DConditionModel(ModelMixin, ConfigMixin):
_supports_gradient_checkpointing = True
_to_config
def __init__(self, sample_size: Optional[int]=None, in_channels: int=4, out_channels: int=4, center_input_sample: bool=False, flip_sin_to_cos: bool=True, freq_shift: int=0, down_block_types: Tuple[str]=('... |
class YoloTrain(object):
def __init__(self):
self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE
self.classes = utils.read_class_names(cfg.YOLO.CLASSES)
self.num_classes = len(self.classes)
self.learn_rate_init = cfg.TRAIN.LEARN_RATE_INIT
self.learn_rate_end = cfg.TRAIN.LEARN_R... |
(version='2.0')
class Pruning(Component):
def __init__(self, conf_fname_or_obj=None):
super(Pruning, self).__init__()
if isinstance(conf_fname_or_obj, Config):
self.cfg = PruningConf()
self.cfg.map_pyconfig_to_cfg(conf_fname_or_obj)
self.cfg = self.cfg.usr_cfg
... |
def make_tarball(tarball_path, sources, base_dir, prefix_dir=''):
base_dir = os.path.normpath(os.path.abspath(base_dir))
def archive_name(path):
path = os.path.normpath(os.path.abspath(path))
common_path = os.path.commonprefix((base_dir, path))
archive_name = path[len(common_path):]
... |
def state_dict_to_master_params(model, state_dict, use_fp16):
if use_fp16:
named_model_params = [(name, state_dict[name]) for (name, _) in model.named_parameters()]
param_groups_and_shapes = get_param_groups_and_shapes(named_model_params)
master_params = make_master_params(param_groups_and_s... |
def _kronecker_product(mat1, mat2):
(m1, n1) = mat1.get_shape().as_list()
mat1_rsh = array_ops.reshape(mat1, [m1, 1, n1, 1])
(m2, n2) = mat2.get_shape().as_list()
mat2_rsh = array_ops.reshape(mat2, [1, m2, 1, n2])
return array_ops.reshape((mat1_rsh * mat2_rsh), [(m1 * m2), (n1 * n2)]) |
def seed_everything(seed=42):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False |
def dropout_eval(model):
for m in model.modules():
if (type(m) == nn.Dropout):
m.eval() |
def detect_compute_compatibility(CUDA_HOME, so_file):
try:
cuobjdump = os.path.join(CUDA_HOME, 'bin', 'cuobjdump')
if os.path.isfile(cuobjdump):
output = subprocess.check_output("'{}' --list-elf '{}'".format(cuobjdump, so_file), shell=True)
output = output.decode('utf-8').str... |
_model_architecture('cmlm_transformer', 'cmlm_transformer_wmt_en_de')
def cmlm_wmt_en_de(args):
cmlm_base_architecture(args) |
def check_rdata_support(caller_name):
try:
import rdata
except ImportError:
raise ImportError(f'{caller_name} requires rdata. Please install pyreadr using `pip install rdata`') |
def _funcWrap(F: Type['U'], f, resultWrap: Optional[Type['Vec[T]']]=None, module: Any=libpymod) -> 'U':
if hasattr(f, '__call__'):
class FuncWrapper(F):
def __init__(self, f) -> None:
self.f = f
F.__init__(self)
def clone(self) -> 'FuncWrapper':
... |
def preprocess(image):
(w, h) = image.size
(w, h) = ((x - (x % 32)) for x in (w, h))
image = image.resize((w, h), resample=PIL_INTERPOLATION['lanczos'])
image = (np.array(image).astype(np.float32) / 255.0)
image = image[None].transpose(0, 3, 1, 2)
image = torch.from_numpy(image)
return ((2.0... |
def load_mesh_data(mesh_fpath: str, field: str, device: Optional[torch.device]=None) -> Tuple[(Optional[torch.Tensor], Optional[torch.Tensor])]:
with PathManager.open(mesh_fpath, 'rb') as hFile:
return torch.as_tensor(pickle.load(hFile)[field], dtype=torch.float).to(device)
return None |
def getEpochsBetweenFullInf(pathToLog):
lineWithPattern = getFirstLineInLogWithCertainPattern(pathToLog, NUM_EPS_BETWEEN_FULLINF_PATTERN)
if (lineWithPattern == None):
return None
return getIntFromStr(lineWithPattern[(lineWithPattern.find(NUM_EPS_BETWEEN_FULLINF_PATTERN) + len(NUM_EPS_BETWEEN_FULLIN... |
def validate_stopping_criteria(stopping_criteria: StoppingCriteriaList, max_length: int) -> StoppingCriteriaList:
stopping_max_length = stopping_criteria.max_length
new_stopping_criteria = deepcopy(stopping_criteria)
if ((stopping_max_length is not None) and (stopping_max_length != max_length)):
war... |
class Block5(M.Model):
def initialize(self):
self.bn0 = L.batch_norm()
self.activ = L.activation(M.PARAM_RELU)
self.c1 = L.conv2D(3, 512, pad='VALID', usebias=False)
self.bn1 = L.batch_norm()
self.c2 = L.conv2D(3, 1024, pad='VALID', usebias=False, dilation_rate=2)
sel... |
class ConfigParser(configargparse.ArgParser):
def __init__(self):
super().__init__(default_config_files=[os.path.join(os.path.dirname(__file__), 'default_config.yml')], conflict_handler='resolve')
self.add('--name', type=str, help='Name of the config for the offline reconstruction system.')
... |
def build_depth_head(cfg):
name = cfg.MODEL.DEPTH_HEAD.NAME
return DEPTH_HEAD_REGISTRY.get(name)(cfg) |
def init_lstm(input_lstm):
for ind in range(0, input_lstm.num_layers):
weight = eval(('input_lstm.weight_ih_l' + str(ind)))
bias = np.sqrt((6.0 / ((weight.size(0) / 4) + weight.size(1))))
nn.init.uniform_(weight, (- bias), bias)
weight = eval(('input_lstm.weight_hh_l' + str(ind)))
... |
def _to_ops(iterable):
if (not _is_iterable(iterable)):
return iterable
return [_to_op(i) for i in iterable] |
class TestLogger(unittest.TestCase):
def test_changing_log_level(self) -> None:
change_log_level(logging.INFO)
self.assertEqual(logging.INFO, log.level) |
class FeaturePyramidNetwork(nn.Module):
def __init__(self, in_channels_list: List[int], out_channels: int, extra_blocks: Optional[ExtraFPNBlock]=None):
super(FeaturePyramidNetwork, self).__init__()
self.inner_blocks = nn.ModuleList()
self.layer_blocks = nn.ModuleList()
for in_channel... |
class Crop(object):
def __init__(self, tao=0.2):
self.tao = tao
def __call__(self, sequence):
copied_sequence = copy.deepcopy(sequence)
sub_seq_length = int((self.tao * len(copied_sequence)))
start_index = random.randint(0, ((len(copied_sequence) - sub_seq_length) - 1))
i... |
def symbolic_equations():
(a0, a1, a2, a3, a4, a5, a6) = var('a0, a1, a2, a3, a4, a5, a6')
(b0, b2, b3, b4, b5, c0) = var('b0, b2, b3, b4, b5, c0')
(t1, t2, t3, t4, t5, t6) = var('t1, t2, t3, t4, t5, t6')
eq1 = ((((a1 * t1) + (a2 * t2)) - (a3 * t3)) - a0)
eq2 = (((((b2 * t2) + (a3 * t3)) - (a4 * t4)... |
def pytest_collection_modifyitems(config, items):
if config.getoption('--runslow'):
return
skip_slow = pytest.mark.skip(reason='need --runslow option to run')
skip_not_implemented = pytest.mark.skip(reason='test not yet implemented')
for item in items:
if ('slow' in item.keywords):
... |
def adjust_learning_rate(optimizer, base_lr, epoch, stepsize=20, gamma=0.1, linear_decay=False, final_lr=0, max_epoch=100):
if linear_decay:
frac_done = (epoch / max_epoch)
lr = ((frac_done * final_lr) + ((1.0 - frac_done) * base_lr))
else:
lr = (base_lr * (gamma ** (epoch // stepsize)))... |
_model_architecture('fconv_self_att', 'fconv_self_att_wp')
def fconv_self_att_wp(args):
args.encoder_embed_dim = getattr(args, 'encoder_embed_dim', 256)
args.encoder_layers = getattr(args, 'encoder_layers', '[(128, 3)] * 2 + [(512,3)] * 1')
args.decoder_embed_dim = getattr(args, 'decoder_embed_dim', 256)
... |
class EpsilonGreedyNewsRecommendation(GreedyNewsRecommendation):
def pick_action(self, context):
map_rewards = self._map_rewards(context)
if (np.random.uniform() < self.epsilon):
article = np.random.randint(0, self.num_articles)
else:
article = np.argmax(map_rewards)
... |
class L2Loss(nn.Module):
def __init__(self):
super(L2Loss, self).__init__()
self.L2 = nn.MSELoss(reduction='mean')
def forward(self, target, mu):
loss = 0
target = target.detach()
loss = self.L2(target, mu)
return loss |
.skipif('env.PYPY')
def test_indirect_cycle(gc_tester):
obj = m.OwnsPythonObjects()
obj_list = [obj]
obj.value = obj_list
gc_tester(obj) |
class IceContrast(SegmentationDataset):
NUM_CLASS = 1
def __init__(self, base_dir='DENTIST', root=os.path.join('~', 'Nutstore Files', 'Dataset'), split='train', mode=None, transform=None, **kwargs):
super(IceContrast, self).__init__(root, split, mode, transform, **kwargs)
self.base_dir = base_di... |
class DyReLU(BaseModule):
def __init__(self, channels: int, ratio: int=4, conv_cfg: OptConfigType=None, act_cfg: MultiConfig=(dict(type='ReLU'), dict(type='HSigmoid', bias=3.0, divisor=6.0)), init_cfg: OptMultiConfig=None) -> None:
super().__init__(init_cfg=init_cfg)
if isinstance(act_cfg, dict):
... |
def make_data_loader(cfg, is_train=True, is_distributed=False, start_iter=0):
num_gpus = get_world_size()
if is_train:
videos_per_batch = cfg.SOLVER.VIDEOS_PER_BATCH
assert ((videos_per_batch % num_gpus) == 0), 'SOLVER.VIDEOS_PER_BATCH ({}) must be divisible by the number '
.format(video... |
def simclr_resnet50(num_classes, **kwargs):
return SimCLRResNet(base_model='resnet50', num_classes=num_classes) |
class SequentialModel(MetaEstimatorMixin, _BaseModel, metaclass=ABCMeta):
def __init__(self, estimator, estimator_hyperparams=None, permutation_test_params=None, latent_dimensions=None, copy_data=True, accept_sparse=False, random_state=None, permutation_test=False, p_threshold=0.001, corr_threshold=0.0):
su... |
class BaseOptions():
def __init__(self):
self.initialized = False
def initialize(self, parser):
parser.add_argument('--dataroot', required=True, help='Path to images')
parser.add_argument('--batchsize', type=int, default=2, help='Batch size')
parser.add_argument('--cfg_file', def... |
_model
def regnetx_006(pretrained=False, **kwargs):
return _create_regnet('regnetx_006', pretrained, **kwargs) |
def get_imdb(name):
if (not __sets.has_key(name)):
raise KeyError('Unknown dataset: {}'.format(name))
return __sets[name]() |
class LocalRunner():
def __init__(self, snapshot_config, max_cpus=1):
self._snapshotter = Snapshotter(snapshot_config.snapshot_dir, snapshot_config.snapshot_mode, snapshot_config.snapshot_gap)
parallel_sampler.initialize(max_cpus)
seed = get_seed()
if (seed is not None):
... |
class SpotterMixin():
def __init__(self, show_score, show_bbox, show_text, show_entity, dict_file=None, class_file=None, auto_reg=False):
self.show_score = show_score
self.show_bbox = show_bbox
self.show_text = show_text
self.show_entity = show_entity
self.auto_reg = auto_reg... |
class SimulationActorState(AbstractState):
def __init__(self, handle):
self.handle = handle
self.position = []
self.velocity = [] |
def global_step(scope=None):
if (scope is None):
scope = fluid.global_scope()
v = scope.find_var('_DECAY_')
step = (np.array(v.get_tensor())[0] if v else 0)
return step |
def combine_dataset_datapoints(dataset_dicts: Dict[(str, List[Datapoint])], vg_imid2data: Dict[(int, Dict)], coco_imid2data: Dict[(str, Dict)], coco_path: str) -> Tuple[(Dict[(str, List[Datapoint])], Dict[(str, List[Datapoint])])]:
coco_all_unsafe = set()
vg_all_unsafe = set()
with open(f'{coco_path}/annota... |
class TrainerKnapsack(TrainerBase):
def get_reward_name() -> str:
return 'value_items'
def is_reward_positive() -> bool:
return True
def get_observation_type() -> Type[Observation]:
return Observation
def init_encoder(self, num_layers, name) -> EncoderBase:
return Knapsac... |
def identifier_everything_sampler(ann: Annotation) -> List[Tuple[(torch.IntTensor, Tuple[(torch.IntTensor, torch.IntTensor, torch.IntTensor)], int)]]:
ret = []
for (tokens, sent) in zip(ann.tokenized_sentences, ann.doc.sentences):
i = torch.IntTensor(ann.i)
c = torch.IntTensor(ann.c)
o =... |
def test_kernel_eval():
result_string = 'ScoredKernel(k_opt=ProductKernel([ MaskKernel(ndim=4, active_dimension=1, base_kernel=PP0Kernel(lengthscale=-3.776833, output_variance=-3.365662)), MaskKernel(ndim=4, active_dimension=2, base_kernel=CubicKernel(offset=-1.149225, output_variance=-0.604651)) ]), nll=4546.59142... |
def load_tsp_test_data(num_cities: int):
if (num_cities == 100):
dataset_filename = 'experiments/evaluation_data/tsp100_test_seed1234.pkl'
elif (num_cities == 125):
dataset_filename = 'experiments/evaluation_data/tsp125_test_small_seed1235.pkl'
elif (num_cities == 150):
dataset_filen... |
def diapreresnet110_svhn(num_classes=10, **kwargs):
return get_diapreresnet_cifar(num_classes=num_classes, blocks=110, bottleneck=False, model_name='diapreresnet110_svhn', **kwargs) |
class ImageNet(Dataset):
def __init__(self, root, train=True, transform=None, target_transform=None, top_k=(1, 5), keep_rgb=False):
split = ('train' if train else 'val')
self.data_set = datasets.ImageNet(root, split=split)
self.classes = list()
for class_tuple in self.data_set.classe... |
def resnet56_cifar100(num_classes=100, **kwargs):
return get_resnet_cifar(num_classes=num_classes, blocks=56, bottleneck=False, model_name='resnet56_cifar100', **kwargs) |
def generate_info_list(data_path, save_dir, psf_type='ZTE_new'):
syn_path = os.path.join(data_path, 'synthetic_data/input')
real_path = os.path.join(data_path, 'real_data/input')
code_path = os.path.join(data_path, 'PSF/kernel_code')
os.makedirs(save_dir, exist_ok=True)
real_save_path = os.path.join... |
class SemanticBranch(BaseModule):
def __init__(self, semantic_channels=(16, 32, 64, 128), in_channels=3, exp_ratio=6, init_cfg=None):
super(SemanticBranch, self).__init__(init_cfg=init_cfg)
self.in_channels = in_channels
self.semantic_channels = semantic_channels
self.semantic_stages... |
_module()
class FPN(BaseModule):
def __init__(self, in_channels, out_channels, num_outs, start_level=0, end_level=(- 1), add_extra_convs=False, extra_convs_on_inputs=False, relu_before_extra_convs=False, no_norm_on_lateral=False, conv_cfg=None, norm_cfg=None, act_cfg=None, upsample_cfg=dict(mode='nearest'), init_cf... |
_function('log')
class AutogradLog(AutogradFunction):
def forward(ctx, input):
ctx.save_for_backward(input)
return input.log()
def backward(ctx, grad_output):
(input,) = ctx.saved_tensors
return grad_output.div(input) |
class SeparableConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding=''):
super(SeparableConv2d, self).__init__()
self.depthwise_conv2d = create_conv2d(in_channels, in_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=in_channels)
... |
class SKMotionEncoder6_Deep_nopool_res(nn.Module):
def __init__(self, args):
super().__init__()
self.cor_planes = cor_planes = (((((args.corr_radius * 2) + 1) ** 2) * args.cost_heads_num) * args.corr_levels)
self.convc1 = PCBlock4_Deep_nopool_res(cor_planes, 128, k_conv=args.k_conv)
... |
class MultiprocessingPdb(pdb.Pdb):
def __init__(self):
pdb.Pdb.__init__(self, nosigint=True)
def _cmdloop(self):
stdin_bak = sys.stdin
with _stdin_lock:
try:
if (_stdin_fd is not None):
if (not _stdin[0]):
_stdin[0] ... |
def strip_ddp_state_dict(state_dict):
clean_state_dict = type(state_dict)()
for (k, v) in state_dict.items():
key = (k[7:] if (k[:7] == 'module.') else k)
clean_state_dict[key] = v
return clean_state_dict |
def dboxes300_coco():
figsize = 300
feat_size = [38, 19, 10, 5, 3, 1]
steps = [8, 16, 32, 64, 100, 300]
scales = [21, 45, 99, 153, 207, 261, 315]
aspect_ratios = [[2], [2, 3], [2, 3], [2, 3], [2], [2]]
dboxes = DefaultBoxes(figsize, feat_size, steps, scales, aspect_ratios)
return dboxes |
class ClosableQueue():
def __init__(self, maxsize: int=1000):
self._maxsize = maxsize
self._queue = deque()
self._mutex = Lock()
self._not_empty = Condition(self._mutex)
self._not_full = Condition(self._mutex)
self._closed = False
def put(self, item):
with... |
def brew_install(modules):
for i in range(len(modules)):
os.system(('brew install %s' % modules[i])) |
def build_profiler(name):
if (name == 'inference'):
return InferenceProfiler()
elif (name == 'pytorch'):
from pytorch_lightning.profiler import PyTorchProfiler
return PyTorchProfiler(use_cuda=True, profile_memory=True, row_limit=100)
elif (name is None):
return PassThroughPro... |
class NERReporter(IndependentLabelReporter):
yaml_tag = '!NERReporter'
def __init__(self, args, reporting_root, reporting_methods, ner_task):
self.args = args
self.reporting_methods = reporting_methods
self.reporting_method_dict = {'label_accuracy': self.report_label_values, 'v_entropy':... |
def cluster_bibliography(input_tuple):
(doc, in_tag, out_tag, src_dir, dest_dir) = input_tuple
src_doc_folder = os.path.join(src_dir, doc)
return_values = []
src_annotations_file = os.path.join(src_dir, doc, (doc + '-{}.json'.format(in_tag)))
with open(src_annotations_file) as f:
annotation_... |
def cifar_resnet18(output_dim):
model = _base_resnet18_cifar()
return _replace_fc(model, output_dim) |
((not FX_MODE), 'Unsupported Fx Mode with PyTorch Version Below 1.8')
class TestPytorchFXAdaptor(unittest.TestCase):
def tearDownClass(self):
shutil.rmtree('./saved', ignore_errors=True)
shutil.rmtree('runs', ignore_errors=True)
def test_fx_quant(self):
for approach in ['qat', 'static']:... |
class CiderScorer(object):
def copy(self):
new = CiderScorer(n=self.n)
new.ctest = copy.copy(self.ctest)
new.crefs = copy.copy(self.crefs)
return new
def __init__(self, df_mode='corpus', test=None, refs=None, n=4, sigma=6.0):
self.n = n
self.sigma = sigma
... |
def convert_from_color_segmentation(arr_3d, image_height, image_width):
palette = pascal_palette()
reshape_array = np.reshape(arr_3d, [(image_height * image_width), 3])
arr_2d = np.fromiter([palette.get((x[0], x[1], x[2]), 0) for x in reshape_array], reshape_array.dtype)
return np.reshape(np.asarray(arr... |
class NormilizeActionSpecWrapper(wrappers.EnvironmentWrapper):
def __init__(self, environment):
super().__init__(environment)
action_spec = environment.action_spec()
self._scale = (action_spec.maximum - action_spec.minimum)
self._offset = action_spec.minimum
minimum = ((actio... |
def main():
(witpols, witsols) = circle_line_set()
input('hit enter to continue')
witset1 = extend(witpols, witsols)
witset2 = singular_locus_set()
intwitset = intersect(5, 3, 2, witset1, witset2)
(eqs, sols) = intwitset
print('the solutions :')
for sol in sols:
print(sol)
so... |
class TransformerEncoder(nn.Module):
def __init__(self, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4.0, qkv_bias=False, drop_rate=0.0, attn_drop_rate=0.0, drop_path_rate=0.0, act_args={'act': 'gelu'}, norm_args={'norm': 'ln'}):
super().__init__()
self.blocks = nn.ModuleList([Block(dim=embed_di... |
class ImagePreprocessor(object):
__metaclass__ = ABCMeta
def __init__(self):
pass
def preprocess(self, image):
pass |
def test_ohem_sampler_empty_gt():
assigner = MaxIoUAssigner(pos_iou_thr=0.5, neg_iou_thr=0.5, ignore_iof_thr=0.5, ignore_wrt_candidates=False)
bboxes = torch.FloatTensor([[0, 0, 10, 10], [10, 10, 20, 20], [5, 5, 15, 15], [32, 32, 38, 42]])
gt_bboxes = torch.empty(0, 4)
gt_labels = torch.LongTensor([])
... |
class Sliding(_ExpandingSliding):
def __init__(self, length, step):
super(Sliding, self).__init__(initial_length=length, start_step=step, end_step=step) |
def get_latest_epoch(loadpath):
states = glob.glob1(os.path.join(*loadpath), 'state_*')
latest_epoch = (- 1)
for state in states:
epoch = int(state.replace('state_', '').replace('.pt', ''))
latest_epoch = max(epoch, latest_epoch)
return latest_epoch |
def create_policy(*, name, env_spec, policy_type, hidden_sizes, hidden_nonlinearity=None, use_lstm=False, lstm_hidden_dim=None, omit_obs_idxs=None, dim_option=None):
option_info = {'dim_option': dim_option}
policy_kwargs = dict(env_spec=env_spec, name=name, omit_obs_idxs=omit_obs_idxs, option_info=option_info)
... |
(version='2.0')
def extract_data_type(data_type: str) -> str:
return (('signed', data_type) if (data_type[0] != 'u') else ('unsigned', data_type[1:])) |
def prepare_add_background_given_object(image, datum, verbose=False, prefix_plan=None, background_instruction='Add gray background'):
task = 'add_background_given_object'
if verbose:
print('Task: ', task)
print('Fill out background, given all objects')
print('context: all boxes')
... |
def build_dataset(cfg, default_args=None):
from .dataset_wrappers import ConcatDataset, RepeatDataset, MixDataset, ClassBalancedDataset
if isinstance(cfg, (list, tuple)):
dataset = ConcatDataset([build_dataset(c, default_args) for c in cfg])
elif (cfg['type'] == 'ConcatDataset'):
dataset = C... |
def resnet164bn_svhn(num_classes=10, **kwargs):
return get_resnet_cifar(num_classes=num_classes, blocks=164, bottleneck=True, model_name='resnet164bn_svhn', **kwargs) |
def is_device_locked(serialno):
import filelock
try:
with device_lock(serialno, timeout=1e-06):
return False
except filelock.Timeout:
return True |
def cnf_to_dimacs(file_name, clauses, num_atoms):
with open(file_name, 'w') as f:
f.write(f'''p cnf {num_atoms} {len(clauses)}
''')
for c in clauses:
for l in c:
f.write((str(l) + ' '))
f.write(('0' + '\n')) |
def render(pcl):
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
print(pcl.height_min, pcl.height_max)
renderer.AddActor(p... |
class Tester(unittest.TestCase):
def test_pksampler(self):
(p, k) = (16, 4)
dataset = FakeData(size=100, num_classes=10, image_size=(3, 1, 1))
targets = [target.item() for (_, target) in dataset]
self.assertRaises(AssertionError, PKSampler, targets, p, k)
dataset = FakeData(s... |
def generate_pickles(ds_name, data_labels_path, output_path, instances_per_label, generate_cls_valid, seed):
path = Path(data_labels_path)
train_labels = pd.read_feather((path / 'labels_train.feather'))
test_labels = pd.read_feather((path / 'labels_test.feather'))
test_labels.id = ('test/' + test_labels... |
class Bottleneck(nn.Module):
def __init__(self, in_channels, bottleneck_channels, out_channels, num_groups, stride_in_1x1, stride, dilation, norm_func):
super(Bottleneck, self).__init__()
self.downsample = None
if (in_channels != out_channels):
down_stride = (stride if (dilation ... |
class ActivationConf(WeightConf):
def __init__(self, datatype=None, scheme=None, granularity=None, algorithm=None):
super().__init__(datatype, scheme, granularity, algorithm) |
class OverallConstraintViolationComparatorTestCases(unittest.TestCase):
def setUp(self):
self.comparator: Comparator = OverallConstraintViolationComparator()
def test_should_comparator_return_0_if_the_solutions_have_no_constraints(self):
solution1 = Solution(1, 1, 0)
solution2 = Solution... |
def find_cut(rhos_array):
cut = min(np.argwhere((np.count_nonzero(rhos_array, axis=0) > 1)))[0]
return cut |
class MAMLTrajectoryBatch(collections.namedtuple('MAMLTrajectoryBatch', ['paths', 'observations', 'actions', 'rewards', 'valids', 'baselines'])): |
class AudioPreprocessing(nn.Module):
def __init__(self, **kwargs):
nn.Module.__init__(self)
self.optim_level = kwargs.get('optimization_level', Optimization.nothing)
self.featurizer = FeatureFactory.from_config(kwargs)
def forward(self, x: Tuple[(torch.Tensor, torch.Tensor)]) -> Tuple[(t... |
class RandomRotate(object):
def __init__(self, angle, diff_angle=0, order=2, reshape=False):
self.angle = angle
self.reshape = reshape
self.order = order
def __call__(self, sample):
(image, depth) = (sample['image'], sample['depth'])
mean_depth = round((ImageStat.Stat(dep... |
def get_selected_template_idx_dataset(model_id):
import numpy as np
def map_fn(pred):
return np.argmax(np.array(pred['probs']))
return _get_predictions_dataset(model_id).map(map_fn) |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments))
if ((len(sys.argv) == 2) and sys.argv[1].endswith('.json')):
(model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
(model_args, data_arg... |
def lid_filter(split, src, tgt, from_folder, to_folder, debug=False):
if (not os.path.exists(LID_MODEL)):
call(f'wget -nc -O {LID_MODEL}')
from_prefix = f'{from_folder}/{split}.{src}-{tgt}'
to_prefix = f'{to_folder}/{split}.{src}-{tgt}'
if (os.path.exists(f'{from_prefix}.{src}') and os.path.exi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.