code stringlengths 101 5.91M |
|---|
class TenCrop(object):
def __init__(self, size, vertical_flip=False):
self.size = size
if isinstance(size, numbers.Number):
self.size = (int(size), int(size))
else:
assert (len(size) == 2), 'Please provide only two dimensions (h, w) for size.'
self.size = ... |
def run_window_all(conf):
print('run test window')
slices = conf['data']['slices']
slices = list(range(slices))
if ('skip' in conf['data']):
for i in conf['data']['skip']:
slices.remove(i)
for i in slices:
print('start run for slice ', str(i))
send_message(('start... |
def _load_conf(conf='.spdrc.json', var_dict=SYS):
if os.path.isfile(conf):
with open(conf) as json_data:
var_dict.add(json.load(json_data)) |
class DNATokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
def __init__(self, vocab_file, do_lower_... |
class XLMModelTester():
def __init__(self, parent, batch_size=13, seq_length=7, is_training=True, use_input_lengths=True, use_token_type_ids=True, use_labels=True, gelu_activation=True, sinusoidal_embeddings=False, causal=False, asm=False, n_langs=2, vocab_size=99, n_special=0, hidden_size=32, num_hidden_layers=5, ... |
_criterion('cross_entropy', dataclass=CrossEntropyCriterionConfig)
class CrossEntropyCriterion(FairseqCriterion):
def __init__(self, task, sentence_avg):
super().__init__(task)
self.sentence_avg = sentence_avg
def forward(self, model, sample, reduce=True):
net_output = model(**sample['ne... |
_with_exponential_backoff(ERRORS)
def chat_completions_with_backoff(*args, **kwargs):
assert (OPENAI_CLIENT is not None)
return OPENAI_CLIENT.chat.completions.create(*args, **kwargs) |
def adjacent_coordinates(x, y, s):
adj = []
adj.append([(x - s), (y - s)])
adj.append([x, (y - s)])
adj.append([(x + s), (y - s)])
adj.append([(x - s), y])
adj.append([(x + s), y])
adj.append([(x - s), (y + s)])
adj.append([x, (y + s)])
adj.append([(x + s), (y + s)])
return adj |
class KandinskyCombinedPipeline(DiffusionPipeline):
_load_connected_pipes = True
model_cpu_offload_seq = 'text_encoder->unet->movq->prior_prior->prior_image_encoder->prior_text_encoder'
def __init__(self, text_encoder: MultilingualCLIP, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: ... |
def test(args, test_loader, model, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
end = time.time()
model.eval()
if (not args.no_progress):
test_loader = tqdm(test_loader, disable=(args.local_rank... |
def get_acc_diff(row, scores_df, task_list):
score_row1 = scores_df.iloc[row['seed1']]
score_row2 = scores_df.iloc[row['seed2']]
for task in task_list:
acc1 = score_row1[task]
acc2 = score_row2[task]
row[f'{task}_diff'] = abs((acc1 - acc2))
return row |
def main_worker(args):
global best_acc1
if args.pretrained:
print("=> using pre-trained model '{}'".format(args.arch))
model = models.__dict__[args.arch](pretrained=True)
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
traindir... |
_model
def ssl_resnext101_32x16d(pretrained=True, **kwargs):
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16, **kwargs)
return _create_resnet('ssl_resnext101_32x16d', pretrained, **model_args) |
def get_data(bs, sz):
img_patch = torch.randn(bs, 3, sz, sz)
att_mask = (torch.rand(bs, sz, sz) > 0.5)
return NestedTensor(img_patch, att_mask) |
def test_reference_wrapper():
assert (m.refwrap_builtin(42) == 420)
assert (m.refwrap_usertype(UserType(42)) == 42)
with pytest.raises(TypeError) as excinfo:
m.refwrap_builtin(None)
assert ('incompatible function arguments' in str(excinfo.value))
with pytest.raises(TypeError) as excinfo:
... |
class TFElectraForQuestionAnswering():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
def ContrastPredict(PixelPath, PatchPath, batch_size, temperature, projection_dim, input_dim):
from DefinedModels import Contrast, MoCo
from Preprocess import feature_normalize2
model = MoCo(projection_dim=projection_dim, input_dim=input_dim, r=640, m=0.999, T=temperature)
print(model)
train_data = ... |
def test_list(capture, doc):
with capture:
lst = m.get_list()
assert (lst == ['inserted-0', 'overwritten', 'inserted-2'])
lst.append('value2')
m.print_list(lst)
assert (capture.unordered == '\n Entry at position 0: value\n list item 0: inserted-0\n list item ... |
def dws_conv3x3_block(in_channels, out_channels, activate):
return DwsConvBlock(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1, activate=activate) |
class DiagGaussian(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(DiagGaussian, self).__init__()
self.num_outputs = num_outputs
init_ = (lambda m: init(m, init_normc_, (lambda x: nn.init.constant_(x, 0))))
self.fc_mean = init_(nn.Linear(num_inputs, num_outputs))
... |
class Encoder(nn.Module):
c: Config
def __call__(self, obs):
x = obs.reshape((((- 1),) + obs.shape[2:]))
Conv = partial(nn.Conv, kernel_size=(4, 4), strides=(2, 2), padding='VALID')
x = leaky_relu(Conv(self.c.total_filters)(x))
x = leaky_relu(Conv((self.c.total_filters * 2))(x))
... |
def build_trainer(hp: 'ModelParams', outdir: str, labels: Dict[(str, Any)], **kwargs) -> Trainer:
if (hp.model_type() == 'categorical'):
return Trainer(hp, outdir, labels, **kwargs)
if (hp.model_type() == 'linear'):
return LinearTrainer(hp, outdir, labels, **kwargs)
if (hp.model_type() == 'c... |
def save_logger(logfile_path='../dataset/cogkge.log', rank=(- 1)):
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d][%(levelname)s][%(message)s]'
simple_format = '[%(asctime)s] - [%(message)s]'
LOGGING_DIC = {'version': 1, 'disable_existing_loggers': Fals... |
def main():
path = '163459__littlebigsounds__lbs-fx-dog-small-alert-bark001.wav'
(y, sr) = librosa.load(path, offset=0.1, duration=1.2)
fig = plot_augmentations(y, sr)
out = __file__.replace('.py', '.png')
fig.savefig(out, bbox_inches='tight') |
def ema_update(wa_model, model, global_step, decay_rate=0.995, warmup_steps=0, dynamic_decay=True):
factor = int((global_step >= warmup_steps))
if dynamic_decay:
delta = (global_step - warmup_steps)
decay = (min(decay_rate, ((1.0 + delta) / (10.0 + delta))) if ((10.0 + delta) != 0) else decay_ra... |
def embedded_dropout(embed, words, dropout, scale=None):
if dropout:
mask = (embed.weight.data.new().resize_((embed.weight.size(0), 1)).bernoulli_((1 - dropout)).expand_as(embed.weight) / (1 - dropout))
masked_embed_weight = (mask * embed.weight)
else:
masked_embed_weight = embed.weight
... |
class ClusterNet5gMultiHead(ResNet):
num_name_mapping = {1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E', 6: 'F', 7: 'G'}
name_num_mapping = {v: k for (k, v) in num_name_mapping.items()}
def __init__(self, num_channel: int=3, output_k_list: List[int]=[70, 10], semisup: bool=False, num_sub_heads: int=5, batchnorm_tra... |
class SimulatorProcessStateExchange(SimulatorProcessBase):
def __init__(self, idx, pipe_c2s, pipe_s2c):
super(SimulatorProcessStateExchange, self).__init__(idx)
self.c2s = pipe_c2s
self.s2c = pipe_s2c
def run(self):
player = self._build_player()
context = zmq.Context()
... |
def validate(model, loader, loss_fn, args, amp_autocast=suppress, log_suffix=''):
batch_time_m = AverageMeter()
losses_m = AverageMeter()
top1_m = AverageMeter()
top5_m = AverageMeter()
model.eval()
end = time.time()
last_idx = (len(loader) - 1)
with torch.no_grad():
for (batch_i... |
def save_dataframe(df, fname, path):
with open(os.path.join(path, (fname + '.pkl')), 'wb') as fd:
pickle.dump(df, fd) |
_model
def efficientnet_b0(pretrained=False, **kwargs):
model = _gen_efficientnet('efficientnet_b0', channel_multiplier=1.0, depth_multiplier=1.0, pretrained=pretrained, **kwargs)
return model |
class CosineProximityCriterion(Criterion):
def __init__(self, bigdl_type='float'):
super(CosineProximityCriterion, self).__init__(None, bigdl_type) |
def unet_cct(in_channels, num_classes):
model = UNet_CCT(in_channels, num_classes)
init_weights(model, 'kaiming')
return model |
class SimpleGray(nn.Module):
def __init__(self):
super(SimpleGray, self).__init__()
gray_vector = torch.tensor([0.2989, 0.587, 0.114]).view(1, 3, 1, 1)
self.register_buffer('buf', gray_vector)
return
def forward(self, x):
w = Variable(self.buf)
return F.conv2d(x, ... |
class SegNet():
def __init__(self, encoderPth, decoderPth, segId=1, segFg=True):
net_encoder = segModel.ModelBuilder.build_encoder(fc_dim=2048, weights=encoderPth)
net_decoder = segModel.ModelBuilder.build_decoder(fc_dim=2048, num_class=150, weights=decoderPth)
self.net = segModel.Segmentati... |
_SAMPLERS.register_module()
class PseudoSampler(BaseSampler):
def __init__(self, **kwargs):
pass
def _sample_pos(self, **kwargs):
raise NotImplementedError
def _sample_neg(self, **kwargs):
raise NotImplementedError
def sample(self, assign_result, bboxes, gt_bboxes, **kwargs):
... |
class Calib_Dataloader(object):
def __init__(self):
pass
def register_transformation(self):
if (globals.code_domain == 'transformers_trainer'):
globals.list_calib_dataloader_name.append('trainer.get_eval_dataloader()')
elif (globals.code_domain == 'transformers_no_trainer'):
... |
def get_extensions():
this_dir = os.path.dirname(os.path.abspath(__file__))
extensions_dir = os.path.join(this_dir, 'dcn/src')
main_file = glob.glob(os.path.join(extensions_dir, '*.cpp'))
source_cpu = glob.glob(os.path.join(extensions_dir, 'cpu', '*.cpp'))
source_cuda = glob.glob(os.path.join(extens... |
def save_image(net, fixed_z, args, sample_dir, i):
net.eval()
with torch.no_grad():
([sampled_src, sampled_dst, rec_dst, without_color_dst], loss) = net([fixed_z], truncation=args.sample_truncation, inference=True)
grid_rows = int((args.n_sample ** 0.5))
save_images(sampled_dst, sample_d... |
class ReweightedWakeSleep(HelmholtzMachine):
def __init__(self, p_layers, q_layers, **kwargs):
super(ReweightedWakeSleep, self).__init__(p_layers, q_layers, **kwargs)
def log_prob_p(self, samples):
n_layers = len(self.p_layers)
n_samples = samples[0].shape[0]
log_p = ([None] * n_... |
def display_batch(batch, size=10):
(imgs, tars) = next(iter(batch))
plt.figure(figsize=((size * 5), 5))
for img_idx in range(size):
if (NUM_CLASSES > 2):
lb = string_label[tf.argmax(tars[img_idx]).numpy()]
else:
lb = string_label[tars[img_idx].numpy()]
plt.sub... |
class HTTPRedirect(Exception):
def __init__(self, url, code=303):
self.url = url
self.code = code
def __repr__(self):
return ('HTTPRedirect(url=%s)' % repr(self.url)) |
class RandomCropFromBorders(DualTransform):
def __init__(self, crop_value=None, crop_0_min=None, crop_0_max=None, crop_1_min=None, crop_1_max=None, crop_2_min=None, crop_2_max=None, always_apply=False, p=1.0):
super(RandomCropFromBorders, self).__init__(always_apply, p)
self.crop_0_min = 0.1
... |
def negative_r2(y_true, y_predicted, sample_weight=None):
val = r2_score(y_true, y_predicted, sample_weight=sample_weight)
return ((- 1.0) * val) |
def _deregister_tracers(tracers):
shell().tracer_cleanup_pending = True
for tracer in tracers:
tracer.clear_instance()
try:
shell().registered_tracers.remove(tracer)
except ValueError:
pass |
class Conll03Processor(QueryNERProcessor):
def get_labels(self):
return ['ORG', 'PER', 'LOC', 'MISC', 'O'] |
def test_probability_raises(model, X):
f = getattr(model, 'probability')
assert_raises(ValueError, f, [X])
assert_raises(ValueError, f, X[0])
assert_raises((ValueError, TypeError, RuntimeError), f, X[0][0])
if (MIN_VALUE is not None):
assert_raises(ValueError, f, [[[(MIN_VALUE - 0.1) for i i... |
_registry(operator_type='View')
class View(Operator):
def __init__(self):
super().__init__()
def set_attr(self, framework, node):
if (framework == 'torch'):
shape_list = []
if (node.inputsAt(1).type().kind() == 'ListType'):
shape_list = parseTorchListConst... |
def build_sampler(cfg, **default_args):
warnings.warn('``build_sampler`` would be deprecated soon, please use ``mmdet.registry.TASK_UTILS.build()`` ')
return TASK_UTILS.build(cfg, default_args=default_args) |
def batch_iterator(batch_size=10):
for _ in tqdm(range(0, args.n_examples, batch_size)):
(yield [next(iter_dataset)[args.text_column] for _ in range(batch_size)]) |
_model
def nest_tiny(pretrained=False, **kwargs):
model_kwargs = dict(embed_dims=(96, 192, 384), num_heads=(3, 6, 12), depths=(2, 2, 8), **kwargs)
model = _create_nest('nest_tiny', pretrained=pretrained, **model_kwargs)
return model |
class NumericalImputation(AutotabularPreprocessingAlgorithm):
def __init__(self, strategy: str='mean', random_state: Optional[np.random.RandomState]=None):
self.strategy = strategy
self.random_state = random_state
def fit(self, X: PIPELINE_DATA_DTYPE, y: Optional[PIPELINE_DATA_DTYPE]=None) -> 'N... |
def highway_layer(arg, bias, bias_start=0.0, scope=None, wd=0.0, input_keep_prob=1.0, is_train=None, output_size=None):
with tf.variable_scope((scope or 'highway_layer')):
if (output_size is not None):
d = output_size
else:
d = arg.get_shape()[(- 1)]
trans = linear([a... |
def load_aliases(alias_path):
aliases = {}
print(('Loading aliases from "%s"' % alias_path))
with open(alias_path, 'r') as f:
for line in f:
line = [s.strip() for s in line.split(',')]
for s in line:
aliases[s] = line[0]
return aliases |
def compute_bleu(reference_corpus, translation_corpus, max_order=4, smooth=False):
matches_by_order = ([0] * max_order)
possible_matches_by_order = ([0] * max_order)
reference_length = 0
translation_length = 0
for (references, translation) in zip(reference_corpus, translation_corpus):
refere... |
class Compose(object):
def __init__(self, transforms):
self.transforms = transforms
def __call__(self, img):
for t in self.transforms:
img = t(img)
return img
def __repr__(self):
format_string = (self.__class__.__name__ + '(')
for t in self.transforms:
... |
(Kernel, AbstractSampler, TensorLike, TensorLike)
def _decoupled_fallback(kern: Kernel, prior: AbstractSampler, Z: TensorLike, u: TensorLike, *, mean_function: Callable=None, update_rule: Callable=exact_update, join_rule: Callable=sum, **kwargs):
f = prior(Z, sample_axis=None)
update = update_rule(kern, Z, u, f... |
def test_add_package_dependency_invalid_version_raises(ing):
with pytest.raises(ValueError):
ing.add_package_dependency('django', 'foobar') |
def has_modal(span):
for token in span:
if (token.tag_ == 'MD'):
return 1
return 0 |
class A2CAlgo(BaseAlgo):
def __init__(self, envs, acmodel, device=None, num_frames_per_proc=None, discount=0.99, lr=0.01, gae_lambda=0.95, entropy_coef=0.01, value_loss_coef=0.5, max_grad_norm=0.5, recurrence=4, rmsprop_alpha=0.99, rmsprop_eps=1e-08, preprocess_obss=None, reshape_reward=None):
num_frames_pe... |
class Conv3dGRUCell(ConvRNNCellBase):
def __init__(self, in_channels, out_channels, kernel_size, bias=True, stride=1, dilation=1, groups=1):
super().__init__(mode='GRU', in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, bias=bias, convndim=3, stride=stride, dilation=dilation, grou... |
class SubtokenizerTest(tf.test.TestCase):
def _init_subtokenizer(self, vocab_list):
temp_file = tempfile.NamedTemporaryFile(delete=False)
with tf.io.gfile.GFile(temp_file.name, 'w') as w:
for subtoken in vocab_list:
w.write(("'%s'" % subtoken))
w.write('\n... |
def make_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer, data_args) -> Dict:
dataset_cls = (LazySupervisedDataset if data_args.lazy_preprocess else SupervisedDataset)
rank0_print('Loading data...')
raw_data = json.load(open(data_args.data_path, 'r'))
perm = np.random.permutation(len(... |
def generate_binary_sequence(size) -> torch.Tensor:
def _gen(sequence_possessed: torch.Tensor, _size: int) -> torch.Tensor:
if (_size == sequence_possessed.shape[1]):
return sequence_possessed
base = sequence_possessed.repeat([2, 1])
appendix = torch.cat([torch.ones((base.shape[0... |
def get_one_from_grid_search(config, index=0):
config = dcopy(config)
if is_grid_search(config):
return config['grid_search'][index]
else:
return config |
class MyPaintWidgetRobot(Widget):
def file_len(self, fname):
with open(fname) as f:
for (i, l) in enumerate(f):
pass
if ('i' in locals()):
return (i + 1)
else:
return 0
def calculate_radius_robot(self):
x_scale = (pos_scales[0][... |
def _read_tensor_from_buf(value, shm_tensor_buffer):
if isinstance(value, TensorMeta):
if (value.numel == 0):
return torch.tensor([], dtype=value.dtype)
else:
shm_tensor = torch.frombuffer(buffer=shm_tensor_buffer.buf, dtype=value.dtype, offset=value.offset, count=value.numel... |
def preprocess_function(examples, tokenizer=tokenizer):
args = ((examples[sentence1_key],) if (sentence2_key is None) else (examples[sentence1_key], examples[sentence2_key]))
result = tokenizer(*args, padding=False, max_length=max_seq_length, truncation=True)
if ((label_to_id is not None) and ('label' in ex... |
def plot_prediction(row, scale=True, log=False):
gold_key = outcome_type
start_point = len(row[gold_key])
for (i, val) in enumerate(row['deaths']):
if (val > 10):
start_point = i
break
start_point = 60
if (len(row[gold_key][start_point:]) < 3):
return
data... |
def plot_diffs(c1):
c1 = {k: v for (k, v) in c1.items() if (v != 0)}
(fig, ax) = plt.subplots(figsize=(19, 6))
xs = np.arange(len(c1))
ax.set_xticks(xs)
ax.set_xticklabels(c1.keys(), rotation=45)
plt.plot(xs, c1.values(), '-')
plt.show() |
class BlenderbotConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk... |
def test_show():
import mmcv
from os import path as osp
from mmdet3d.core.bbox import LiDARInstance3DBoxes
tmp_dir = tempfile.TemporaryDirectory()
temp_dir = tmp_dir.name
root_path = './tests/data/lyft'
ann_file = './tests/data/lyft/lyft_infos.pkl'
class_names = ('car', 'truck', 'bus', '... |
def test_center_region_assigner():
self = CenterRegionAssigner(pos_scale=0.3, neg_scale=1)
bboxes = torch.FloatTensor([[0, 0, 10, 10], [10, 10, 20, 20], [8, 8, 9, 9]])
gt_bboxes = torch.FloatTensor([[0, 0, 11, 11], [10, 10, 20, 20], [4.5, 4.5, 5.5, 5.5], [0, 0, 10, 10]])
gt_labels = torch.LongTensor([2,... |
def coarsify2abstract(shoppinglist: list[dict], abstract_scene_description: str) -> list[dict]:
shoppinglist_ablated = copy.deepcopy(shoppinglist)
for el in shoppinglist_ablated:
assert (('class_name' in el) and ('attributes' in el))
el['class_name'] = abstract_scene_description
el['attr... |
def prepare_jit_inputs(inputs, model, tokenizer):
num_batch = len(inputs)
dummy_input = tokenizer.batch_encode_plus(inputs, return_tensors='pt', padding=True)
(num_block_layers, num_attention_heads, num_embedding_size_per_head) = sparse_model_config(model.config)
if (model.config.model_type == 'bloom'):... |
def find_weather_presets():
presets = [x for x in dir(carla.WeatherParameters) if re.match('[A-Z].+', x)]
return [(getattr(carla.WeatherParameters, x), x) for x in presets] |
def _get_depths(alpha: float) -> List[int]:
depths = [32, 16, 24, 40, 80, 96, 192, 320]
return [_round_to_multiple_of((depth * alpha), 8) for depth in depths] |
def make_layers(cfg, **kwargs):
layers = []
in_channels = 3
for v in cfg:
if (v == 'M1'):
layers += [nn.MaxPool2d(kernel_size=3, stride=2, padding=1)]
elif (v == 'M2'):
layers += [nn.MaxPool2d(kernel_size=3, stride=1, padding=1)]
elif (v == 'M'):
l... |
class PixelShuffle_ICNR(Module):
def __init__(self, ni: int, nf: int=None, scale: int=2, blur: bool=False, norm_type=NormType.Weight, leaky: float=None):
nf = ifnone(nf, ni)
self.conv = conv_layer(ni, (nf * (scale ** 2)), ks=1, norm_type=norm_type, use_activ=False)
icnr(self.conv[0].weight)
... |
def conv1d(inputs, num_output_channels, kernel_size, scope, stride=1, padding='SAME', data_format='NHWC', use_xavier=True, stddev=0.001, weight_decay=None, activation_fn=tf.nn.relu, bn=False, bn_decay=None, is_training=None):
with tf.variable_scope(scope) as sc:
assert ((data_format == 'NHWC') or (data_form... |
class InferenceOptimizer(BaseInferenceOptimizer):
ALL_INFERENCE_ACCELERATION_METHOD: Dict = {'original': TFAccelerationOption(), 'static_int8': TFAccelerationOption(inc=True), 'bf16': TFAccelerationOption(bf16=True), 'openvino_fp32': TFAccelerationOption(openvino=True), 'openvino_bf16': TFAccelerationOption(openvin... |
def process_datasets(config, api_config, max_suffix_length=0):
possible_datasets = __filter_datasets_from_config(config)
for (idx, dataset) in enumerate(possible_datasets):
max_suffix_length = _print_progress_bar((idx + len(possible_datasets)), (len(possible_datasets) * 3), ('Process ' + dataset.name), ... |
class AutoTokenizerTest(unittest.TestCase):
def test_tokenizer_from_pretrained(self):
for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if ('japanese' not in x)):
tokenizer = AutoTokenizer.from_pretrained(model_name)
self.assertIsNotNone(tokenizer)
s... |
def run_exp(exp_config: str, run_type: str, base_config='', ckpt_path='', eval_viz=False, debug=False, train_split=False, gt_semantics=False, run_id=None, run_suffix=None, wipe_only=False, deterministic=False, record_all=False, skip_log=False, simple_eval=False, opts=None) -> None:
if (run_suffix is not None):
... |
def make_dataset(root, label):
images = []
labeltxt = open(label)
for line in labeltxt:
data = line.strip().split(' ')
if is_image_file(data[0]):
path = os.path.join(root, data[0])
gt = int(data[1])
item = (path, gt)
images.append(item)
return images |
class SegmentationDataSet1(data.Dataset):
def __init__(self, inputs: list, targets: list, transform=None):
self.inputs = inputs
self.targets = targets
self.transform = transform
self.inputs_dtype = torch.float32
self.targets_dtype = torch.long
def __len__(self):
r... |
def get_top_n_labels(n, hist=None):
hist = (hist or calculate_label_distribution())
labels = sorted([(k, v) for (k, v) in hist.items()], reverse=True)
answer = []
for (_count, kws) in labels:
answer.extend(kws)
if (len(answer) >= n):
break
return answer[:n] |
def main(args):
utils.import_user_module(args)
if (args.buffer_size < 1):
args.buffer_size = 1
if ((args.max_tokens is None) and (args.max_sentences is None)):
args.max_sentences = 1
assert ((not args.sampling) or (args.nbest == args.beam)), '--sampling requires --nbest to be equal to --... |
def any_broadcast(data, root_rank, max_size=4096):
if ((not hasattr(any_broadcast, '_in_buffer')) or (max_size != any_broadcast._in_buffer.size())):
any_broadcast._buffer = torch.cuda.ByteTensor(max_size)
buffer_ = any_broadcast._buffer
enc = pickle.dumps(data)
enc_size = len(enc)
if ((enc_s... |
class ResBlock(nn.Module):
def __init__(self, nFin, nFout):
super(ResBlock, self).__init__()
self.conv_block = nn.Sequential()
self.conv_block.add_module('ConvL1', nn.Conv2d(nFin, nFout, kernel_size=3, padding=1, bias=False))
self.conv_block.add_module('BNorm1', nn.BatchNorm2d(nFout)... |
class LightConv3x3(nn.Module):
def __init__(self, in_channels, out_channels):
super(LightConv3x3, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, 1, stride=1, padding=0, bias=False)
self.conv2 = nn.Conv2d(out_channels, out_channels, 3, stride=1, padding=1, bias=False, grou... |
def rmse_bootstrap(y, y_pred, target=1, m=10000):
np.random.seed(1)
e = []
for i in range(m):
idx = np.arange(len(y))
sel = np.random.choice(idx, len(idx), replace=True)
e.append(rmse(y[sel], y_pred[sel], target))
return (rmse(y, y_pred, target), np.std(e)) |
class UNetMidBlockCrossAttnMotion(nn.Module):
def __init__(self, in_channels: int, temb_channels: int, dropout: float=0.0, num_layers: int=1, transformer_layers_per_block: int=1, resnet_eps: float=1e-06, resnet_time_scale_shift: str='default', resnet_act_fn: str='swish', resnet_groups: int=32, resnet_pre_norm: bool... |
class SetTransformer(nn.Module):
def __init__(self, dim_input, num_outputs, dim_output, num_inds=32, dim_hidden=128, num_heads=4, ln=False):
super(SetTransformer, self).__init__()
self.enc = nn.Sequential(ISAB(dim_input, dim_hidden, num_heads, num_inds, ln=ln), ISAB(dim_hidden, dim_hidden, num_heads... |
class Parser(BaseParser):
def __post_init__(self):
self.data = json.loads(self.content)
def _parse(self, selector: str) -> List[Dict[(str, str)]]:
return (jmespath.search(selector, self.data) or [])
def _raw_urls(self) -> List[Dict[(str, str)]]:
return (self._parse(self.follower) if ... |
class Factory(BaseFactory):
def pt_defaults_scope_value():
return {'activation_fn': default_activation.current_value, 'batch_normalize': True, 'learned_moments_update_rate': 0.0003, 'variance_epsilon': 0.001, 'scale_after_normalization': True}
default_patch_feature_dim = 8
def __init__(self, recon_d... |
class SynapseGroup():
__slots__ = ['id', '_synEntries', '_maxNumBitsPerWord', '_numSyn', '_numSynEntries', '_numSynMemWords', '_maxNumWords', '_maxNumSynMemWords', '_cost']
def __init__(self, groupId, synEntries):
self._maxNumSynMemWords = 16384
self._maxNumBitsPerWord = 64
self.id = gro... |
class _RepeatSampler(object):
def __init__(self, sampler):
self.sampler = sampler
def __iter__(self):
while True:
(yield from iter(self.sampler)) |
class TwoPlayer_Env1(TwoPlayerSokobanEnv):
metadata = {'render.modes': ['human', 'rgb_array', 'tiny_human', 'tiny_rgb_array']}
def __init__(self):
super(TwoPlayer_Env1, self).__init__(num_boxes=3, max_steps=200, dim_room=(7, 7)) |
def test_arg_and_kwargs():
args = ('arg1_value', 'arg2_value', 3)
assert (m.args_function(*args) == args)
args = ('a1', 'a2')
kwargs = dict(arg3='a3', arg4=4)
assert (m.args_kwargs_function(*args, **kwargs) == (args, kwargs)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.