code stringlengths 101 5.91M |
|---|
class FlowGraph(FlowGraph):
def __init__(self, flow):
self.name = flow.__name__
self.nodes = self._create_nodes(flow)
self.doc = deindent_docstring(flow.__doc__)
self._traverse_graph()
self._postprocess()
def _create_nodes(self, flow):
module = __import__(flow.__m... |
def ref_hard_tanh_backward(x, dy, **kw):
return np.array([(dy if ((- 1) <= i <= 1) else 0) for i in np.nditer(x)]) |
class SymmetryFinder(object):
def __init__(self, loc):
self.loc = loc
def getChildrenNonZero(self, children):
cnt = 0
for c in children:
if (c.nb != 0):
cnt += 1
return cnt
def getSymmetryConstraints(self, node, pid):
if (node.nb == 0):
... |
def _trim_arity(func, maxargs=2):
if (func in singleArgBuiltins):
return (lambda s, l, t: func(t))
limit = [0]
foundArity = [False]
if (system_version[:2] >= (3, 5)):
def extract_stack(limit=0):
offset = ((- 3) if (system_version == (3, 5, 0)) else (- 2))
frame_su... |
class CliReporter(TextReporter):
def __init__(self, executes_verbose, ui):
super(CliReporter, self).__init__()
self._num_runs = None
self.ui = ui
self._runs_completed = 0
self._start_time = None
self._runs_remaining = 0
self._executes_verbose = executes_verbos... |
def mk_dotnet_wrappers(dotnet):
global Type2Str
dotnet.write('\n')
dotnet.write(' public static void Z3_set_error_handler(Z3_context a0, Z3_error_handler a1) {\n')
dotnet.write(' LIB.Z3_set_error_handler(a0, a1);\n')
dotnet.write(' Z3_error_code err = (Z3_error_code)LIB.... |
class Wrapper():
def get_args(parser):
pass
def get_net(args):
return Discriminator().to(args.device)
def get_optimizer(discriminator, args):
return None |
def masked_loss_mse(mask, reg_weight=0, norm_by_mask=True):
return masked_loss(mask, K.square, reg_weight=reg_weight, norm_by_mask=norm_by_mask) |
class TransfoXLTokenizationTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = TransfoXLTokenizer
test_rust_tokenizer = False
test_seq2seq = False
def setUp(self):
super().setUp()
vocab_tokens = ['<unk>', '[CLS]', '[SEP]', 'want', 'unwanted', 'wa', 'un', 'running', ',', 'low... |
def D_adv_loss(pred, real=False, w=None):
w = match_size(w, pred)
if real:
return (w * F.relu((1 - pred))).mean()
else:
return (w * F.relu((1 + pred))).mean() |
def prepare_encoder_decoder_model_kwargs(**kwargs):
kwargs_common = {argument: value for (argument, value) in kwargs.items() if ((not argument.startswith('encoder_')) and (not argument.startswith('decoder_')))}
if ('input_ids' in kwargs_common):
kwargs['encoder_input_ids'] = kwargs_common.pop('input_ids... |
def read_json(fname):
fname = Path(fname)
with fname.open('rt') as handle:
return json.load(handle, object_hook=OrderedDict) |
def test_complicated():
offsets1 = ak.index.Index64(np.array([0, 3, 3, 5], dtype=np.int64))
content1 = ak.contents.ListOffsetArray(offsets1, ak.contents.NumpyArray(np.array(primes[:5], dtype=np.int64)))
offsets2 = ak.index.Index64(np.array([0, 3, 3, 5, 6, 8, 9], dtype=np.int64))
offsets3 = ak.index.Inde... |
def resnext101_32x8d(in_channels=3, pretrained=False, progress=True, **kwargs):
kwargs['groups'] = 32
kwargs['width_per_group'] = 8
return _resnet(in_channels, 'resnext101_32x8d', Bottleneck, [3, 4, 23, 3], pretrained, progress, **kwargs) |
_dispatch
def ihfft(x, n=None, axis=(- 1), norm=None, overwrite_x=False, workers=None, *, plan=None):
return (Dispatchable(x, np.ndarray),) |
def run_experiment_papi_ipc(input_config):
experiments = []
experiments.append(docker_experiment(instances=1, name='inscount_papi', experiment_type='papi', input_config=input_config, additional_cfg={'papi': {'events': ['PAPI_TOT_INS', 'PAPI_LST_INS', 'PAPI_BR_INS'], 'overflow_instruction_granularity': 1000000.0... |
def register_Ns3VhtWifiMacHelper_methods(root_module, cls):
cls.add_constructor([param('ns3::VhtWifiMacHelper const &', 'arg0')])
cls.add_constructor([])
cls.add_method('DataRateForMcs', 'ns3::StringValue', [param('int', 'mcs')], is_static=True)
cls.add_method('Default', 'ns3::VhtWifiMacHelper', [], is_... |
class ValidatedDict(dict):
validate = dict([(key, validator) for (key, (default, validator)) in six.iteritems(default_goptions)])
def __setitem__(self, key, val):
try:
cval = self.validate[key](val)
dict.__setitem__(self, key, cval)
except KeyError:
raise KeyE... |
def evaluate(dataset, predictions, output_folder, **kwargs):
args = dict(dataset=dataset, predictions=predictions, output_folder=output_folder, **kwargs)
if isinstance(dataset, datasets.KittiDataset):
return kitti_evaluation(**args)
else:
dataset_name = dataset.__class__.__name__
rai... |
def is_a_wikilink_or_keyword(item):
if (len(item) == 1):
return 1
else:
return 0 |
def register_Ns3CallbackImplBase_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True)
cls.add_method('IsEqual', 'bool', [param('ns3::Pt... |
def test_normalize_action(as_default, as_jt_full, as_jt_norm, as_jp_full, as_jp_norm):
assert (as_default.normalize_action(upper_100_denormalized_jp_action) == upper_100_normalized_action).all()
assert (as_jp_full.normalize_action(upper_100_denormalized_jp_action) == upper_100_normalized_action).all()
asser... |
def unpackage_configuration(conf):
confStr = conf.to_string()
fileName = conf.build_folder()
print('Unpackaging {}...'.format(confStr))
sourceDir = os.path.join(conf.target, fileName)
targetDir = os.path.join(PROJECT_CONFIG['build_dir'], fileName)
(folders, filesToCopy) = files_to_copy(conf, con... |
class SRWLOptCryst(SRWLOpt):
def __init__(self, _d_sp, _psi0r, _psi0i, _psi_hr, _psi_hi, _psi_hbr, _psi_hbi, _tc, _ang_as, _nvx=0, _nvy=0, _nvz=(- 1), _tvx=1, _tvy=0, _uc=1):
self.dSp = _d_sp
self.psi0r = _psi0r
self.psi0i = _psi0i
self.psiHr = _psi_hr
self.psiHi = _psi_hi
... |
class CrossValidatedTask(BaseTask):
def __init__(self, wrapped_task: BaseTask, num_folds: int=4, seed: int=None):
self.wrapped_task: BaseTask = wrapped_task
self.num_folds = num_folds
self.folds = None
self._spec = wrapped_task.spec()
self.set_fold(0)
self.seed = seed... |
def __getattr__(name):
return _sub_module_deprecation(sub_package='io', module='mmio', private_modules=['_mmio'], all=__all__, attribute=name) |
def test():
empty1 = ak.highlevel.Array(ak.contents.EmptyArray(), check_valid=True)
empty2 = ak.highlevel.Array(ak.contents.ListOffsetArray(ak.index.Index64(np.array([0, 0, 0, 0], dtype=np.int64)), ak.contents.EmptyArray()), check_valid=False)
array = ak.highlevel.Array([[1.1, 2.2, 3.3], [], [4.4, 5.5]], ch... |
.parametrize('action_size', [4])
def test_identity_transformer_action_sampler(action_size: int) -> None:
action_sampler = IdentityTransformerActionSampler()
x = np.random.random(action_size)
action = action_sampler(x)
assert np.all((action == x)) |
def exportable_test_case_with_unexpected_exception(function_mock):
test_case = dtc.DefaultTestCase(ModuleTestCluster(0))
float_stmt = FloatPrimitiveStatement(test_case, 42.23)
function_stmt = FunctionStatement(test_case, function_mock, {'z': float_stmt.ret_val})
function_stmt.add_assertion(ass.Exception... |
class SpectralOpFuzzer(benchmark.Fuzzer):
def __init__(self, *, seed: int, dtype=torch.float64, cuda: bool=False, probability_regular: float=1.0):
super().__init__(parameters=[FuzzedParameter('ndim', distribution={1: 0.3, 2: 0.4, 3: 0.3}, strict=True), [FuzzedParameter(name=f'k_any_{i}', minval=MIN_DIM_SIZE... |
def set_defaults(dict_, defaults):
for (key, val) in six.iteritems(defaults):
dict_.setdefault(key, val) |
def get_word2vec(args, word_counter):
glove_path = os.path.join(args.glove_dir, 'glove.{}.{}d.txt'.format(args.glove_corpus, args.glove_vec_size))
sizes = {'6B': int(400000.0), '42B': int(1900000.0), '840B': int(2200000.0), '2B': int(1200000.0)}
total = sizes[args.glove_corpus]
word2vec_dict = {}
wi... |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
(model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
if (data_args.server_ip and data_args.server_port):
import ptvsd
print('Waiting for debugger attach')
ptvsd.... |
class multiplanetPoincareSystem(rebound.Simulation):
def add(self, *args, **kwargs):
super(multiplanetPoincareSystem, self).add(*args, **kwargs)
self.sim_to_myvars()
def sim_to_myvars(self):
ps = self.particles
Nps = len(ps)
Mjac = np.zeros(Nps)
mujac = np.zeros(N... |
class ReactAgent(BaseAgent):
def __init__(self, llm, context_len=2000):
super().__init__(llm, context_len)
self.type = 'React_Webrun_Agent'
self.name = f'{self.type}_{self.life_label}'
def prompt_layer(self):
one_shot = pre_prompt.oneshot
prompt = f'''{one_shot}{self.obse... |
class Discriminator2D(nn.Module):
def __init__(self, opt=None):
super(Discriminator2D, self).__init__()
self.main = nn.Sequential(nn.Conv3d(6, 64, kernel_size=(1, 4, 4), stride=(1, 2, 2), padding=(0, 2, 2)), nn.LeakyReLU(0.2, inplace=True), nn.Conv3d(64, 128, kernel_size=(1, 4, 4), stride=(1, 2, 2),... |
def create_pipeline_configuration(DEBUG=False, batch_size=32):
config = {'batch_dim': 0, 'depth': 10000, 'basic_blocks': (T5LayerNorm, StatelessEmbedding, Embedding, Dropout, Linear), 'model_inputs': {'attention_mask': {'shape': torch.Size([32, 64]), 'dtype': torch.int64, 'is_batched': True, 'used_by': [0, 8]}, 'de... |
def init_wandb(directory, config):
if (('NO_WANDB' in os.environ) and (os.environ['NO_WANDB'] == 'true')):
log.info('== Working without wandb')
return None
directory_contents = directory.split('/')
run_name = directory_contents[(- 1)]
date = directory_contents[(- 2)]
strat_name = dir... |
class GRUFused(Function):
def forward(ctx, input_gate, hidden_gate, hx, ibias=None, hbias=None):
ctx.backend = type2backend[input_gate.type()]
hy = input_gate.new()
workspace = input_gate.new((hx.numel() * 5))
ctx.has_bias = False
if (ibias is not None):
ctx.has_b... |
class Exemplar1K(Dataset):
def __init__(self, data_root, classes, num_samples, transform):
self.transform = transform
self.sample_filepaths = []
self.train = train
self.train_sample_cls = []
self.test_sample_cls = []
self.train_data = []
self.test_data = []
... |
def test_dde_simple():
def dde_tester(a: dace.float64[20], b: dace.float64[20]):
c = (a + b)
b[:] = a
sdfg = dde_tester.to_sdfg()
Pipeline([DeadDataflowElimination()]).apply_pass(sdfg, {})
sdfg.simplify()
assert (sdfg.number_of_nodes() == 1)
assert all(((n.data != 'c') for n in s... |
def test_pdf_set_poi(backend):
model = pyhf.simplemodels.uncorrelated_background([5.0], [10.0], [2.5])
assert (model.config.poi_index == 0)
assert (model.config.poi_name == 'mu')
model.config.set_poi('uncorr_bkguncrt')
assert (model.config.poi_index == 1)
assert (model.config.poi_name == 'uncorr... |
class CompoundTransformerLayer(TransformerLayer):
def __init__(self, units: int, transformer_list: List[TransformerLayer]):
self.transformer_list = transformer_list
super(CompoundTransformerLayer, self).__init__(units=units)
def transform(self, inputs: tf.Tensor) -> tf.Tensor:
outputs = ... |
def steenrod_basis_error_check(dim, p, **kwds):
from sage.misc.verbose import verbose
generic = kwds.get('generic', (p != 2))
if (not generic):
bases = ('adem', 'woody', 'woodz', 'wall', 'arnona', 'arnonc', 'pst_rlex', 'pst_llex', 'pst_deg', 'pst_revz', 'comm_rlex', 'comm_llex', 'comm_deg', 'comm_re... |
def _imresize_before(img, size, channel_first, interpolate, interpolations_map):
if (not isinstance(img, np.ndarray)):
raise ValueError('the input img for imresize must be numpy.ndarray.')
if (not isinstance(size, (list, tuple))):
raise ValueError('size must be list or tuple')
if (len(img.sh... |
def test_conformer():
import resource
import sys
try:
resource.setrlimit(resource.RLIMIT_STACK, ((2 ** 29), (- 1)))
except Exception as exc:
print(f'resource.setrlimit {type(exc).__name__}: {exc}')
sys.setrecursionlimit((10 ** 6))
time_dim = Dim(Tensor('time', [batch_dim], dtype=... |
def focal_loss_with_logits(output: torch.Tensor, target: torch.Tensor, gamma: float=2.0, alpha: Optional[float]=0.25, reduction: str='mean', normalized: bool=False, reduced_threshold: Optional[float]=None, eps: float=1e-06, ignore_index=None) -> torch.Tensor:
target = target.type_as(output)
p = torch.sigmoid(ou... |
def euclidean_distance_standardized(v1, v2):
v1_v2 = np.vstack([v1, v2])
sk_v1_v2 = np.var(v1_v2, axis=0, ddof=1)
return np.sqrt((((v1 - v2) ** 2) / (sk_v1_v2 + (zero_bit * np.ones_like(sk_v1_v2)))).sum()) |
class DataParallelModel(DataParallel):
def forward(self, inputs, **kwargs):
kwargs = scatter(kwargs, self.device_ids[:len(inputs)], self.dim)
if (len(self.device_ids) == 1):
return (self.module(*inputs[0], **kwargs[0]),)
replicas = self.replicate(self.module, self.device_ids[:len... |
_checkable
class AuthProvider(Generic[Auth], Protocol):
def get(self, case: Case, context: AuthContext) -> (Auth | None):
def set(self, case: Case, data: Auth, context: AuthContext) -> None: |
def eval(args):
bench = benchmark_set.BenchmarkSet(args.benchmark)
bench.set_instance(args.instance)
if (args.kwargs is None):
args.kwargs = sample_random(bench)
ys = bench.objective_function(args.kwargs)
return ys |
class YT8MDialDataset(BaseDataset):
def __init__(self, **kwargs):
super().__init__(kwargs['vis_processor'], kwargs['text_processor'], kwargs['vis_root'], kwargs['ann_paths'])
self.modalities = kwargs['modalities']
for modality in self.modalities:
if ('image' in modality):
... |
class NpWrapper(gym.ObservationWrapper):
def observation(self, observation):
obs = np.array(observation).astype('int')
return obs |
def generate_tgen_config(args, tgen_clients, exit_peers, hs_peers):
abs_conf_path = '{}/{}'.format(args.prefix, CONFIG_DIRNAME)
if (not os.path.exists(abs_conf_path)):
os.makedirs(abs_conf_path)
hosts_prefix = '{}/{}/{}'.format(args.prefix, SHADOW_TEMPLATE_PATH, SHADOW_HOSTS_PATH)
if (not os.pat... |
class FlaxAutoModelForMaskedLM(_BaseAutoModelClass):
_model_mapping = FLAX_MODEL_FOR_MASKED_LM_MAPPING |
_context(matplotlib_settings)
def plot_potential_to_axes(axes: Axes, x_vals: ndarray, potential_vals: Union[(ndarray, List[float])], offset_list: Union[(ndarray, List[float])], **kwargs) -> None:
y_min = np.min(potential_vals)
y_max = np.max(offset_list)
y_range = (y_max - y_min)
y_max += (0.3 * y_range... |
def process_cache(cached_lines):
tokens = []
ner_tags = []
for line in cached_lines:
array = line.split('\t')
if (len(array) < MIN_NUM_FIELD):
array = line.split()
assert ((len(array) >= MIN_NUM_FIELD) and (len(array) <= MAX_NUM_FIELD)), 'Got unexpected line length: {}'.f... |
class LatticePolygon_PPL_class(LatticePolytope_PPL_class):
_method
def ordered_vertices(self):
neighbors = dict()
if (self.affine_dimension() < 2):
return self.vertices()
for c in self.minimized_constraints():
(v1, v2) = self.vertices_saturating(c)
nei... |
def from_pandas_points_labels(df):
require = ['timestamp', 'label']
columns = df.columns.tolist()
if (not all(((x in columns) for x in require))):
raise KeyError('{} not found in columns: {}.'.format(require, columns))
df = df[(df['label'] == 1)]
return from_pandas_points(df) |
def get_features(data_dict):
users = data_dict.get('users', None)
items = data_dict.get('items', None)
timestamp_col = data_dict.get('timestamp_col', None)
ratings_col = data_dict.get('ratings_col', None)
features = [FeatureInfo(column=data_dict['user_col'], feature_hint=FeatureHint.QUERY_ID, featur... |
def getSMTPConnection():
try:
conn = smtplib.SMTP('smtp.gmail.com', 587)
conn.ehlo()
conn.starttls()
conn.ehlo()
conn.login('', 'mypassword')
except:
traceback.print_exc()
raise SMTPConnectionError
return conn |
_utils.test(arch=archs_support_ndarray_ad)
def test_ad_multiple_tapes():
N = 10
def compute_sum(a: ti.types.ndarray(), p: ti.types.ndarray()):
for i in a:
p[None] += ((a[i][0] * 2) + (a[i][1] * 3))
a = ti.ndarray(ti.math.vec2, shape=N, needs_grad=True)
p = ti.ndarray(ti.f32, shape=()... |
def load_usps0():
(X_train, y_train, X_test, y_test) = load_usps()
selected = (y_train == 10)
y_train[selected] = 1
y_train[(~ selected)] = 0
selected = (y_test == 10)
y_test[selected] = 1
y_test[(~ selected)] = 0
return (X_train, y_train, X_test, y_test) |
class Task_Head(nn.Module):
def __init__(self, args, logger):
super(Task_Head, self).__init__()
self.args = args
self.logger = logger
self.cls_embed_layer = nn.Embedding(1, args.model_task_cls_segment_hidden_dim)
if (args.model_task_cls_time_pos_embed_type == 'absolute_learne... |
def get_evaluation_chunk_extra_data_key(evaluation_chunk_id):
return 'evaluation_chunks/{}_data.bytes'.format(evaluation_chunk_id) |
def _swig_setattr_nondynamic_instance_variable(set):
def set_instance_attr(self, name, value):
if (name == 'thisown'):
self.this.own(value)
elif (name == 'this'):
set(self, name, value)
elif (hasattr(self, name) and isinstance(getattr(type(self), name), property)):
... |
def instances2dict(imageFileList, verbose=False, dataset_name=None, rgb2id=None, input_image_size=None, mapillary_dataloading_style='OURS', debug=False):
imgCount = 0
instanceDict = {}
if (not isinstance(imageFileList, list)):
imageFileList = [imageFileList]
if verbose:
print('Processing... |
def generate_proposals(ann_file, tem_results_dir, pgm_proposals_dir, pgm_proposals_thread, **kwargs):
video_infos = load_video_infos(ann_file)
num_videos = len(video_infos)
num_videos_per_thread = (num_videos // pgm_proposals_thread)
processes = []
manager = mp.Manager()
result_dict = manager.di... |
def train_detector(model, dataset, cfg, distributed=False, validate=False, timestamp=None, meta=None):
cfg = compat_cfg(cfg)
logger = get_root_logger(log_level=cfg.log_level)
dataset = (dataset if isinstance(dataset, (list, tuple)) else [dataset])
if ('runner' not in cfg):
raise NotImplementedEr... |
class Node():
balance = 0.5
def __init__(self, state, parent, action):
self.state = state
self.parent = parent
self.action = action
self.depth = 0
if (self.parent != None):
self.depth = (parent.depth + 1)
def getChildren(self):
children = []
... |
class FBTwoHopPathCache(FBCacheBase):
FILENAME = 'TwoHopPath.bin'
def query_two_hop_paths(self, entity):
if (not self.ready):
self.load()
if (entity in self.data):
return self.data[entity]
paths = get_2hop_relations(entity)[2]
paths = self.dataset_specific... |
class FailToTypeCheck(CustomWarning):
def __init__(self):
super().__init__('File containing type errors!') |
.parametrize('cv_result', [(1, True), (2, False), ('split', True), (KFold(5), False), (ShuffleSplit(1), True), (ShuffleSplit(2), False), (LeaveOneOut(), False)])
def test_check_no_agg_cv(cv_result: Tuple) -> None:
array = ['prefit', 'split']
(cv, result) = cv_result
np.testing.assert_almost_equal(check_no_a... |
def pad_to_batch(batch, w_to_ix, s_to_ix):
(history, current, slot, intent) = list(zip(*batch))
max_history = max([len(h) for h in history])
max_len = max([h.size(1) for h in flatten(history)])
max_current = max([c.size(1) for c in current])
max_slot = max([s.size(1) for s in slot])
(historys, c... |
_params({'y_true': ['array-like'], 'y_pred': ['array-like'], 'labels': ['array-like', None], 'pos_label': [str, numbers.Integral, None], 'average': [None, StrOptions({'binary', 'micro', 'macro', 'weighted', 'samples', 'multiclass'})], 'sample_weight': ['array-like', None], 'correction': [Interval(numbers.Real, 0, None,... |
class TransposeType(ExplicitEnum):
NO = 'no'
SIMPLE = 'simple'
CONV1D = 'conv1d'
CONV2D = 'conv2d' |
class ParamNode(LeafNode):
def __init__(self, prod: Production):
if (not prod.is_param()):
raise ValueError('Cannot construct an AST param node from a non-param production')
super().__init__(prod)
def index(self) -> int:
prod = cast(ParamProduction, self._prod)
return... |
class TransformedDataset(Dataset):
def __init__(self, dataset, transform=None, target_transform=None):
self.dataset = dataset
self.transform = transform
self.target_transform = target_transform
def __len__(self):
return len(self.dataset)
def __getitem__(self, index):
... |
class DoubleConv(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.double_conv = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, pa... |
def build_model(data, kernel_func=None):
variance = tf.math.reduce_variance(data.observations)
if (kernel_func is None):
kernel = gpflow.kernels.Matern52(variance=variance)
else:
kernel = kernel_func(variance)
gpr = gpflow.models.GPR(data.astuple(), kernel, noise_variance=1e-05)
gpfl... |
def div(field, variables=None):
variables = default_space_variables(variables)
n_var = len(variables)
field = list(field)
assert (len(field) == n_var)
out = 0
for (f_i, x_i) in zip(field, variables):
out += sp.sympify(f_i).diff(x_i)
return out |
def make_parser():
parser = argparse.ArgumentParser(description=description)
parser.add_argument('--log', dest='log', default=None, help='one of [DEBUG, INFO, ERROR, WARNING, CRITICAL]')
parser.add_argument('--print-fastest-mirror', action='store_true', help='Print out the fastest mirror. All other argument... |
.parametrize('inshape', [(8, 2, 2, 2), (16, 1, 8)])
.parametrize('n_outmaps', [16, 32])
.parametrize('base_axis', [1, 2])
.parametrize('w_init', [None, I.NormalInitializer(), True])
.parametrize('b_init', [None, I.ConstantInitializer(), True])
.parametrize('with_bias', [False, True])
.parametrize('fix_parameters', [Fal... |
def ComputeNumSignBits(bitwidth, v):
size = v.size()
size1 = (size - 1)
sign = z3.Extract(size1, size1, v)
def rec(i):
if (i < 0):
return z3.BitVecVal(size, bitwidth)
return z3.If((z3.Extract(i, i, v) == sign), rec((i - 1)), z3.BitVecVal((size1 - i), bitwidth))
return rec... |
class ConvReLU3d(_FusedModule):
def __init__(self, conv, relu):
assert ((type(conv) == Conv3d) and (type(relu) == ReLU)), 'Incorrect types for input modules{}{}'.format(type(conv), type(relu))
super().__init__(conv, relu) |
def create_model(bert_config, is_training, input_ids, input_mask, input_type_ids, labels, num_labels, use_one_hot_embeddings, tsa, unsup_ratio, global_step, num_train_steps):
num_sample = input_ids.shape[0].value
if is_training:
assert ((num_sample % (1 + (2 * unsup_ratio))) == 0)
sup_batch_size... |
class Predict(Parameter):
def __init__(self, signature, **config):
self.stage = random.randbytes(8).hex()
self.signature = signature
self.config = config
self.reset()
if isinstance(signature, str):
(inputs, outputs) = signature.split('->')
(inputs, out... |
class InfinitePolynomial_dense(InfinitePolynomial):
def __call__(self, *args, **kwargs):
for kw in kwargs:
value = kwargs[kw]
if isinstance(value, InfinitePolynomial):
kwargs[kw] = value._p
args = list(args)
for (i, arg) in enumerate(args):
... |
def compile(source_code):
with compiler_lock:
return ROOT.gInterpreter.Declare(source_code) |
def run_translate(args):
logging.info('Running translator.')
time_limit = limits.get_time_limit(args.translate_time_limit, args.overall_time_limit)
memory_limit = limits.get_memory_limit(args.translate_memory_limit, args.overall_memory_limit)
translate = get_executable(args.build, REL_TRANSLATE_PATH)
... |
def rad_shifted(n, cutoff):
r0 = 0.5
rn = (cutoff - 1.0)
delta = ((rn - r0) / float((n - 1)))
sfs = [{'rad': {'cutoff': cutoff, 'eta': (0.5 / (delta ** 2)), 'mu': (r0 + (i * delta))}} for i in range(n)]
return (sfs, n, 0) |
def test():
array = ak.Array([[0, 1, 2, 3], [8, 9, 10, 11]], backend='typetracer')
other = ak.Array([1, 2], backend='cpu')
result = (array + other)
assert (ak.backend(result) == 'typetracer') |
class ImageDirectoryLoader():
def __init__(self, rootdir, pathspec=os.path.join('{source}', '{image_name}'), format='tiff', standardize=False):
self.rootdir = rootdir
self.pathspec = pathspec
self.format = format
self.standardize = standardize
def get(self, *args, **kwargs):
... |
def _flat_nested_json_dict(json_dict, flatted, sep='.', start=''):
for (k, v) in json_dict.items():
if isinstance(v, dict):
_flat_nested_json_dict(v, flatted, sep, ((start + sep) + str(k)))
else:
flatted[((start + sep) + str(k))] = v |
class ParsimoniousAttack(object):
def __init__(self, model, args, **kwargs):
self.loss_func = args.loss_func
self.max_queries = args.max_queries
self.epsilon = args.epsilon
self.batch_size = args.batch_size
self.block_size = args.block_size
self.no_hier = args.no_hier... |
class PLBartTokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
model_input_names = ['input_ids', 'attention_mask']
prefix_tokens: List[int] = []
suffix_tokens... |
class _UtteranceExtractor(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
self._indim = input_size
self._outdim = output_size
self.linear1 = nn.Linear(input_size, output_size)
self.linear2 = nn.Linear(output_size, output_size)
self.act_fn =... |
def register_Ns3SpectrumSignalParameters_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::SpectrumSignalParameters const &', 'p')])
cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True)
cls.add_instance_attribute('psd', 'ns3::Ptr< ns3... |
def test_is_invertible_module():
X = torch.zeros(1, 10, 10, 10)
assert (not is_invertible_module(torch.nn.Conv2d(10, 10, kernel_size=(1, 1)), test_input_shape=X.shape))
fn = AdditiveCoupling(SubModule(), implementation_bwd=(- 1), implementation_fwd=(- 1))
assert is_invertible_module(fn, test_input_shape... |
class DeltaActionEnvWrapper(gym.ActionWrapper):
def __init__(self, env):
super(DeltaActionEnvWrapper, self).__init__(env)
self.env.add_wrapper_info({'delta_action': dict()})
def action(self, action):
if (self.env.get_action_mode() == 'joint_positions'):
offset = self.env.get_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.