code stringlengths 101 5.91M |
|---|
class ModelBuffer():
def __init__(self, buffer_size):
self.data = None
self.buffer_size = int(buffer_size)
def put(self, batch_data):
batch_data.to_torch(device='cpu')
if (self.data is None):
self.data = batch_data
else:
self.data.cat_(batch_data)
... |
class OutputLogger(Logger):
def __init__(self):
super(OutputLogger, self).__init__()
self.stats['tensor_val'] = None
def forward(self, x):
if (self.stats['tensor_val'] is None):
self.stats['tensor_val'] = x
else:
self.stats['tensor_val'] = torch.cat((self.... |
def test_outer_iterations_max_constrained():
def fg(x):
n = len(x)
c = np.arange(n)
f = (x.dot(x) + c.dot(x))
g = ((2 * x) + c)
return (f, g)
def constraint_f(x):
f = (np.sum(x) - 1)
return f
def constraint_jac_prod(x, y):
g = np.ones_like(x)
... |
def load_datasets(name: str) -> Tuple[(CVDataset, CVDataset, CVDataset)]:
if (name == 'omniglot'):
return (paddlefsl.datasets.Omniglot(mode='train', image_size=(28, 28)), paddlefsl.datasets.Omniglot(mode='valid', image_size=(28, 28)), paddlefsl.datasets.Omniglot(mode='test', image_size=(28, 28)))
if (na... |
def _logmap0(y, c):
sqrt_c = (c ** 0.5)
y_norm = torch.clamp_min(y.norm(dim=(- 1), p=2, keepdim=True), 1e-05)
return (((y / y_norm) / sqrt_c) * artanh((sqrt_c * y_norm))) |
class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
def __init__(self, *args, **kwargs):
kwargs['max_help_position'] = 30
kwargs['indent_increment'] = 1
kwargs['width'] = (get_terminal_size()[0] - 2)
optparse.IndentedHelpFormatter.__init__(self, *args, **kwargs)
def format... |
def test_sym_sym():
tmp = np.zeros((M.get(), N.get()), dtype=np.int64)
A = sym_sym(tmp)
assert (A[0] == (M.get() + N.get())) |
def main(args):
device = torch.device(('cuda' if (torch.cuda.is_available() and (not args.no_cuda)) else 'cpu'))
n_gpu = torch.cuda.device_count()
logger.info('device: {}, n_gpu: {}, 16-bits training: {}'.format(device, n_gpu, args.fp16))
random.seed(args.seed)
np.random.seed(args.seed)
torch.ma... |
def test_issue_334():
a = ak.highlevel.Array([1, 2, 3, 4])
b = ak.highlevel.Array([(- 1)])
c = ak.highlevel.Array([True, False, True, True])
assert (ak.operations.where(c, a, b).to_list() == [1, (- 1), 3, 4])
assert (ak.operations.where(*ak.operations.broadcast_arrays(c, a, b)).to_list() == [1, (- 1... |
class FunctionField_polymod(FunctionField):
Element = FunctionFieldElement_polymod
def __init__(self, polynomial, names, category=None):
from sage.rings.polynomial.polynomial_element import Polynomial
if ((polynomial.parent().ngens() > 1) or (not isinstance(polynomial, Polynomial))):
... |
class PolynomialCameraCal(object):
__slots__ = ['data']
if T.TYPE_CHECKING:
data = []
def __init__(self, focal_length, principal_point, critical_undistorted_radius, distortion_coeffs):
self.data = []
if isinstance(focal_length, numpy.ndarray):
if (focal_length.shape in [(... |
_node_type()
class DiffEpsilon(optplan.Function):
type = schema_utils.polymorphic_model_type('function.diff_epsilon')
epsilon = optplan.ReferenceType(optplan.Function)
epsilon_ref = types.PolyModelType(EpsilonSpec) |
def SymmetricGroupRepresentation(partition, implementation='specht', ring=None, cache_matrices=True):
partition = Partition(partition)
Rep = SymmetricGroupRepresentations(sum(partition), implementation=implementation, ring=ring, cache_matrices=cache_matrices)
return Rep(partition) |
class BiGRU(nn.Module):
def __init__(self, inputdim, outputdim, bidirectional=True, **kwargs):
nn.Module.__init__(self)
self.rnn = nn.GRU(inputdim, outputdim, bidirectional=bidirectional, batch_first=True, **kwargs)
def forward(self, x, hid=None):
(x, hid) = self.rnn(x)
return (x... |
class OperatorsSet(OperatorsSetBase):
def __init__(self, name: str, qc_options: QuantizationConfigOptions=None):
super().__init__(name)
self.qc_options = qc_options
is_fusing_set = (qc_options is None)
self.is_default = ((_current_tp_model.get().default_qco == self.qc_options) or is_... |
def test_asarray_with_order_ignored():
xp = pytest.importorskip('numpy.array_api')
xp_ = _AdjustableNameAPITestWrapper(xp, 'wrapped.array_api')
X = numpy.asarray([[1.2, 3.4, 5.1], [3.4, 5.5, 1.2]], order='C')
X = xp_.asarray(X)
X_new = _asarray_with_order(X, order='F', xp=xp_)
X_new_np = numpy.a... |
def get_image_net_datasets(train_transform, test_transform, train_classes=range(1000), open_set_classes=range(1000), num_open_set_classes=1000, balance_open_set_eval=False, split_train_val=True, seed=0, osr_split='random'):
np.random.seed(seed)
print('No validation split option for ImageNet dataset...')
pri... |
def encode(batch, tokenizer, nlp):
if (nlp is not None):
tokenized_texts = tokenize_with_spacy(batch['text'], nlp)
else:
tokenized_texts = batch
tokenized_texts['offset_mapping'] = [list(zip(range(len(tokens)), range(1, (1 + len(tokens))))) for tokens in tokenized_texts['tokens']]
en... |
def main(args):
cfg = setup(args)
logger.info(f'Used CDPN module name: {cfg.MODEL.CDPN.NAME}')
(model, optimizer) = eval(cfg.MODEL.CDPN.NAME).build_model_optimizer(cfg)
logger.info('Model:\n{}'.format(model))
if args.eval_only:
MyCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(cf... |
def test_kernel_ridge_precomputed():
for kernel in ['linear', 'rbf', 'poly', 'cosine']:
K = pairwise_kernels(X, X, metric=kernel)
pred = KernelRidge(kernel=kernel).fit(X, y).predict(X)
pred2 = KernelRidge(kernel='precomputed').fit(K, y).predict(K)
assert_array_almost_equal(pred, pred... |
def mupad_console():
from sage.repl.rich_output.display_manager import get_display_manager
if (not get_display_manager().is_in_terminal()):
raise RuntimeError('Can use the console only in the terminal. Try %%mupad magics instead.')
os.system('mupkern') |
def forward_step(*, model: Model, extern_data: TensorDict, **_kwargs) -> Tuple[(Tensor, Tensor, Dim, Dim)]:
data = extern_data[extern_data_inputs_name]
batch_dims = data.remaining_dims((data_spatial_dim, data.feature_dim))
(enc_args, enc_spatial_dim) = model.encode(data, in_spatial_dim=data_spatial_dim)
... |
def zero_pad_collator(batch) -> Union[(Dict[(str, torch.Tensor)], Tuple[torch.Tensor])]:
datum = batch[0]
if isinstance(datum, str):
return batch
if isinstance(datum, tuple):
return tuple((collate_tensors([b[i] for b in batch]) for i in range(len(datum))))
keys = datum.keys()
return ... |
def generate_all_entities(facts_arr):
entities = []
for triple in facts_arr:
(subject, object) = (triple[0], triple[2])
if (subject not in entities):
entities.append(subject)
if (object not in entities):
entities.append(object)
return entities |
class Grammar(object):
def __init__(self, rules):
self.rules = rules
self.rule_index = defaultdict(list)
self.rule_to_id = OrderedDict()
node_types = set()
lhs_nodes = set()
rhs_nodes = set()
for rule in self.rules:
self.rule_index[rule.parent].app... |
def test_wrap_index_cupy():
cp = pytest.importorskip('cupy')
data = cp.arange(10, dtype=cp.int64)
index = ak.index.Index64(data)
other_data = cp.asarray(index)
assert cp.shares_memory(data, other_data) |
class PDELU_MobileNet(nn.Module):
cfg = [64, (128, 2), 128, (256, 2), 256, (512, 2), 512, 512, 512, 512, 512, (1024, 2), 1024]
def __init__(self, num_classes=100):
super(PDELU_MobileNet, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False)
self.b... |
class Stack(Progress):
phases = (' ', '', '', '', '', '', '', '', '')
def update(self):
nphases = len(self.phases)
i = min((nphases - 1), int((self.progress * nphases)))
self.write(self.phases[i]) |
class Metrics(object):
def __init__(self):
self.metrics = OrderedDict()
self.cache_dict = OrderedDict()
def register(self, name=None, value=None, formatter=None, display_name=None, write_db=True, write_mail=True):
assert (not (name is None)), 'No name specified'.format(name)
if (... |
def get_opt(model, model_bert, model_type):
if (model_type == 'FT_s2s_1'):
opt = torch.optim.Adam(filter((lambda p: p.requires_grad), model.parameters()), lr=args.lr, weight_decay=0)
opt_bert = torch.optim.Adam(filter((lambda p: p.requires_grad), model_bert.parameters()), lr=args.lr_bert, weight_dec... |
class GroupOps(object):
def identity():
_res = ([0.0] * 8)
_res[0] = 0
_res[1] = 0
_res[2] = 0
_res[3] = 0
_res[4] = 0
_res[5] = 0
_res[6] = 0
_res[7] = 0
return sym.PolynomialCameraCal.from_storage(_res)
def inverse(a):
_a ... |
def scipy_optimise(merge_test_loader, args):
small_k = args.num_labeled_classes
big_k = args.max_classes
test_k_means_partial = partial(test_kmeans_for_scipy, merge_test_loader=merge_test_loader, args=args, verbose=True)
res = minimize_scalar(test_k_means_partial, bounds=(small_k, big_k), method='bounde... |
class Tree(object):
def __init__(self, data, children, meta=None):
self.data = data
self.children = children
self._meta = meta
def meta(self):
if (self._meta is None):
self._meta = Meta()
return self._meta
def __repr__(self):
return ('Tree(%r, %r)'... |
def handle_after_execution(context: ExecutionContext, event: events.AfterExecution) -> None:
context.operations_processed += 1
context.results.append(event.result)
display_execution_result(context, event)
display_percentage(context, event) |
_function_dispatch(_multiply_dispatcher)
def multiply(a, i):
a_arr = numpy.asarray(a)
i_arr = numpy.asarray(i)
if (not issubclass(i_arr.dtype.type, integer)):
raise ValueError('Can only multiply by integers')
out_size = (_get_num_chars(a_arr) * max(long(i_arr.max()), 0))
return _vec_string(a... |
def test(model, dataloader, nshot):
utils.fix_randseed(0)
average_meter = AverageMeter(dataloader.dataset)
for (idx, batch) in enumerate(dataloader):
batch = utils.to_cuda(batch)
pred_mask = model.module.predict_mask_nshot(batch, nshot=nshot)
assert (pred_mask.size() == batch['query_... |
class _HashedSeq(list):
__slots__ = 'hashvalue'
def __init__(self, tup, hash=hash):
self[:] = tup
self.hashvalue = hash(tup)
def __hash__(self):
return self.hashvalue |
def test_EPOCH16breakdown(lib):
epoch16 = (ctypes.c_double * 2)(.0, .0)
yyyy = ctypes.c_long(0)
mm = ctypes.c_long(0)
dd = ctypes.c_long(0)
hh = ctypes.c_long(0)
mn = ctypes.c_long(0)
sec = ctypes.c_long(0)
msec = ctypes.c_long(0)
usec = ctypes.c_long(0)
nsec = ctypes.c_long(0)
... |
class Cached(type):
def __call__(cls, *args, **kwargs):
obj = type.__call__(cls, *args, **kwargs)
obj.register_cache()
return obj |
def create_logger():
loggers = []
names = ['train', 'val', 'test']
for (i, dataset) in enumerate(range(cfg.share.num_splits)):
loggers.append(Logger(name=names[i], task_type=infer_task()))
return loggers |
def _exp_sinch(a, x):
if (abs(x) < 0.0135):
x2 = (x * x)
return (np.exp(a) * (1 + ((x2 / 6.0) * (1 + ((x2 / 20.0) * (1 + (x2 / 42.0)))))))
else:
return ((np.exp((a + x)) - np.exp((a - x))) / (2 * x)) |
def get_test_list(run_only: Optional[List[str]]) -> TestList:
test_list: TestList = []
test_list.extend(get_test_list_by_type(run_only, TestType.CPP))
py_run_only = get_python_run_only(run_only)
test_list.extend(get_test_list_by_type(py_run_only, TestType.PY))
if (not test_list):
raise_no_te... |
class Transition(nn.Module):
def __init__(self, in_planes, out_planes):
super(Transition, self).__init__()
self.bn = nn.BatchNorm2d(in_planes)
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)
def forward(self, x):
out = self.conv(F.relu(self.bn(x)))
... |
class SegmentationPsa(nn.Module):
def __init__(self, config, num_classes, in_channel=4096, middle_channel=512, scale=8):
super(SegmentationPsa, self).__init__()
self.config = config
self.seg1 = Conv2dbnPR(in_channel, middle_channel, 3, 1, padding=12, dilation=12, bias=True)
self.rpad... |
_utils.test()
def test_snode_clear_gradient():
x = ti.field(float, shape=(), needs_grad=True, needs_dual=True)
y = ti.field(float, shape=(), needs_grad=True, needs_dual=True)
x[None] = 1.0
def compute():
y[None] += (x[None] ** 2)
with ti.ad.Tape(loss=y):
compute()
with ti.ad.FwdM... |
def resolve_dir(env_variable, default='data'):
default_dir = os.path.join(resolve_cache_dir(), default)
dir_path = os.getenv(env_variable, default_dir)
if (not PathManager.exists(dir_path)):
PathManager.mkdirs(dir_path)
return dir_path |
(TEST_WITH_TSAN, 'Fails with TSAN with the following error: starting new threads after multi-threaded fork is not supported. Dying (set die_after_fork=0 to override)')
class TestIndividualWorkerQueue(TestCase):
def setUp(self):
super(TestIndividualWorkerQueue, self).setUp()
self.dataset = TestWorker... |
def format_sftp_path(path):
if path.as_posix().startswith('sftp'):
uid = os.getuid()
path = Path(f'/run/user/{uid}/gvfs/sftp:host={path.as_posix()[6:]}')
return path |
class TestRecurrence():
def check_poly(self, func, param_ranges=[], x_range=[], nn=10, nparam=10, nx=10, rtol=1e-08):
np.random.seed(1234)
dataset = []
for n in np.arange(nn):
params = [(a + ((b - a) * np.random.rand(nparam))) for (a, b) in param_ranges]
params = np.a... |
class EnsembleModelEntropy(ModelTemplate):
def __init__(self, all_models, mode='entropy', num_classes=4, use_softmax=False):
super(ModelTemplate, self).__init__()
self.all_models = all_models
self.max_ent = torch.log(torch.Tensor([num_classes])).item()
self.mode = mode
self.u... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--target', default='', type=str, required=True, help='JSON file path to the target (reference) text')
parser.add_argument('--translation', default='', type=str, required=True, help='JSON file path to the translation text')
parser.add_ar... |
def shard_params_and_opt_state(params, params_spec, mesh, optimizer, init_opt_state=None):
def init_fn(params_):
if (init_opt_state is None):
opt_state_ = optimizer.init(params_)
else:
opt_state_ = init_opt_state
return (opt_state_, params_)
def get_opt_spec(x):
... |
def draw_bootstrap(*arrays, bootstrap_ratio=0.632, min_samples=1):
num_data = arrays[0].shape[0]
assert all(((arr.shape[0] == num_data) for arr in arrays))
if (bootstrap_ratio is None):
num_samples = min_samples
else:
assert (bootstrap_ratio < 1)
num_samples = int((math.log((1 - ... |
_module
class SpMiddleFHD(nn.Module):
def __init__(self, num_input_features=128, norm_cfg=None, name='SpMiddleFHD', **kwargs):
super(SpMiddleFHD, self).__init__()
self.name = name
self.dcn = None
self.zero_init_residual = False
if (norm_cfg is None):
norm_cfg = di... |
.parametrize('task_name', [tn for tn in (all_tasks - julia_tasks)])
def test_describe_x(task_name):
task = get_task(task_name)
labels = task.get_labels_data()
assert isinstance(labels, list)
assert (len(labels) == task.get_observation(num_observation=1).shape[(- 1)]) |
class QuadraticEVPSolver(Solver):
def __init__(self, conf, mtx_m=None, mtx_d=None, mtx_k=None, n_eigs=None, eigenvectors=None, status=None, context=None, **kwargs):
Solver.__init__(self, conf=conf, mtx_m=mtx_m, mtx_d=mtx_d, mtx_k=mtx_k, n_eigs=n_eigs, eigenvectors=eigenvectors, status=status, context=contex... |
def extend_with_decoupled_weight_decay(base_optimizer: Type[tf.keras.optimizers.Optimizer]) -> Type[tf.keras.optimizers.Optimizer]:
class OptimizerWithDecoupledWeightDecay(DecoupledWeightDecayExtension, base_optimizer):
def __init__(self, weight_decay: Union[(FloatTensorLike, Callable)], *args, **kwargs):
... |
class LamaFeatureSelector():
def __init__(self, outcome: str, outcome_type: str, treatment: str, timeout: int, n_threads: int, n_folds: int, verbose: bool, generate_report: bool, report_dir: str, use_algos: List[str]):
self.outcome = outcome
self.outcome_type = outcome_type
self.treatment = ... |
class PrivMLP(MLP):
def __init__(self, num_classes, epsilon: Annotated[(float, ArgInfo(help='DP epsilon parameter', option='-e'))], delta: Annotated[(Union[(Literal['auto'], float)], ArgInfo(help='DP delta parameter (if "auto", sets a proper value based on data size)', option='-d'))]='auto', max_grad_norm: Annotate... |
_toolkit()
class AugustSmartLock(FunctionToolkit):
name_for_human = 'August Smart Lock'
description_for_human = 'Toolkit for controlling and managing August Smart Lock.'
name_for_model = 'AugustSmartLock'
description_for_model = "Used for controlling and managing the August Smart Lock, specifically inst... |
(frozen=True)
class Processor():
metric: 'Metric'
metric_service: MetricService
eval_cache_path: str
adapter_spec: AdapterSpec
def process(self, request_state_set: RequestStateSet) -> List[Stat]:
instance_stats: List[Stat] = []
generation_states = request_state_set.generation_states
... |
def train(args):
np.random.seed(args.seed)
(train_l, train_ul, test) = load_dataset(args.data_dir, valid=args.validation, dataset_seed=args.dataset_seed)
print('N_train_labeled:{}, N_train_unlabeled:{}'.format(train_l.N, train_ul.N))
enc = CNN(n_outputs=args.n_categories, dropout_rate=args.dropout_rate,... |
class Schelling(Model):
def __init__(self, height=20, width=20, density=0.8, minority_pc=0.2, homophily=3, education_boost=0, education_pc=0.2, seed=None):
self.height = height
self.width = width
self.density = density
self.minority_pc = minority_pc
self.homophily = homophily... |
class DCGAN_G_nobn(nn.Module):
def __init__(self, isize, nz, nc, ngf, ngpu, n_extra_layers=0):
super(DCGAN_G_nobn, self).__init__()
self.ngpu = ngpu
assert ((isize % 16) == 0), 'isize has to be a multiple of 16'
(cngf, tisize) = ((ngf // 2), 4)
while (tisize != isize):
... |
class HuggingFaceWav2Vec2(nn.Module):
def __init__(self, source, save_path, output_norm=False, freeze=False, freeze_feature_extractor=False, apply_spec_augment=False, output_all_hiddens=False):
super().__init__()
self.feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(source, cache_dir=sav... |
class AugScoreBase():
def __call__(self, augmenter, X_train, Y_train, X_test, Y_test):
raise NotImplementedError() |
def load_warning(method):
if (_warnings_enabled['YAMLLoadWarning'] is False):
return
import warnings
message = ('calling yaml.%s() without Loader=... is deprecated, as the default Loader is unsafe. Please read for full details.' % method)
warnings.warn(message, YAMLLoadWarning, stacklevel=3) |
def dace_sum(X_in: dace.float32[N], X_out: dace.float32[1]):
dace.reduce((lambda a, b: (a + b)), X_in, X_out, identity=0) |
class FiniteWordPath_square_grid_callable(WordDatatype_callable, FiniteWordPath_square_grid, FiniteWord_class):
pass |
class TestLINGAM(unittest.TestCase):
def setUp(self) -> None:
np.random.seed(0)
sample_size = 1000
columns = ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']
x3 = np.random.uniform(size=sample_size)
x0 = ((3.0 * x3) + np.random.uniform(size=sample_size))
x2 = ((6.0 * x3) + np.ran... |
def compute_metrics_from_files(path_to_reference, path_to_candidate, exclude_qids, perform_checks=True):
qids_to_relevant_documentids = load_reference(path_to_reference)
qids_to_ranked_candidate_documents = load_candidate(path_to_candidate)
if perform_checks:
(allowed, message) = quality_checks_qids... |
class AdMethod():
def __init__(self, arch: Arch, scorer: Scorer, dataset: Dataset):
self.arch = arch
self.scorer = scorer
self.dataset = dataset
def get_trained_arch(self):
raise NotImplementedError
def get_normal_class(self) -> int:
raise NotImplementedError
def ... |
class Scanner(object):
def __init__(self, lexicon, stream, name='', initial_pos=None):
self.trace = 0
self.buffer = u''
self.buf_start_pos = 0
self.next_pos = 0
self.cur_pos = 0
self.cur_line = 1
self.start_pos = 0
self.start_line = 0
self.star... |
_utils.in_tempdir
def test_dory_shadow_extract(location):
copy_dory_catlas()
args = 'dory_k21 dory_k21_r1 shadow_out --contigs-db dory_k21/bcalm.unitigs.db'.split()
print('** running extract_nodes_by_shadow_ratio')
assert (extract_nodes_by_shadow_ratio.main(args) == 0) |
def add_reader_preprocessing_params(parser: argparse.ArgumentParser):
parser.add_argument('--gold_passages_src', type=str, help='File with the original dataset passages (json format). Required for train set')
parser.add_argument('--gold_passages_src_dev', type=str, help='File with the original dataset passages ... |
def request(method, url, **kwargs):
with sessions.Session() as session:
return session.request(method=method, url=url, **kwargs) |
def calc_au(model, test_dataloader, delta=0.01, verbose=False):
data_loop = (tqdm(test_dataloader) if verbose else test_dataloader)
def get_mu(batch):
(encoder_inputs, encoder_masks, labels) = batch
encoder_inputs = encoder_inputs.to(model.device)
encoder_masks = encoder_masks.to(model.d... |
class CaselessPreservingLiteral(CaselessLiteral):
def __init__(self, matchString):
super().__init__(matchString.upper())
self.name = ("'%s'" % matchString)
self.errmsg = ('Expected ' + self.name)
self.myException.msg = self.errmsg
def parseImpl(self, instring, loc, doActions=True... |
def get_pai_explain_cmd(datasource, project, oss_model_path, model_name, data_table, result_table, model_type, model_params, job_file, params_file, label_name):
if (model_type == EstimatorType.PAIML):
cmd = get_explain_random_forests_cmd(datasource, model_name, data_table, result_table, label_name)
else... |
('openfl.federated.Plan.parse')
def test_aggregator_start(mock_parse):
current_path = Path(__file__).resolve()
plan_path = current_path.parent.joinpath('plan')
plan_config = plan_path.joinpath('plan.yaml')
cols_config = plan_path.joinpath('cols.yaml')
mock_parse.return_value = mock.Mock()
ret = ... |
class Functional(ModelLayer):
def __init__(self, model, input_record, output_names_or_num, function, name='functional', output_dtypes=None, tags=None, **kwargs):
input_record = schema.as_record(input_record)
super(Functional, self).__init__(model, name, input_record, tags=tags, **kwargs)
sel... |
class DiscreteDecisionTransformerImpl(TransformerAlgoImplBase):
_modules: DiscreteDecisionTransformerModules
_clip_grad_norm: float
_warmup_tokens: int
_final_tokens: int
_initial_learning_rate: float
_tokens: int
def __init__(self, observation_shape: Shape, action_size: int, modules: Discre... |
def regroup_reds_dataset(train_path, val_path):
val_folders = glob.glob(os.path.join(val_path, '*'))
for folder in val_folders:
new_folder_idx = (int(folder.split('/')[(- 1)]) + 240)
os.system(f'cp -r {folder} {os.path.join(train_path, str(new_folder_idx))}') |
def register_Ns3Dot11sPeerManagementProtocol_methods(root_module, cls):
cls.add_constructor([])
cls.add_method('AssignStreams', 'int64_t', [param('int64_t', 'stream')])
cls.add_method('ConfigurationMismatch', 'void', [param('uint32_t', 'interface'), param('ns3::Mac48Address', 'peerAddress')])
cls.add_me... |
def main():
project_root = Path(__file__).parent.parent
nerf_mvl_root = (((project_root / 'data') / 'nerf_mvl') / 'nerf_mvl_7k_pano')
nerf_mvl_parent_dir = nerf_mvl_root.parent
train_split = {'water_safety_barrier': 2, 'tire': 2, 'pier': 2, 'plant': 2, 'warning_sign': 2, 'bollard': 2, 'pedestrian': 3, '... |
def import_dir_files(cdir, pattern='*'):
path = os.path.join(cdir, pattern)
return sorted(glob.glob(path)) |
def test_forward_partitioned_attention(pretrain_file):
model = build_model(pretrain_file, '--pattn_num_heads', '8', '--pattn_num_layers', '8')
run_forward_checks(model)
model = build_model(pretrain_file, '--pattn_num_heads', '0', '--pattn_num_layers', '0')
run_forward_checks(model) |
class UnknownExecutor(ActionExecutor):
def execute(self, script: Script, state: EnvironmentState, info: ExecutionInfo):
raise ExecutionException('Execution of {0} is not supported', script[0].action) |
def _predict(predictors: Dict[(str, str)]):
def predict_inner(args: argparse.Namespace) -> None:
predictor = _get_predictor(args, predictors)
output_file = None
if (args.silent and (not args.output_file)):
print('--silent specified without --output-file.')
print('Exit... |
def send_morphology_request(request):
return send_request(request, MorphologyResponse, MORPHOLOGY_JAVA) |
def batch_predict_with_a_model(data, model, session=None):
data_logits = []
data_labels = []
data_weights = []
step = 1
while ((step * FLAGS.batch_size) <= len(data.fileindices)):
(batch_docnames, batch_docs, batch_label, batch_weight) = data.get_batch(((step - 1) * FLAGS.batch_size), (step ... |
class DiscreteFunctionFieldValuation_base(DiscreteValuation):
def extensions(self, L):
K = self.domain()
from sage.categories.function_fields import FunctionFields
if (L is K):
return [self]
if (L in FunctionFields()):
if K.is_subring(L):
if (L... |
def get_custom_op_library_path():
if sys.platform.startswith('win32'):
library_filename = 'custom_ops.dll'
elif sys.platform.startswith('darwin'):
library_filename = 'libcustom_ops.dylib'
else:
library_filename = 'libcustom_ops.so'
path = os.path.abspath('build/{}'.format(library... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--max_enc_len', default=400, help='Encoder input max sequence length', type=int)
parser.add_argument('--max_dec_len', default=100, help='Decoder input max sequence length', type=int)
parser.add_argument('--max_dec_steps', default=120, h... |
def list_files(files, path):
for item in os.listdir(path):
item = os.path.join(path, item)
if os.path.isdir(item):
list_files(files, item)
elif os.path.isfile(item):
files.append(item) |
def choose_color_by_layertype(layertype):
color = '#6495ED'
if ((layertype == 'Convolution') or (layertype == 'Deconvolution')):
color = '#FF5050'
elif (layertype == 'Pooling'):
color = '#FF9900'
elif (layertype == 'InnerProduct'):
color = '#CC33FF'
return color |
def _recursive_in_check(node, state, gpu_scalars):
scalset = set()
scalout = True
sdfg = state.parent
for e in state.in_edges(node):
last_edge = state.memlet_path(e)[0]
if isinstance(last_edge.src, nodes.AccessNode):
desc = sdfg.arrays[last_edge.src.data]
if isins... |
def broadcast_xla_master_model_param(model):
logger.info('Broadcasting XLA model parameters and buffers from master process ...')
parameters_and_buffers = []
for p in chain(model.parameters(), model.buffers()):
if (not is_main()):
zero = torch.tensor(0, dtype=p.data.dtype, device=p.data.... |
class Metadata(Base):
_attributes = OrderedDict([('schema_version', str), ('title', str), ('creators', str), ('copyright', str), ('collection', str), ('source_filename', str), ('source_format', str)])
_optional_attributes = ['title', 'creators', 'copyright', 'collection', 'source_filename', 'source_format']
... |
class feature_node(Structure):
_names = ['index', 'value']
_types = [c_int, c_double]
_fields_ = genFields(_names, _types)
def __str__(self):
return ('%d:%g' % (self.index, self.value)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.