code stringlengths 101 5.91M |
|---|
def run(src_region, dest_region, n_files=1, file_size_mb=1, multipart=False):
logger.info((((((f'Running skyplane cp integration test with config ' + f'src_region={src_region}, ') + f'dest_region={dest_region}, ') + f'n_files={n_files}, ') + f'file_size_mb={file_size_mb}, ') + f'multipart={multipart}'))
(src_bu... |
class ModelArguments():
model_name_or_path: Optional[str] = field(default=None, metadata={'help': 'The model checkpoint for weights initialization. Leave None if you want to train a model from scratch.'})
model_type: Optional[str] = field(default=None, metadata={'help': ('If training from scratch, pass a model ... |
def normalize_space(format_sql):
format_sql_1 = [' '.join(sub_sql.strip().replace(',', ' , ').replace('(', ' ( ').replace(')', ' ) ').split()) for sub_sql in format_sql.split('\n')]
format_sql_1 = '\n'.join(format_sql_1)
format_sql_2 = format_sql_1.replace('\njoin', ' join').replace(',\n', ', ').replace(' w... |
_module()
class AOTEncoder(nn.Module):
def __init__(self, in_channels=4, mid_channels=64, out_channels=256, act_cfg=dict(type='ReLU')):
super().__init__()
self.encoder = nn.Sequential(nn.ReflectionPad2d(3), ConvModule(in_channels, mid_channels, kernel_size=7, stride=1, act_cfg=act_cfg), ConvModule(m... |
class LoaderConfig():
schema_or_location: (str | dict[(str, Any)])
app: Any
base_url: (str | None)
validate_schema: bool
skip_deprecated_operations: bool
data_generation_methods: tuple[(DataGenerationMethod, ...)]
force_schema_version: (str | None)
request_tls_verify: (bool | str)
re... |
def get_model_gradient_multipliers(last_layers, last_layer_gradient_multiplier):
gradient_multipliers = {}
for var in slim.get_model_variables():
if ('biases' in var.op.name):
gradient_multipliers[var.op.name] = 2.0
for layer in last_layers:
if ((layer in var.op.name) and... |
def _get_parts_meta():
stuff_ids = [k['id'] for k in PASCAL_PARTS_CATEGORIES]
stuff_dataset_id_to_contiguous_id = {k: i for (i, k) in enumerate(stuff_ids)}
stuff_classes = [k['name'] for k in PASCAL_PARTS_CATEGORIES]
ret = {'stuff_dataset_id_to_contiguous_id': stuff_dataset_id_to_contiguous_id, 'stuff_c... |
def compute_accuracy(anomalies, real_events):
correct = 0
for anomaly in anomalies:
if (anomaly in real_events):
correct = (correct + 1)
return (correct / len(real_events)) |
class SIE_literal(SageInputExpression):
def _sie_is_simple(self):
return (not self._sie_share) |
class TestUtil(unittest.TestCase):
def test_clean_via_pos(self):
self.assertEqual(['newly-elect', 'leader', 'wife'], clean_via_pos(['the', 'newly-elect', 'leader', "'s", 'wife'], ['DT', 'JJ', 'NN', 'POS', 'NN'])) |
class CodeObjectNode(ExprNode):
subexprs = ['varnames']
is_temp = False
result_code = None
def __init__(self, def_node):
ExprNode.__init__(self, def_node.pos, def_node=def_node)
args = list(def_node.args)
local_vars = [arg for arg in def_node.local_scope.var_entries if arg.name]
... |
def test_worker(from_idx, to_idx, params):
params = params
succ = set()
fail = set()
for idx in range(from_idx, to_idx):
try:
succ.add(idx)
except ValueError:
fail.add(idx)
return (succ, fail) |
class SAM(torch.optim.Optimizer):
def __init__(self, params, base_optimizer, rho=0.05, **kwargs):
assert (rho >= 0.0), f'Invalid rho, should be non-negative: {rho}'
defaults = dict(rho=rho, **kwargs)
super(SAM, self).__init__(params, defaults)
self.base_optimizer = base_optimizer(sel... |
def simplify_replacements(replacements):
if (len(replacements) <= 1):
return replacements
replacements.sort(key=(lambda x: len(x[0])))
idx = 0
while (idx < len(replacements)):
(old, new) = replacements[idx]
j = (idx + 1)
while (j < len(replacements)):
(old_2, ... |
_context(allow_default=True)
class Node(object):
def __init__(self, node='local', **kwargs):
self._name = str(node)
self._kwargs = kwargs
Cluster.current().add_node(self)
def __str__(self):
return self._name
def __repr__(self):
return 'Node(name={}, kwargs={})'.format... |
def valid_YYYYMMDD(inval):
if re.search('(19[5-9]|20[0-4])\\d(0\\d|1[0-2])([0-2]\\d|3[01])', inval):
return True
else:
return False |
class Predict(Subcommand):
def __init__(self, predictor_overrides: Dict[(str, str)]={}) -> None:
self.predictors = {**DEFAULT_PREDICTORS, **predictor_overrides}
def add_subparser(self, name: str, parser: argparse._SubParsersAction) -> argparse.ArgumentParser:
description = 'Run the specified mod... |
def test_get_output_auto_wrap_false():
est = EstimatorWithSetOutputNoAutoWrap()
assert (not hasattr(est, 'set_output'))
X = np.asarray([[1, 0, 3], [0, 0, 1]])
assert (X is est.transform(X)) |
class SchNet(torch.nn.Module):
def __init__(self, hidden_channels=128, num_filters=128, num_interactions=6, num_gaussians=50, cutoff=10.0, readout='add', dipole=False, mean=None, std=None, atomref=None):
super(SchNet, self).__init__()
assert (readout in ['add', 'sum', 'mean'])
self.hidden_ch... |
def _test_loader_from_config(cfg, dataset_name, mapper=None):
dataset = get_detection_dataset_dicts([dataset_name], filter_empty=False, proposal_files=([cfg.DATASETS.PROPOSAL_FILES_TEST[list(cfg.DATASETS.TEST).index(dataset_name)]] if cfg.MODEL.LOAD_PROPOSALS else None))
if (mapper is None):
mapper = Da... |
def line_search(model, f, x, fullstep, expected_improve_full, max_backtracks=10, accept_ratio=0.1):
fval = f(True).data
for stepfrac in [(0.5 ** x) for x in range(max_backtracks)]:
x_new = (x + (stepfrac * fullstep))
set_flat_params_to(model, x_new)
fval_new = f(True).data
actual... |
def get_models(module, include_pretrained=False):
models = []
model_classes = (transformers.PreTrainedModel, transformers.TFPreTrainedModel, transformers.FlaxPreTrainedModel)
for attr_name in dir(module):
if ((not include_pretrained) and (('Pretrained' in attr_name) or ('PreTrained' in attr_name))):... |
class SegformerOnnxConfig(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... |
.parametrize('path,name', demos)
def test_demos(path, name):
ret = subprocess.run([sys.executable, name], cwd=str(path), check=True)
assert (ret.returncode == 0) |
def is_valid(node, check_ids=True, check_prob_sum=False, light=False):
if check_ids:
(val, err) = has_valid_ids(node)
if (not val):
return (val, err)
for n in get_nodes_by_type(node):
if (len(n.scope) == 0):
return (False, ('node %s has no scope' % n.id))
... |
def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False):
names = os.listdir(src)
if (ignore is not None):
ignored_names = ignore(src, names)
else:
ignored_names = set()
os.makedirs(dst)
errors = []
for name in names:
if (na... |
class MypyManager(TCManager):
def _build_tc_cmd(self, fpath):
return ['mypy', '--show-error-codes', '--no-incremental', '--cache-dir=/dev/null', fpath]
def _check_tc_outcome(self, _, outlines):
if any((l.endswith(err) for l in outlines for err in self._inc_errcodes)):
raise FailToTyp... |
def tf32_on_and_off(tf32_precision=1e-05):
def with_tf32_disabled(self, function_call):
with tf32_off():
function_call()
def with_tf32_enabled(self, function_call):
with tf32_on(self, tf32_precision):
function_call()
def wrapper(f):
params = inspect.signature(... |
def scalar_imp_level2_train(listener=False):
data = [('blue', (240.0, 100.0, 100.0)), ('blue', (170.0, 100.0, 70.0)), ('green', (170.0, 100.0, 70.0)), ('green', (80.0, 100.0, 100.0)), ('yellow', (80.0, 100.0, 100.0))]
return pairs_to_insts(data, listener=listener) |
def tfidf_from_questions(names, args, dictionary, dataroot='data', target=['rad']):
inds = [[], []]
df = dict()
N = len(dictionary)
if args.use_RAD:
dataroot = args.RAD_dir
def populate(inds, df, text):
tokens = dictionary.tokenize(text, True)
for t in tokens:
df[... |
class A004526(SloaneSequence):
def __init__(self):
SloaneSequence.__init__(self, offset=0)
def _repr_(self):
return 'The nonnegative integers repeated.'
def _eval(self, n):
return ZZ((n // 2)) |
class FreeAbelianMonoidFactory(UniqueFactory):
def create_key(self, n, names):
n = int(n)
names = normalize_names(n, names)
return (n, names)
def create_object(self, version, key):
return FreeAbelianMonoid_class(*key) |
def backup_codes(root_dir, res_dir, backup_list):
if os.path.exists(res_dir):
shutil.rmtree(res_dir)
os.makedirs(res_dir)
for name in backup_list:
shutil.copytree(os.path.join(root_dir, name), os.path.join(res_dir, name))
print('codes backup at {}'.format(os.path.join(res_dir, name))) |
class GradChecker():
def __init__(self, loss, to_check):
self.to_check = to_check
self.loss = loss
self.eps_range = (2.0 ** np.arange((- 3), (- 30), (- 2)).astype(np.float64))
self.result = ([None] * len(to_check))
self.all_fields = get_all_fields()
self.backups = sav... |
def show_all_variables():
total_count = 0
for (idx, op) in enumerate(tf.trainable_variables()):
shape = op.get_shape()
count = np.prod(shape)
print(('[%2d] %s %s = %s' % (idx, op.name, shape, count)))
total_count += int(count)
print(('[Total] variable size: %s' % '{:,}'.forma... |
def flip(prob=0.5):
if (random.random() > prob):
return (lambda x: x)
return (lambda img: img.transpose(Image.FLIP_LEFT_RIGHT)) |
class NLayerDiscriminator(nn.Module):
def __init__(self, input_nc=3, ndf=64, n_layers=3, use_actnorm=False):
super(NLayerDiscriminator, self).__init__()
if (not use_actnorm):
norm_layer = nn.BatchNorm2d
else:
norm_layer = ActNorm
if (type(norm_layer) == functo... |
class ExtPowerDualFreeModule(FiniteRankFreeModule_abstract):
Element = FreeModuleAltForm
def __init__(self, fmodule, degree, name=None, latex_name=None):
from sage.arith.misc import binomial
from sage.typeset.unicode_characters import unicode_bigwedge
self._fmodule = fmodule
self... |
def apply_nan_suppression(updates, print_mode='all'):
new_updates = OrderedDict([])
for (shared_variable, new_expression) in updates.iteritems():
isnan = (T.isnan(new_expression).any() | T.isinf(new_expression).any())
warning_msg = 'Warning: non-finite update suppressed for %s'
if (print... |
class Model():
def __init__(self, inputs, gt, alpha):
self.num_coarse = 1024
self.grid_size = 4
self.num_fine = ((self.grid_size ** 2) * self.num_coarse)
self.features = self.create_encoder(inputs)
(self.coarse, self.fine) = self.create_decoder(self.features)
(self.lo... |
class DenoisingDataset(FairseqDataset):
def __init__(self, dataset, sizes, vocab, mask_idx, mask_whole_words, shuffle, seed, args):
self.dataset = dataset
self.sizes = sizes
self.vocab = vocab
self.shuffle = shuffle
self.seed = seed
self.mask_idx = mask_idx
se... |
.parametrize('flatlist_as_rvec', [False, True])
def test_ListArray_NumpyArray(flatlist_as_rvec):
v2a = ak.contents.listarray.ListArray(ak.index.Index(np.array([4, 100, 1], np.int64)), ak.index.Index(np.array([7, 100, 3, 200], np.int64)), ak.contents.numpyarray.NumpyArray(np.array([6.6, 4.4, 5.5, 7.7, 1.1, 2.2, 3.3,... |
def get_bridge_entities(sample):
cell_with_links = []
for (r_ind, row) in enumerate(sample['table']['data']):
for (c_ind, col) in enumerate(row):
for (e_ind, link) in enumerate(col[1]):
if ((link is not None) and (link in sample['text'])):
bridge_entity = ... |
class ParamsLog(Callback):
def __init__(self, total_params_log: bool=True, trainable_params_log: bool=True, non_trainable_params_log: bool=True):
super().__init__()
self._log_stats = AttributeDict({'total_params_log': total_params_log, 'trainable_params_log': trainable_params_log, 'non_trainable_par... |
class LoadImage():
def __call__(self, results):
if isinstance(results['img'], str):
results['filename'] = results['img']
results['ori_filename'] = results['img']
else:
results['filename'] = None
results['ori_filename'] = None
img = mmcv.imread(... |
def register_pascal_person_part_parsing(root):
root = os.path.join(root, 'pascal-person-part')
meta = _get_pascal_person_part_parsing_meta()
for (name, (image_root, category_gt_root, instance_gt_root, human_gt_root)) in _PREDEFINED_SPLITS.items():
image_root = os.path.join(root, image_root)
... |
def run_conv_selection(module, x):
tag_conv(module, x)
def _dfs_traverse(module):
for submodule in module.children():
if (isinstance(submodule, torch.nn.Conv2d) and hasattr(submodule, 'input')):
selected_conv = select_conv(submodule, submodule.input)
submodule... |
class HighResolutionNet(nn.Module):
def __init__(self, config, **kwargs):
extra = config.MODEL.EXTRA
super(HighResolutionNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = BatchNorm2d(64, momentum=BN_MOMENTUM)
self.c... |
def get_initializer(matrix):
def _initializer(shape, dtype=None, partition_info=None, **kwargs):
return matrix
return _initializer |
class Solver():
def __init__(self, n_tasks):
super().__init__()
self.n_tasks = n_tasks
def get_weighted_loss(self, losses, ray, parameters=None, **kwargs):
pass
def __call__(self, losses, ray, parameters, **kwargs):
return self.get_weighted_loss(losses, ray, parameters, **kwa... |
_task('multimodal_classification')
class MultimodalClassificationTask(BaseTask):
def __init__(self):
super().__init__()
def valid_step(self, model, samples):
results = []
outputs = model.predict(samples)
predictions = outputs['predictions']
targets = outputs['targets']
... |
def get_job_throughputs(jobs, oracle_throughputs, worker_types):
throughputs = {}
for (i, job) in enumerate(jobs):
throughputs[job.job_id] = {}
for worker_type in worker_types:
job_type_key = (job.job_type, job.scale_factor)
throughputs[job.job_id][worker_type] = oracle_t... |
class SustainDownManager():
def __init__(self, start, end):
self.start = start
self.end = end
self.managed_notes = []
self._note_dict = {}
def add_managed_note(self, note: pretty_midi.Note):
self.managed_notes.append(note)
def transposition_notes(self):
for no... |
def evaluate_model(trained_model, data_loader):
net = CrowdCounter()
network.load_net(trained_model, net)
net.cuda()
net.eval()
mae = 0.0
mse = 0.0
for blob in data_loader:
im_data = blob['data']
gt_data = blob['gt_density']
density_map = net(im_data, gt_data)
... |
class StateNameMixin():
def store_state_names(self, variables, cardinality, state_names):
if state_names:
for (key, value) in state_names.items():
if (not isinstance(value, (list, tuple))):
raise ValueError('The state names must be for the form: {variable: lis... |
def load_ply(path):
f = open(path, 'r')
n_pts = 0
n_faces = 0
face_n_corners = 3
pt_props = []
face_props = []
is_binary = False
header_vertex_section = False
header_face_section = False
while True:
line = f.readline().rstrip('\n').rstrip('\r')
if line.startswith(... |
class RoundRobinZipDatasets(FairseqDataset):
def __init__(self, datasets, eval_key=None):
super().__init__()
if isinstance(datasets, dict):
datasets = OrderedDict(datasets)
assert isinstance(datasets, OrderedDict)
assert datasets, "Can't make a RoundRobinZipDatasets out o... |
.operations('create_user', 'get_user', 'update_user')
def test_openapi_links(cli, cli_args, schema_url, hypothesis_max_examples, snapshot_cli):
assert (cli.run(*cli_args, f'--hypothesis-max-examples={(hypothesis_max_examples or 2)}', '--hypothesis-seed=1', '--hypothesis-derandomize', '--hypothesis-deadline=None', '... |
def compute_total_loss(split, params, rng, config):
num_to_get = min(500, loader.get_number_of_batches(split))
total_loss = 0
total_indices = 0
for i in range(num_to_get):
batch = loader.get_batch(split, i)
total_loss += (compute_loss(femr.models.transformer.convert_params(params, jnp.fl... |
class InputExample(object):
def __init__(self, guid, text_a, text_b=None, label=None, logits=None, meta: Optional[Dict]=None, idx=(- 1)):
self.guid = guid
self.text_a = text_a
self.text_b = text_b
self.label = label
self.logits = logits
self.idx = idx
self.met... |
_numpy_output(check_dtype=True)
def test_ufunc_copysign_ff(A: dace.float32[10], B: dace.float32[10]):
return np.copysign(A, B) |
class LRLambda(object):
def constant_lr():
return (lambda step: 1.0)
def constant_lr_with_warmup(num_warmup_steps: int):
assert (num_warmup_steps >= 1)
def lr_lambda(step: int):
if (step < num_warmup_steps):
return (step / num_warmup_steps)
else:
... |
class SWS2013Testset(Dataset):
def __init__(self, split, **kwargs):
assert (split in ['dev', 'eval'])
scoring_root = Path(kwargs['sws2013_scoring_root'])
audio_names = parse_ecf(((scoring_root / f'sws2013_{split}') / 'sws2013.ecf.xml'))
query_names = parse_tlist(((scoring_root / f'sw... |
_criterion('ctc', dataclass=CtcCriterionConfig)
class CtcCriterion(FairseqCriterion):
def __init__(self, cfg: CtcCriterionConfig, task: FairseqTask):
super().__init__(task)
self.blank_idx = (task.target_dictionary.index(task.blank_symbol) if hasattr(task, 'blank_symbol') else 0)
self.pad_idx... |
def test_save_and_load_one_entry():
dense_matrix = np.zeros((4, 6))
dense_matrix[(1, 2)] = 1
_check_save_and_load(dense_matrix) |
(scope='session')
def hdf_file_path(tmpdir_factory):
path = tmpdir_factory.mktemp('hdf_buffer').join('test.hdf')
return str(path) |
_converter_regitstry('DMA_cw_transpose')
def DMA_cw_transpose_converter(context: 'BM1688Context', reg: DMA_cw_transpose_reg):
lane_mask = ((reg.localmem_mask_h32 * (2 ** 32)) + reg.localmem_mask_l32)
(n, c, h, w) = (reg[f'src_{d}size'] for d in 'nchw')
opd0 = dict(address=dma_addr(reg.src_start_addr_h8, reg... |
def example():
write_ebml_header(sys.stdout, 'matroska', 2, 2)
write_infinite_segment_header(sys.stdout)
sys.stdout.write(ebml_element(, (((('' + ebml_element(29604, random_uid())) + ebml_element(31657, 'mkvgen.py test')) + ebml_element(19840, 'mkvgen.py')) + ebml_element(22337, 'mkvgen.py'))))
sys.stdo... |
def _create_data_folder(path, props):
if ('data_folder' in props):
props['name'] = (props['data_folder'] + '_regen')
data_folder = props['name']
else:
data_folder = Path(props['templates']).stem
data_folder += ('_' + datetime.now().strftime('%y%m%d-%H-%M-%S'))
props['data_folder'... |
def dump_hls_lut_node5(f, name, lut, node):
n = lut.get_node_connection_size(node)
s = lut.get_lut_table_size(node)
tbl = 0
for i in range(s):
if lut.get_lut_table(node, i):
tbl += (1 << i)
f.write(('Q(%s,0x%016xLL)\n' % (make_lut_func_name(name, node), tbl))) |
def precak(sim, str_sim, k=None):
act_lists = [np.nonzero(s)[0] for s in str_sim]
pred_lists = np.argsort((- sim), axis=1)
num_cores = min(multiprocessing.cpu_count(), 8)
nq = len(act_lists)
preck = Parallel(n_jobs=num_cores)((delayed(prec)(act_lists[iq], pred_lists[iq], k) for iq in range(nq)))
... |
def wandb_xla_logger(config: WandbConfig):
last_mtime = ((wandb.run and wandb.run.start_time) or time.time())
def log_xla_to_wandb(step: StepInfo):
nonlocal last_mtime
save_xla_dumps_to_wandb(last_mtime)
last_mtime = time.time()
if config.save_xla_dumps:
return log_xla_to_wan... |
_function_dispatch(_unary_op_dispatcher)
def isdecimal(a):
if (_use_unicode(a) != unicode_):
raise TypeError('isnumeric is only available for Unicode strings and arrays')
return _vec_string(a, bool_, 'isdecimal') |
def get_parser():
parser = argparse.ArgumentParser(description='DualHead-Net')
parser.add_argument('--work-dir', type=str, required=True, help='the work folder for storing results')
parser.add_argument('--model_saved_name', default='')
parser.add_argument('--config', default='./config/ntu-xview/test_bon... |
def test_bogus_string():
assert_raises(ValueError, np.longdouble, 'spam')
assert_raises(ValueError, np.longdouble, '1.0 flub') |
class FetchAndRestoreError(PythonCodeExecutor):
def __init__(self):
self.sizeof_PyObjectPtr = gdb.lookup_type('PyObject').pointer().sizeof
self.pointer = self.malloc((self.sizeof_PyObjectPtr * 3))
type = self.pointer
value = (self.pointer + self.sizeof_PyObjectPtr)
traceback ... |
def common_backend(backends: Collection[Backend]) -> Backend:
if (len(backends) == 1):
return next(iter(backends))
else:
for backend in backends:
if (not backend.nplike.known_data):
return backend
if (len(backends) > 1):
raise ValueError('cannot op... |
class SERes2NetBlock(nn.Module):
def __init__(self, in_channels, out_channels, res2net_scale=8, se_channels=128, kernel_size=1, dilation=1, activation=torch.nn.ReLU, groups=1):
super().__init__()
self.out_channels = out_channels
self.tdnn1 = TDNNBlock(in_channels, out_channels, kernel_size=1... |
def get_pip_packages(run_lambda):
def run_with_pip(pip):
if (get_platform() == 'win32'):
grep_cmd = 'findstr /R "numpy torch"'
else:
grep_cmd = 'grep "torch\\|numpy"'
return run_and_read_all(run_lambda, ((pip + ' list --format=legacy | ') + grep_cmd))
if (not PY3)... |
.unbox(EmptyType)
def EmptyType_unbox(typ, obj, c):
out = numba.core.cgutils.create_struct_proxy(typ)(c.context, c.builder)
is_error = numba.core.cgutils.is_not_null(c.builder, c.pyapi.err_occurred())
return numba.extending.NativeValue(out._getvalue(), is_error=is_error) |
def GenerateSM80_PlanarComplexTensorOp_16816(manifest, args):
if (not CudaToolkitVersionSatisfies(args.cuda_version, 11, 0)):
return
layouts = [(LayoutType.ColumnMajor, LayoutType.ColumnMajor, LayoutType.ColumnMajor), (LayoutType.ColumnMajor, LayoutType.RowMajor, LayoutType.ColumnMajor), (LayoutType.Row... |
class CNNTransformerSE(TransformerInterface):
def __init__(self, d_model, output_size, output_activation=nn.ReLU, nhead=8, num_layers=8, d_ffn=512, dropout=0.1, activation=nn.LeakyReLU, causal=True, custom_emb_module=None, normalize_before=False):
super().__init__(d_model=d_model, nhead=nhead, num_encoder_l... |
def track_iter_progress(tasks, bar_width=50, **kwargs):
if isinstance(tasks, tuple):
assert (len(tasks) == 2)
assert isinstance(tasks[0], collections_abc.Iterable)
assert isinstance(tasks[1], int)
task_num = tasks[1]
tasks = tasks[0]
elif isinstance(tasks, collections_abc... |
def get_emotion_dict(path):
table = pd.read_csv(path)
table = table.to_dict(orient='records')
table = {item['path'].split('/')[(- 2)]: {'valence': item['valence'], 'energy': item['energy'], 'tempo': item['tempo']} for item in table}
return table |
def main(args):
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('mode', choices=['create', 'remove'], help='The mode to use')
parser.add_argument('-l', '--log-level', type=str, default='info', dest='log_level', choices=['debug', 'info', '... |
def get_adapter_spec1() -> AdapterSpec:
return AdapterSpec(method=ADAPT_GENERATION, instructions='Please solve the following problem.\n', max_train_instances=5, max_eval_instances=10, num_outputs=3, num_train_trials=3, model='simple/model1', model_deployment='simple/model1', temperature=1, stop_sequences=['.']) |
_model_architecture('transformer_lm', 'transformer_lm_gpt2_medium')
def transformer_lm_gpt2_medium(args):
args.decoder_embed_dim = safe_getattr(args, 'decoder_embed_dim', 1280)
args.decoder_ffn_embed_dim = safe_getattr(args, 'decoder_ffn_embed_dim', 5120)
args.decoder_layers = safe_getattr(args, 'decoder_la... |
class _Callables(_Constraint):
def is_satisfied_by(self, val):
return callable(val)
def __str__(self):
return 'a callable' |
class ROILoopPool(nn.Module):
def __init__(self, output_size, spatial_scale):
super(ROILoopPool, self).__init__()
self.output_size = output_size
self.spatial_scale = spatial_scale
def forward(self, input, rois):
assert ((rois.dim() == 2) and (rois.size(1) == 5))
return ro... |
def collect_point_data(scene_name):
label_map = scannet_utils.read_label_mapping(opt.label_map_file, label_from='raw_category', label_to='nyu40id')
data_folder = os.path.join(opt.scannet_path, scene_name)
out_filename = os.path.join(data_folder, (scene_name + '_new_semantic.npy'))
seg_filename = os.path... |
def check_structure_test(pretrain_file, args1, args2):
set_random_seed(1000)
other = build_model(pretrain_file, *args1)
other.eval()
set_random_seed(1001)
model = build_model(pretrain_file, *args2)
model.eval()
assert (not torch.allclose(model.delta_embedding.weight, other.delta_embedding.we... |
class KLEJDYKTask(KLEJTask):
def __init__(self):
self._spec = TaskSpecification('DYK', 'classification', 2, 2, 'KLEJ')
self._spec.no_dev_set = True
self._spec.evaluation_metric = self._spec.binary_f1
def normalizer(self) -> TextNormalizer:
return TextNormalizer(detokenize=False)
... |
def create_model(variant, pretrained=False, rng=None, input_shape=None, dtype=jnp.float32, **kwargs):
model_cfg = get_model_cfg(variant)
model_args = model_cfg['arch_fn'](variant, **model_cfg['arch_cfg'])
model_args.update(kwargs)
se_args = model_args.pop('se_cfg', {})
if ('se_layer' not in model_ar... |
class TLPool(CornerPoolPack):
def __init__(self, dim, conv_cfg=None, norm_cfg=None, first_kernel_size=3, kernel_size=3, corner_dim=128):
super(TLPool, self).__init__(dim, CornerPool('top'), CornerPool('left'), conv_cfg, norm_cfg, first_kernel_size, kernel_size, corner_dim) |
class SchemeMorphism_polynomial_projective_space_field(SchemeMorphism_polynomial_projective_space):
def rational_preimages(self, Q, k=1):
k = ZZ(k)
if (k <= 0):
raise ValueError(('k (=%s) must be a positive integer' % k))
from sage.schemes.projective.projective_subscheme import A... |
def test_unknown_1():
text = 'unknown'
parsedtype = ak.types.from_datashape(text, highlevel=False)
assert isinstance(parsedtype, ak.types.UnknownType)
assert (str(parsedtype) == text) |
def setup_logging(default_path=CFG_FILE, default_level=logging.INFO):
path = default_path
if osp.exists(osp.abspath(path)):
with open(path, 'r') as f:
config = yaml.safe_load(f)
logging.config.dictConfig(config)
return __get_collect_logger(config)
else:
lo... |
def bracket_filter(sentence, mode='phonetic'):
new_sentence = str()
if (mode == 'phonetic'):
flag = False
for ch in sentence:
if ((ch == '(') and (flag is False)):
flag = True
continue
if ((ch == '(') and (flag is True)):
fl... |
class MLP(LasagnePowered, Serializable):
def __init__(self, output_dim, hidden_sizes, hidden_nonlinearity, output_nonlinearity, hidden_W_init=LI.GlorotUniform(), hidden_b_init=LI.Constant(0.0), output_W_init=LI.GlorotUniform(), output_b_init=LI.Constant(0.0), name=None, input_var=None, input_layer=None, input_shape... |
def compute_dists(recon_points, gt_points, eval_type='Default'):
recon_kd_tree = KDTree(recon_points)
gt_kd_tree = KDTree(gt_points)
(re2gt_distances, re2gt_vertex_ids) = recon_kd_tree.query(gt_points, workers=4)
(gt2re_distances, gt2re_vertex_ids) = gt_kd_tree.query(recon_points, workers=4)
if (eva... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.