code stringlengths 101 5.91M |
|---|
def read_vfiles(vfiles):
models = {}
for vfile in vfiles:
model_name = (vfile.split('/')[(- 2)] if ('//' not in vfile) else vfile.split('/')[(- 3)])
with open(vfile, 'r') as validf:
steps = {}
for line in validf:
entries = line.strip().split()
... |
class RODEncode(nn.Module):
def __init__(self):
super(RODEncode, self).__init__()
self.conv1a = nn.Conv3d(in_channels=2, out_channels=64, kernel_size=(9, 5, 5), stride=(1, 1, 1), padding=(4, 2, 2))
self.conv1b = nn.Conv3d(in_channels=64, out_channels=64, kernel_size=(9, 5, 5), stride=(2, 2, ... |
def find_best_match(path, prefixes):
path_parts = path.split('.')
for p in prefixes:
if ((len(p) <= len(path_parts)) and (p == path_parts[:len(p)])):
return ('.'.join(p), '.'.join(path_parts[len(p):]))
return ('', path) |
class RTE(AbstractTask):
name = 'rte'
labels_list = ['0', '1']
metric = [metrics.accuracy]
metric_names = ['accuracy']
split_to_data_split = {'train': 'train', 'validation': 'validation', 'test': 'validation'}
def load_dataset(self, split):
return datasets.load_dataset('glue', 'rte', spl... |
def test_double_double_polynomial(vrblvl=0):
set_double_double_dimension(2, vrblvl)
dim = get_double_double_dimension(vrblvl)
print('the dimension :', dim)
org = 'x*y - 1;'
idx = 1
set_double_double_polynomial(idx, dim, org, vrblvl)
pol = get_double_double_polynomial(idx, vrblvl)
print('... |
def Process(args):
old_file = open(args.file_path, 'r')
if (args.output_path == None):
args.output_path = args.file_path
if (args.sampling_rate != 1.0):
new_file_path = ((args.output_path + '_sam') + str(args.kmer))
else:
new_file_path = ((args.output_path + '_cut') + str(args.km... |
def clip_norms(gs, c):
norm = T.sqrt(sum([T.sum((g ** 2)) for g in gs]))
return [clip_norm(g, c, norm) for g in gs] |
def test_inheritance(msg):
roger = m.Rabbit('Rabbit')
assert (((roger.name() + ' is a ') + roger.species()) == 'Rabbit is a parrot')
assert (m.pet_name_species(roger) == 'Rabbit is a parrot')
polly = m.Pet('Polly', 'parrot')
assert (((polly.name() + ' is a ') + polly.species()) == 'Polly is a parrot... |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
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_args,... |
def test_actionAngleTorus_hessian_linear():
from galpy.actionAngle import actionAngleTorus
from galpy.potential import MWPotential2014
aAT = actionAngleTorus(pot=MWPotential2014)
(jr, jphi, jz) = (0.075, 1.1, 0.05)
h = aAT.hessianFreqs(jr, jphi, jz, tol=0.0001, nosym=True)[0]
dj = numpy.array([0... |
def makeInternalLink(title, label):
colon = title.find(':')
if ((colon > 0) and (title[:colon] not in options.acceptedNamespaces)):
return ''
if (colon == 0):
colon2 = title.find(':', (colon + 1))
if ((colon2 > 1) and (title[(colon + 1):colon2] not in options.acceptedNamespaces)):
... |
def json_pack(snippets_dir, video_name, frame_width, frame_height, label='unknown', label_index=(- 1)):
sequence_info = []
p = Path(snippets_dir)
for path in p.glob((video_name + '*.json')):
json_path = str(path)
print(path)
frame_id = int(path.stem.split('_')[(- 2)])
frame_d... |
class BaseModel():
def load(self, args, **kwargs):
raise NotImplementedError()
def save(self, args, **kwargs):
raise NotImplementedError()
def train_on_instance(self, x, y):
raise NotImplementedError()
def eval_on_instance(self, x, y):
raise NotImplementedError()
def ... |
def mk_vqa_dataloader(anno_path, img_lmdb_dir, cfg, tokenizer, is_train=True):
if isinstance(anno_path, str):
raw_datalist = load_jsonl(anno_path)
else:
raw_datalist = flat_list_of_lists([load_jsonl(p) for p in anno_path])
if (cfg.data_ratio != 1.0):
random.shuffle(raw_datalist)
... |
def run_eval(args, logger, model, eval_dataloader, all_guids, task_name, return_preds=False):
model.eval()
eval_loss = 0
nb_eval_steps = 0
preds = []
pred_guids = []
out_label_ids = None
for eval_batch in tqdm(eval_dataloader, desc='Evaluating'):
eval_batch = tuple((t.to(args.device)... |
def _echo_run_names(header, d):
click.echo((('-----' + header) + '-----'))
for name in d:
click.echo(name)
click.echo() |
def run_baseline(args, model, inp, dec_prefix, adjust=True):
if (args.task == 'sum'):
forced_bos_token_id = None
else:
forced_bos_token_id = dec_prefix[(- 1)]
if (args.max_len == (- 1)):
input_ids = tokenizer(inp, return_tensors='pt').input_ids
cur_max_len = (input_ids.squeez... |
def _selective_search_IJCV_top_k(split, year, top_k):
imdb = datasets.pascal_voc(split, year)
imdb.roidb_handler = imdb.selective_search_IJCV_roidb
imdb.config['top_k'] = top_k
return imdb |
def isalpha_num(token):
char_set = set(token)
num_found = False
alpha_found = False
for char in char_set:
if char.isalpha():
alpha_found = True
if char.isnumeric():
num_found = True
if ((alpha_found == True) and (num_found == True)):
return True
el... |
class XCLIPTextModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class ASPP(nn.Module):
def __init__(self, backbone, output_stride, BatchNorm, dropout):
super(ASPP, self).__init__()
if ('drn' in backbone):
inplanes = 512
elif (backbone == 'mobilenet'):
inplanes = 320
else:
inplanes = 2048
if (output_stri... |
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, base_width=64, dilation=1, norm_layer=None):
super(BasicBlock, self).__init__()
if (norm_layer is None):
norm_layer = BatchNorm2d
if ((groups != 1) or (base_wi... |
_module()
class NerTransform():
def __init__(self, label_convertor, max_len):
self.label_convertor = build_convertor(label_convertor)
self.max_len = max_len
def __call__(self, results):
texts = results['text']
input_ids = self.label_convertor.convert_text2id(texts)
labels... |
class AutoModelForMaskedLM():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
class OneHot():
def __init__(self, n_classes, to_float: bool=False):
self.n_classes = n_classes
self.to_float = to_float
def __call__(self, label: torch.Tensor):
return (one_hot(label, self.n_classes).float() if self.to_float else one_hot(label, self.n_classes)) |
def get_script(args, BASH_COMMAND_LIST):
print('Start writing the command list!')
job_script = '\n'
for command in BASH_COMMAND_LIST:
job_script += f'''srun -N 1 -n 1 {command} &
'''
script = get_slurm_script(args, job_script)
file_path = './bash_files/'
if (not os.path.exists(file_path... |
def parse_config():
parser = argparse.ArgumentParser()
parser.add_argument('--src_vocab', type=str, default='es.vocab')
parser.add_argument('--tgt_vocab', type=str, default='en.vocab')
parser.add_argument('--arch', type=str, choices=['vanilla', 'mem', 'rg'], default='vanilla')
parser.add_argument('-... |
def get_marker_parameters():
params = {}
params['dict_id'] = cv2.aruco.DICT_4X4_50
params['marker_length'] = 0.018
params['marker_length_pixels'] = 6
params['pixels_per_mm'] = 2
params['sticker_length_mm'] = {'robots': 25, 'cubes': 28, 'corners': 24}
return params |
def placeholder_inputs(batch_size, num_point):
pointclouds_pl = tf.placeholder(tf.float32, shape=(batch_size, num_point, 3))
labels_pl = tf.placeholder(tf.int32, shape=batch_size)
mask_pl = tf.placeholder(tf.int32, shape=(batch_size, num_point))
return (pointclouds_pl, labels_pl, mask_pl) |
def _process(func, path, repeat):
data = []
try:
for i in range(repeat):
data.append(func(np.loadtxt(path.format(i))))
data = np.array(data)[(~ np.isnan(data))]
return (np.mean(data), np.std(data))
except ValueError as e:
if (len(data) != 0):
print(e)
... |
class svm_parameter(Structure):
_names = ['svm_type', 'kernel_type', 'degree', 'gamma', 'coef0', 'cache_size', 'eps', 'C', 'nr_weight', 'weight_label', 'weight', 'nu', 'p', 'shrinking', 'probability']
_types = [c_int, c_int, c_int, c_double, c_double, c_double, c_double, c_double, c_int, POINTER(c_int), POINTER... |
class SDFA_Decoder(nn.Module):
def __init__(self, num_ch_enc, num_ch_dec=[64, 64, 64, 128, 256], output_ch=49, insert_sdfa=[], sdfa_mode='OA', out_mode=''):
super().__init__()
self.insert_sdfa = insert_sdfa
self.sdfa_mode = sdfa_mode
self.out_mode = out_mode
self.num_layers =... |
class DynamicLossScaler():
def __init__(self, init_scale=(2.0 ** 15), scale_factor=2.0, scale_window=2000):
self.loss_scale = init_scale
self.scale_factor = scale_factor
self.scale_window = scale_window
self._iter = 0
self._last_overflow_iter = (- 1)
def update_scale(self... |
class DataArguments():
dataset_path: str = field(default='tatsu-lab/alpaca_farm')
dataset_name: str = field(default='alpaca_instructions')
train_splits: List[str] = field(default_factory=(lambda : ['unlabeled']))
eval_splits: List[str] = field(default_factory=(lambda : ['val']))
prompt_dict_path: st... |
def main():
print('solving a general instance of the Apollonius circle problem')
solve_general_problem()
print('solving a special instance of the Apollonius circle problem')
solve_special_problem()
print('solving a perturbed instance of the Apollonius circle problem')
solve_perturbed_problem() |
def parse_args():
parser = argparse.ArgumentParser(description='Browse a dataset')
parser.add_argument('config', help='train config file path')
parser.add_argument('--skip-type', type=str, nargs='+', default=['DefaultFormatBundle', 'Normalize', 'Collect'], help='skip some useless pipeline')
parser.add_a... |
class PGFloor(torch.nn.Module):
def __init__(self):
super(PGFloor, self).__init__()
def forward(self, x):
return PGFloorFunc.apply(x) |
class AttnGraphConvolution(nn.Module):
def __init__(self, in_features: int, out_features: int, bias: bool=False, dropout: float=0.3, alpha: float=0.2, act=F.elu):
super(AttnGraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.dropout... |
def _check_length_and_finiteness_of_metrics(nepochs, inner_logdir, metric_files):
for metric_file in metric_files:
assert (inner_logdir / metric_file).exists()
with (inner_logdir / metric_file).open() as f:
metric = np.loadtxt(f)
assert (len(metric) == nepochs)
assert np.... |
def parse_run_results(run_dict: dict):
runs_to_parsed_results = {}
for (name, json_path) in run_dict.items():
runs_to_parsed_results[name] = {}
timesteps = []
episodes = []
exploitability = []
print(f'parsing {json_path}')
with open(json_path, 'r') as json_file:
... |
class BezierRNN(nn.Module, metaclass=Named):
def __init__(self, num_classes=10, k=64, gn=False, block_size=12):
super().__init__()
self.num_classes = num_classes
self.net = nn.Sequential(conv2d(3, k), ResBlock(k, (2 * k), gn=gn, stride=2), ResBlock((2 * k), (4 * k), gn=gn, stride=2), RNNBloc... |
_module
class BalancedL1Loss(nn.Module):
def __init__(self, alpha=0.5, gamma=1.5, beta=1.0, reduction='mean', loss_weight=1.0):
super(BalancedL1Loss, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.beta = beta
self.reduction = reduction
self.loss_weight = ... |
_group.command('list')
('filters', nargs=(- 1))
_project()
def list_jobs(filters, project=None):
from cli.jobs import fetch_jobs
try:
filters = parse_args(filters)
if project:
filters['project'] = project
except Exception:
click.secho(f'Failed to parse filters: {filters}'... |
class InvertibleCheckpointFunction(torch.autograd.Function):
def forward(ctx, fn, fn_inverse, keep_input, num_bwd_passes, preserve_rng_state, num_inputs, *inputs_and_weights):
ctx.fn = fn
ctx.fn_inverse = fn_inverse
ctx.keep_input = keep_input
ctx.weights = inputs_and_weights[num_inp... |
def main(args):
save_path_base = './reddit_data/Reddit_split_2017-11/split_csv/'
save_path_k_core = (((save_path_base + str(args.k_core)) + '_') + args.save_master_k_core)
G = nx.read_gpickle(save_path_k_core)
top_nodes_G = sorted(G.degree, key=(lambda x: x[1]), reverse=True)[args.skip_n:(101 + args.ski... |
def _chunk_minibatch(batch, num_batches):
(X, y) = batch
batch_size = (len(X) // num_batches)
for i in range(num_batches):
(yield (X[(i * batch_size):((i + 1) * batch_size)], y[(i * batch_size):((i + 1) * batch_size)])) |
class SGDW(Optimizer):
def __init__(self, params, lr=required, momentum=0, dampening=0, weight_decay=0, nesterov=False):
if ((lr is not required) and (lr < 0.0)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (momentum < 0.0):
raise ValueError('Invalid momentum ... |
def prettyprint(o):
if isinstance(o, types.GeneratorType):
return ('(generator) ' + str(list(o)))
else:
return str(o) |
def resolution_to_number(string):
try:
return (int(string.split('x')[0]) * int(string.split('x')[1]))
except Exception as e:
raise P1203StandaloneError('Wrong specification of resolution {string}: {e}'.format(**locals())) |
_ASSIGNERS.register_module()
class HungarianAssigner(BaseAssigner):
def __init__(self, cls_cost=dict(type='ClassificationCost', weight=1.0), reg_cost=dict(type='BBoxL1Cost', weight=1.0), iou_cost=dict(type='IoUCost', iou_mode='giou', weight=1.0)):
self.cls_cost = build_match_cost(cls_cost)
self.reg_... |
class HolonomicEncoder(Encoder):
def get_action(self, action):
assert (len(action) == 3), f'Expected an action of size 3 but received: {action}'
return action |
class ViTConfig(PretrainedConfig):
model_type = 'vit'
def __init__(self, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act='gelu', hidden_dropout_prob=0.0, attention_probs_dropout_prob=0.0, initializer_range=0.02, layer_norm_eps=1e-12, image_size=224, patch_size=1... |
class Shape(Layer):
def __init__(self, bigdl_type='float'):
super(Shape, self).__init__(None, bigdl_type) |
def drop_data(df):
df = df.drop(df[(df['Id'] == 0)].index)
df = df.drop(df[(df['Id'] == 1)].index)
return df |
def new_softmax(labels, logits):
flatten_labels = tf.reshape(labels, [(- 1)])
n_samples = tf.shape(flatten_labels)[0]
flatten_logits = tf.reshape(logits, shape=[n_samples, (- 1)])
f_logits = tf.exp(flatten_logits)
row_sums = tf.reduce_sum(f_logits, (- 1))
t2 = tf.expand_dims(flatten_labels, 1)
... |
_model
def dla34(pretrained=False, **kwargs):
model_kwargs = dict(levels=[1, 1, 1, 2, 2, 1], channels=[16, 32, 64, 128, 256, 512], block=DlaBasic, **kwargs)
return _create_dla('dla34', pretrained, **model_kwargs) |
def _get_dataloader_by_mode(mode, subset, config):
is_train = (subset == 'train')
data_dir = config['paths']['data_dir']
if (mode == 'detector_translator'):
return ImagePairDataLoader(data_dir, subset, random_order=is_train, randomness=is_train)
elif (mode == 'motion_generator'):
model_c... |
class MLP_model(nn.Module):
def __init__(self, args, InputNorm=False):
super(MLP_model, self).__init__()
in_channels = args.num_features
hidden_channels = args.MLP_hidden
out_channels = args.num_classes
num_layers = args.All_num_layers
dropout = args.dropout
N... |
class TFCLIPVisionModel(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def build_fake_yaml():
fake_yaml = "\n model:\n name: self_distillation\n framework: pytorch\n\n distillation:\n train:\n start_epoch: 0\n end_epoch: 3\n iteration: 10\n frequency: 1\n optimizer:\n SGD:\n ... |
def quad_double_pole_step(vrblvl=0):
if (vrblvl > 0):
print('in quad_double_pole_step ...')
phc = get_phcfun()
apar = pointer(c_int32(2))
bvrb = pointer(c_int32(0))
cstep = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> quad_double_pole_step calls phc... |
_arg_scope
def bias_add(inputs, activation_fn=None, initializer=init_ops.zeros_initializer(), regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, data_format=DATA_FORMAT_NHWC, scope=None):
if (data_format not in (DATA_FORMAT_NCHW, DATA_FORMAT_NHWC)):
raise Val... |
def checkin_newton_power_series(nbsym, lser, idx):
if (idx == 0):
okay = (nbsym == len(lser))
else:
okay = (nbsym == (len(lser) + 1))
if (not okay):
if (idx == 0):
dim = nbsym
else:
dim = (nbsym - 1)
print('Wrong length of list of leading terms... |
class Normalize(BaseWaveformTransform):
supports_multichannel = True
def __init__(self, apply_to: str='all', p: float=0.5):
super().__init__(p)
assert (apply_to in ('all', 'only_too_loud_sounds'))
self.apply_to = apply_to
def randomize_parameters(self, samples: NDArray[np.float32], s... |
def adjust_range(in_min, in_max, device, non_zero):
if (device in [DeviceType.HEXAGON.value, DeviceType.HTA.value]):
return adjust_range_for_hexagon(in_min, in_max)
out_max = max(0.0, in_max)
out_min = min(0.0, in_min)
if non_zero:
out_min = min(out_min, (in_min - ((out_max - in_min) / 2... |
.parametrize('ds_split', [0.2, 0.3, [train_test_split(np.arange(20), test_size=0.4, shuffle=True)], ShuffleSplit(n_splits=1)])
.skip('Deslib is not compatible with new python. Waiting for PR.')
def test_ds_split_parameter(ds_split: Any, df_iris: pd.DataFrame) -> None:
df_iris = df_iris[df_iris['species'].isin(['ver... |
class DecoderBlock(nn.Module):
def __init__(self, in_channels, n_filters):
super(DecoderBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, (in_channels // 4), 1)
self.norm1 = nn.BatchNorm2d((in_channels // 4))
self.relu1 = nonlinearity
self.deconv2 = nn.ConvTranspose... |
def load_tf_weights_in_tapas(*args, **kwargs):
requires_backends(load_tf_weights_in_tapas, ['torch']) |
def num_frames(length, fsize, fshift):
pad = (fsize - fshift)
if ((length % fshift) == 0):
M = ((((length + (pad * 2)) - fsize) // fshift) + 1)
else:
M = ((((length + (pad * 2)) - fsize) // fshift) + 2)
return M |
_SEG_HEADS_REGISTRY.register()
class MaskFormerHead(nn.Module):
_version = 2
def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
version = local_metadata.get('version', None)
if ((version is None) or (version < 2)):
... |
def construct_function_from_graph_def(func, graph_def, frozen_func=None):
if (frozen_func is None):
frozen_func = func
for f in graph_def.library.function:
while context.context().has_function(f.signature.name):
context.context().remove_function(f.signature.name)
captures = {c[1]... |
def generate_forecaster(args):
input_feature_num = (321 if (args.dataset == 'tsinghua_electricity') else 1)
output_feature_num = (321 if (args.dataset == 'tsinghua_electricity') else 1)
metrics = args.metrics
freq = ('h' if (args.dataset == 'tsinghua_electricity') else 't')
if (args.model == 'lstm')... |
def get_elem_value(elem, name):
for child in elem:
if (child.attrib.get('name') != name):
continue
if (child.tag == 'string'):
return child.attrib.get('value')
if (child.tag == 'boolean'):
return (child.attrib.get('value') == 'true')
if (child.tag ... |
def get_num_layer_stage_wise(var_name, num_max_layer):
if (var_name in ('backbone.cls_token', 'backbone.mask_token', 'backbone.pos_embed')):
return 0
elif var_name.startswith('backbone.downsample_layers'):
return 0
elif var_name.startswith('backbone.stages'):
stage_id = int(var_name.... |
def resnet50_fc512_efdmix123_a0d1(num_classes, loss='softmax', pretrained=True, **kwargs):
model = ResNet(num_classes=num_classes, loss=loss, block=Bottleneck, layers=[3, 4, 6, 3], last_stride=1, fc_dims=[512], dropout_p=None, efdmix_layers=['layer1', 'layer2', 'layer3'], efdmix_alpha=0.1, **kwargs)
if pretrain... |
class AgentNetworkException(AgentClientException):
def __init__(self, detail: Union[(str, None)]=None) -> None:
super().__init__('agent_network', detail) |
def test_write_mnist(orca_context_fixture, use_api=False):
sc = orca_context_fixture
temp_dir = tempfile.mkdtemp()
try:
train_image_file = os.path.join(temp_dir, 'train-images')
train_label_file = os.path.join(temp_dir, 'train-labels')
output_path = os.path.join(temp_dir, 'output_dat... |
def proc_time_emb(hist_t, cur_t):
hist_t = [((cur_t - i) + 1) for i in hist_t]
hist_t = [np.sum((i >= gap)) for i in hist_t]
return hist_t |
def insert_topics(conn, topics):
sql = 'insert into topics values(null,%s,0)'
cur = conn.cursor()
cur.executemany(sql, topics)
cur.close()
conn.commit() |
def add_chain_recipe_opts(args):
_add_simple_arg(args, 'stage', 0, int)
_add_simple_arg(args, 'train-stage', 0, int)
_add_simple_arg(args, 'decode_nj', 30, int)
_add_simple_arg(args, 'train-set', 'train_clean_5', str)
_add_simple_arg(args, 'test-sets', 'dev_clean_2', str)
_add_simple_arg(args, '... |
def create_voxel_off(path):
voxel_path = (path + '/voxelization_{}.npy'.format(res))
off_path = (path + '/voxelization_{}.off'.format(res))
if unpackbits:
occ = np.unpackbits(np.load(voxel_path))
voxels = np.reshape(occ, ((res,) * 3))
else:
voxels = np.reshape(np.load(voxel_path)... |
def associated_legendre_polynomials(k, zero_m_only=True):
z = sym.symbols('z')
P_l_m = [([0] * (j + 1)) for j in range(k)]
P_l_m[0][0] = 1
if (k > 0):
P_l_m[1][0] = z
for j in range(2, k):
P_l_m[j][0] = sym.simplify(((((((2 * j) - 1) * z) * P_l_m[(j - 1)][0]) - ((j - 1) * P_l... |
def train_AdaRNN(args, model, optimizer, train_loader_list, epoch, dist_old=None, weight_mat=None):
model.train()
criterion = nn.MSELoss()
criterion_1 = nn.L1Loss()
loss_all = []
loss_1_all = []
dist_mat = torch.zeros(args.num_layers, args.len_seq).cuda()
len_loader = np.inf
for loader i... |
.parametrize('klass', (DummyVecEnv, ShmemVecEnv, SubprocVecEnv))
.parametrize('num_envs', (1, 4))
.parametrize('video_length', (10, 100))
.parametrize('video_interval', (1, 50))
def test_video_recorder(klass, num_envs, video_length, video_interval):
def make_fn():
env = gym.make('PongNoFrameskip-v4')
... |
class DataManager(object):
def __init__(self, dataset_name, shuffle, seed, init_cls, increment, args=None):
self.args = args
self.dataset_name = dataset_name
self._setup_data(dataset_name, shuffle, seed)
assert (init_cls <= len(self._class_order)), 'No enough classes.'
self._... |
def build_vis_if_needed():
script_path = os.path.dirname(os.path.abspath(__file__))
js_bundle_dest = os.path.join(script_path, 'interpret', 'root', 'bld', 'lib', 'interpret-inline.js')
if os.path.exists(js_bundle_dest):
return
js_path = os.path.join(script_path, '..', '..', 'shared', 'vis')
... |
def predFlowCoarse(corrKernel21, NetFlowCoarse, grid, up8X=True):
flowCoarse = NetFlowCoarse(corrKernel21, up8X)
(b, _, w, h) = flowCoarse.size()
flowGrad = (flowCoarse.narrow(2, 1, (w - 1)).narrow(3, 1, (h - 1)) - flowCoarse.narrow(2, 0, (w - 1)).narrow(3, 0, (h - 1)))
flowGrad = torch.norm(flowGrad, d... |
def load_model_for_inference(weights_path: str, quantization: Optional[int]=None, lora_weights_name_or_path: Optional[str]=None, torch_dtype: Optional[str]=None, force_auto_device_map: bool=False, trust_remote_code: bool=False) -> Tuple[(PreTrainedModel, PreTrainedTokenizerBase)]:
if (type(quantization) == str):
... |
class Visualizer():
def __init__(self, opt):
self.display_id = opt.display_id
self.use_html = (opt.is_train and (not opt.no_html))
self.win_size = opt.display_winsize
self.name = opt.exp_name
self.log_path = os.path.join(opt.expr_dir, 'train_log.txt')
if (self.display... |
def forward_model(s, parallelization, ncores=None):
params = {}
model = dd.Model(params)
if parallelization:
simul_obs = model.run(s, parallelization, ncores)
else:
simul_obs = model.run(s, parallelization)
return simul_obs |
class GANImageBuffer():
def __init__(self, buffer_size, buffer_ratio=0.5):
self.buffer_size = buffer_size
if (self.buffer_size > 0):
self.img_num = 0
self.image_buffer = []
self.buffer_ratio = buffer_ratio
def query(self, images):
if (self.buffer_size == 0... |
def connect_addon(name: str='zpy_addon', addon_dir: Union[(Path, str)]='$BLENDERADDONS') -> None:
log.debug(f'Connecting Addon {name}.')
path = f'$BLENDERADDONS/{name}/__init__.py'
path = zpy.files.verify_path(path, make=False)
bpy.ops.preferences.addon_install(filepath=str(path))
bpy.ops.preference... |
def is_pt_flax_cross_test(test_case):
if ((not _run_pt_flax_cross_tests) or (not is_torch_available()) or (not is_flax_available())):
return unittest.skip('test is PT+FLAX test')(test_case)
else:
try:
import pytest
except ImportError:
return test_case
else... |
def register_algo(name):
def decorator(algo_func):
algos_mapping[name] = algo_func
return algo_func
return decorator |
class TestDARN(RWSLayerTest, unittest.TestCase):
def setUp(self):
self.n_samples = 10
self.layer = DARN(n_X=16, n_Y=8)
self.layer.setup() |
def filter_backends(backends, filters=None, **kwargs):
def _match_all(obj, criteria):
return all(((getattr(obj, key_, None) == value_) for (key_, value_) in criteria.items()))
configuration_filters = {}
status_filters = {}
for (key, value) in kwargs.items():
if all(((key in backend.confi... |
class TargetPassThroughTransformer(PassThroughTransformer):
def __init__(self):
super().__init__()
def transform(self, X: Optional[DataLike]=None, y: Optional[DataLike]=None) -> Optional[DataLike]:
return y
def fit_transform(self, X: Optional[DataLike]=None, y: Optional[DataLike]=None) -> Op... |
class ConfigFromDict(object):
def __init__(self, attr_dict):
for (k, v) in attr_dict.items():
setattr(self, k, v) |
class TrainEvaluator(AbstractEvaluator):
def __init__(self, backend: Backend, queue: multiprocessing.Queue, metric: Scorer, port: Optional[int], configuration: Optional[Union[(int, Configuration)]]=None, scoring_functions: Optional[List[Scorer]]=None, seed: int=1, output_y_hat_optimization: bool=True, resampling_st... |
def PreResNetWrapper(num_blocks, num_class=10, block=None, attention_module=None):
b = (lambda in_planes, planes, stride: block(in_planes, planes, stride, attention_module=attention_module))
return PreResNet(b, num_blocks, num_class=num_class) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.