code stringlengths 101 5.91M |
|---|
class LastLevelP6P7(nn.Module):
def __init__(self, in_channels, out_channels):
super(LastLevelP6P7, self).__init__()
self.p6 = nn.Conv2d(in_channels, out_channels, 3, 2, 1)
self.p7 = nn.Conv2d(out_channels, out_channels, 3, 2, 1)
for module in [self.p6, self.p7]:
nn.init.... |
class ResNetForImageClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def build_java_base_graphs():
definitions = pickle.load(open(JAVA_BASE, 'rb'))
if (not os.path.exists(JAVA_BASE_DIR)):
os.makedirs(JAVA_BASE_DIR)
results = parallel_process(definitions, build_single_graph, args=(JAVA_BASE_DIR,))
succeed = 0
for result in results:
if result:
... |
class TestExpmActionInterval():
def test_sparse_expm_multiply_interval(self):
np.random.seed(1234)
start = 0.1
stop = 3.2
n = 40
k = 3
endpoint = True
for num in (14, 13, 2):
A = scipy.sparse.rand(n, n, density=0.05)
B = np.random.randn... |
class CovarGMM():
def __init__(self, mins, maxs, seed=None, params=dict()):
self.seed = seed
if (not seed):
self.seed = np.random.randint(42, 424242)
np.random.seed(self.seed)
self.mins = np.array(mins)
self.maxs = np.array(maxs)
self.potential_ks = (np.ar... |
def register_Ns3MgtProbeResponseHeader_methods(root_module, cls):
cls.add_constructor([param('ns3::MgtProbeResponseHeader const &', 'arg0')])
cls.add_constructor([])
cls.add_method('Deserialize', 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True)
cls.add_method('GetBeaconIntervalUs'... |
class TuneReportHook(EvalHook):
def __init__(self, eval_period, eval_function):
super().__init__(eval_period, eval_function)
self.step = 0
def _do_eval(self):
results = self._func()
if results:
assert isinstance(results, dict), 'Eval function must return a dict. Got {... |
def ensure_same_backend(*layouts: Any, default_backend: (str | Backend)='cpu') -> list[Any]:
backends: set[Backend] = {layout.backend for layout in layouts if hasattr(layout, 'backend')}
backend: Backend
if (len(backends) >= 1):
backend = common_backend(backends)
else:
backend = regulari... |
def get_config():
config = ml_collections.ConfigDict()
config.learning_rate = 0.01
config.momentum = 0.9
config.batch_size = 128
config.num_epochs = 10
config.rounds_to_train = 3
return config |
class LanguageDecoder(nn.Module):
def __init__(self, in_dim, out_dim, **kwargs):
super().__init__()
self.language_lstm = nn.LSTMCell((in_dim + kwargs['hidden_dim']), kwargs['hidden_dim'], bias=True)
self.fc = weight_norm(nn.Linear(kwargs['hidden_dim'], out_dim))
self.dropout = nn.Dro... |
def writeJSONLine(data, path):
with open(path, 'w') as f:
for i in data:
f.write(('%s\n' % json.dumps(i)))
return None |
_utils.test(arch=get_host_arch_list())
def test_offset_must_throw_vector():
with pytest.raises(ti.TaichiCompilationError, match='The dimensionality of shape and offset must be the same'):
a = ti.Vector.field(3, dtype=ti.f32, shape=3, offset=(3, 4))
with pytest.raises(ti.TaichiCompilationError, match='sh... |
def subprocess_fn(rank, args, temp_dir):
dnnlib.util.Logger(should_flush=True)
if (args.num_gpus > 1):
init_file = os.path.abspath(os.path.join(temp_dir, '.torch_distributed_init'))
if (os.name == 'nt'):
init_method = ('file:///' + init_file.replace('\\', '/'))
torch.dist... |
def collect_files(patterns):
files = []
for (root, spec) in patterns:
if spec.endswith('.sbd'):
contracts = []
for sbdfile in glob.glob(spec, recursive=True):
contracts.extend(sb.io.read_lines(sbdfile))
elif root:
try:
contracts... |
_if_32bit
.parametrize('csr_container', CSR_CONTAINERS)
.parametrize('kernel', ['linear', 'poly', 'rbf'])
def test_svc_iris(csr_container, kernel):
iris_data_sp = csr_container(iris.data)
sp_clf = svm.SVC(kernel=kernel).fit(iris_data_sp, iris.target)
clf = svm.SVC(kernel=kernel).fit(iris.data, iris.target)
... |
class SNGAN(nn.Module):
def __init__(self, gen_cfg: DictConfig, disc_cfg: DictConfig, *args, **kwargs):
super().__init__()
self.generator = hydra.utils.instantiate(gen_cfg)
self.discriminator = hydra.utils.instantiate(disc_cfg)
def gen_backward(self, batch_size):
fake_samples = s... |
.integtest
def test_manual_pipeline(sampled_app_train_test, sampled_app_roles, binary_task):
(train, test) = sampled_app_train_test
pd_dataset = PandasDataset(train, roles_parser(sampled_app_roles), task=binary_task)
selector_iterator = FoldsIterator(pd_dataset, 1)
pipe = LGBSimpleFeatures()
model0 ... |
def match_target_hypo(args, target_outfile, hypo_outfile):
if (len(args.weight1) == 1):
res = score_target_hypo(args, args.weight1[0], args.weight2[0], args.weight3[0], args.lenpen[0], target_outfile, hypo_outfile, True, args.normalize)
rerank_scores = [res]
else:
print('launching pool')... |
def sec_to_frame(seconds):
samples = (seconds * global_fs)
frame_idx = (samples // hopSize).astype(int)
return frame_idx |
class Trainer(DefaultTrainer):
def __init__(self, cfg):
super().__init__(cfg)
self.checkpointer = DetectionCheckpointer(self.model, cfg.OUTPUT_DIR, optimizer=self.optimizer, scheduler=self.scheduler)
def build_evaluator(cls, cfg, dataset_name, output_folder=None):
if (output_folder is No... |
def evaluate_em(model, dataset, tokenizer, collator, opt):
sampler = SequentialSampler(dataset)
dataloader = DataLoader(dataset, sampler=sampler, batch_size=opt.per_gpu_batch_size, drop_last=False, num_workers=10, collate_fn=collator)
model.eval()
total = 0
exactmatch = []
model = (model.module ... |
class TestQuantizeFx(QuantizationTestCase):
def _get_conv_linear_test_cases(self):
class Conv(torch.nn.Module):
def __init__(self, weight):
super().__init__()
self.weight = torch.nn.Parameter(weight)
self.stride = (1, 1)
self.paddin... |
class FitSolverError(FitError):
def __init__(self, mesg):
emsg = 'Solver for the MLE equations failed to converge: '
emsg += mesg.replace('\n', '')
self.args = (emsg,) |
.register('mobilenet_v3')
def mobilenet_v3():
model = MobileNetV3()
if cfg.BACKBONE.MV3.SAME_PAD:
model = convert_conv2convsamepadding_model(model)
return model |
class SuzukiSporadicGroup(PermutationGroup_unique):
def __init__(self):
libgap.load_package('atlasrep')
PermutationGroup_generic.__init__(self, gap_group='AtlasGroup("Suz")')
def _repr_(self):
return 'Sporadic Suzuki group acting on 1782 points' |
class BaseOptions():
def __init__(self):
self.initialized = False
def initialize(self, parser):
parser.add_argument('--name', type=str, default='label2coco', help='name of the experiment. It decides where to store samples and models')
parser.add_argument('--gpu_ids', type=str, default='0... |
def build_data(resource, directory='data'):
if resource.filename.endswith('.tar.gz'):
resource_dir = os.path.splitext(os.path.splitext(os.path.basename(resource.filename))[0])[0]
else:
resource_dir = os.path.splitext(os.path.basename(resource.filename))[0]
file_path = os.path.join(directory,... |
(scope='module')
def config():
return Configuration.from_yaml('tardis/io/tests/data/tardis_configv1_verysimple.yml') |
def test_mean_logvar_length_dict():
r = model1_dict.forward(x1_dict.float())
assert (len(r[1][0]) == len(r[2][0])) |
class RegularSuperCrystals(Category_singleton):
def super_categories(self):
return [SuperCrystals().Finite()]
class ElementMethods():
def epsilon(self, i):
string_length = 0
x = self
while True:
x = x.e(i)
if (x is None):
... |
class BiSeNetOutput(nn.Module):
def __init__(self, in_chan, mid_chan, num_class):
super(BiSeNetOutput, self).__init__()
self.conv = ConvBNReLU(in_chan, mid_chan, ks=3, stride=1, padding=1)
self.conv_out = nn.Conv2d(mid_chan, num_class, kernel_size=1, bias=False)
def forward(self, x):
... |
.parametrize('csr_container', CSR_CONTAINERS)
def test_scale_normalize(global_random_seed, csr_container):
generator = np.random.RandomState(global_random_seed)
X = generator.rand(100, 100)
for mat in (X, csr_container(X)):
(scaled, _, _) = _scale_normalize(mat)
_do_scale_test(scaled)
... |
def _set_checking_parameters(estimator):
params = estimator.get_params()
name = estimator.__class__.__name__
if ('n_estimators' in params):
estimator.set_params(n_estimators=min(5, estimator.n_estimators))
if (name == 'ClusterCentroids'):
if (sklearn_version < parse_version('1.1')):
... |
def window(df: pd.DataFrame, size: int, driving_series: List[str], target_series: List[str]):
X = df[driving_series].values
y = df[target_series].values
X_T = []
y_T = []
for i in range(((len(X) - size) + 1)):
X_T.append(X[i:(i + size)])
y_T.append(y[i:(i + size)])
return (np.arr... |
def set_target_os(platform: Optional[str]=None):
global _target_os
if ((platform is None) or (platform in ('linux', 'macosx', 'windows'))):
_target_os = platform
else:
raise OSError(f"Unsupported target OS: '{platform}' - py-solc-x supports 'linux', 'macosx', or 'windows'.") |
def expected_failure_on_sympy(func: T.Callable) -> T.Callable:
if (symforce.get_symbolic_api() == 'sympy'):
return unittest.expectedFailure(func)
else:
return func |
def convert_examples_to_features(examples, label_list, tokenizer, max_seq_length, max_entity_length, max_mention_length):
max_num_subwords = (max_seq_length - 2)
label_map = {label: i for (i, label) in enumerate(label_list)}
features = []
def tokenize_word(text):
if (isinstance(tokenizer, Robert... |
class ClusterGCN(GraphSamplingBase):
def __init__(self, args, data, train_idx, processed_dir):
super(ClusterGCN, self).__init__(args, data, train_idx, processed_dir)
base_gnnconv = (SAGEConvMLP if (args.gnn_type == 'mlp') else SAGEConv)
self.convs = torch.nn.ModuleList()
self.convs.a... |
def get_input_fn(config_params, image_dir, batch_size=None, steps=None):
if (batch_size is None):
raise ValueError('`batch_size` cannot be None')
image_paths = glob(os.path.join(image_dir, '*'))
preprocessing_pipeling = PreprocessingPipeline(config_params.input.input_shape, config_params.dataloader_... |
class TestMEstimateEncoder(TestCase):
def test_reference_m0(self):
x = ['A', 'A', 'B', 'B']
y = [1, 1, 0, 1]
x_t = ['A', 'B', 'C']
encoder = encoders.MEstimateEncoder(m=0, handle_unknown='value', handle_missing='value')
encoder.fit(x, y)
scored = encoder.transform(x_t... |
def create_clustering_layout():
return dbc.Row([dbc.Col([create_description_card(), create_control_card(), html.Div(['initial child'], id='clustering-output-clientside', style={'display': 'none'})], width=2), dbc.Col([dbc.Row([dbc.Col(dbc.Card(dbc.CardBody([html.H4('Summary'), html.Div(id='clustering-summary')])), ... |
def test_cond_twice_shared_params():
time_dim = Dim(Tensor('time', [batch_dim], dtype='int32'))
in_dim = Dim(7, name='in')
out_dim = Dim(13, name='out')
extern_data = TensorDict({'data': Tensor('data', [batch_dim, time_dim, in_dim], dtype='float32')})
class _Net(rf.Module):
def __init__(self... |
def hook_maxpool1d(m, x, y):
flops_per_ele = (m.kernel_size - 1)
flops = (flops_per_ele * y.numel())
return int(flops) |
class Test():
def __init__(self, value: int) -> None:
self._value = value
def test_method(self, x: int) -> int:
return (5 * x) |
.parametrize('std', [False, True])
.parametrize('pro', [False, True])
def test_iff_variables(std, pro):
if (std == pro):
with pytest.raises(ValueError):
_bk = Background(use_std_logic_variables=std, use_prolog_variables=pro)
else:
_bk = Background(use_std_logic_variables=std, use_pro... |
def _validate_gpu():
import torch
if (not torch.cuda.is_available()):
logger.error('Skyline did not detect a GPU on this machine. Skyline only profiles deep learning workloads on GPUs.')
return False
return True |
class BitDownsampleConv(nn.Module):
def __init__(self, config, in_channels, out_channels, stride=1, preact=True):
super().__init__()
self.conv = WeightStandardizedConv2d(in_channels, out_channels, 1, stride=stride, eps=1e-08, padding=config.global_padding)
self.norm = (nn.Identity() if preac... |
def isotropic_opening(image, radius, out=None, spacing=None):
eroded = isotropic_erosion(image, radius, out=out, spacing=spacing)
return isotropic_dilation(eroded, radius, out=out, spacing=spacing) |
class EDGE_ENHANCE_MORE(BuiltinFilter):
name = 'Edge-enhance More'
filterargs = ((3, 3), 1, 0, ((- 1), (- 1), (- 1), (- 1), 9, (- 1), (- 1), (- 1), (- 1))) |
class TransformerWav2VecEncoderLayer(nn.Module):
def __init__(self, embedding_dim: float=768, ffn_embedding_dim: float=3072, num_attention_heads: float=8, dropout: float=0.1, attention_dropout: float=0.1, activation_dropout: float=0.1, activation_fn: str='relu', add_bias_kv: bool=False, add_zero_attn: bool=False, e... |
def test_int_primitive_statement_delta(default_test_case):
config.configuration.test_creation.max_delta = 10
statement = stmt.IntPrimitiveStatement(default_test_case, 1)
with mock.patch('pynguin.utils.randomness.next_gaussian') as gauss_mock:
gauss_mock.return_value = 0.5
statement.delta()
... |
def make_policy():
return DeterministicPolicy(state_shape=STATE_SHAPE, action_shape=ACTION_SHAPE, hidden_units=[256, 256], hidden_activation=nn.ReLU(inplace=True), device=args.device) |
class Adam(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
raise ValueError('Invalid epsilon value: {}'.format... |
def make_and_save_predictions(model, input_path_str, output_path_str):
input_path = Path(input_path_str)
output_path = Path(output_path_str)
input_image_filenames = [(input_path / filename) for filename in os.listdir(input_path)]
for image_filename in tqdm(input_image_filenames):
input_image = i... |
class Mixed_5b(nn.Module):
def __init__(self):
super(Mixed_5b, self).__init__()
self.branch0 = nn.Sequential(BasicConv3d(832, 256, kernel_size=1, stride=1))
self.branch1 = nn.Sequential(BasicConv3d(832, 160, kernel_size=1, stride=1), SepConv3d(160, 320, kernel_size=3, stride=1, padding=1))
... |
def get_params(argv='1'):
print('SET: {}'.format(argv))
params = dict(quick_test=True, finetune_mode=False, pretrained_model_weights='models/1_1_foa_dev_split6_model.h5', dataset_dir='/scratch/asignal/partha/DCASE2023/DCASE2023_SELD_dataset', feat_label_dir='/scratch/asignal/partha/DCASE2023/DCASE2023_SELD_data... |
def np_loader(np_path, l2norm=False):
with open(np_path, 'rb') as f:
data = np.load(f, encoding='latin1', allow_pickle=True)
if (isinstance(data, np.ndarray) and (data.size == 1)):
data = data[()]
if l2norm:
print('L2 normalizing features')
if isinstance(data, dict):
... |
def batch_nested_sequences(seqs_subseqs, max_length=None, max_tokens=None, fixed_length=None, batch_first=True, pad_value=PAD, augment=False, device=None, dtype=torch.long):
(seqs, sub_seqs) = zip(*seqs_subseqs)
(batch_dim, time_dim) = ((0, 1) if batch_first else (1, 0))
if (fixed_length is not None):
... |
class TestSharedExtension(object):
def test_get_shared_lib_extension(self):
import sys
ext = get_shared_lib_extension(is_python_ext=False)
if sys.platform.startswith('linux'):
assert_equal(ext, '.so')
elif sys.platform.startswith('gnukfreebsd'):
assert_equal(e... |
def get_world_size():
if (not dist.is_available()):
return 1
if (not dist.is_initialized()):
return 1
return dist.get_world_size() |
def test_resampler_last_stage_passthrough():
(X, y) = make_classification(n_classes=2, class_sep=2, weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0, n_features=20, n_clusters_per_class=1, n_samples=50000, random_state=0)
rus = RandomUnderSampler(random_state=42)
pipe = make_pipeline(rus, None)
... |
def get_default_plots_list():
plots_list = [['AssA', 'DetA', 'HOTA', 'HOTA', 'geometric_mean'], ['AssPr', 'AssRe', 'HOTA', 'AssA', 'jaccard'], ['DetPr', 'DetRe', 'HOTA', 'DetA', 'jaccard'], ['HOTA(0)', 'LocA(0)', 'HOTA', 'HOTALocA(0)', 'multiplication'], ['HOTA', 'LocA', 'HOTA', None, None], ['HOTA', 'MOTA', 'HOTA'... |
def findmap(*args, **kwargs):
if (len(args) > 3):
raise TypeError(('findmap takes at most 3 positional arguments (%s given)' % len(args)))
bad_args = set(kwargs).difference(['values', 'distribution', 'domain', 'codomain', 'depth', 'max_values'])
if bad_args:
raise TypeError(("findmap got une... |
class Reader():
def __init__(self, task: Task, *args: Any, **kwargs: Any):
self.task = task
self._roles = {}
self._dropped_features = []
self._used_array_attrs = {}
self._used_features = []
def roles(self) -> RolesDict:
return self._roles
def dropped_features(... |
def tn(y_true, y_pred):
smooth = 1
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = (1 - y_pred_pos)
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = (1 - y_pos)
tn = ((K.sum((y_neg * y_pred_neg)) + smooth) / (K.sum(y_neg) + smooth))
return tn |
def main(as_module=False):
cli.main(args=sys.argv[1:], prog_name=('python -m flask' if as_module else None)) |
def _validate_params_axes(params_axes, params):
axis_names = flax_partitioning.get_axis_names(params_axes)
missing_params_axes = (set(traverse_util.flatten_dict(params, sep='/')) - set(traverse_util.flatten_dict(axis_names, sep='/')))
if missing_params_axes:
raise ValueError(f'Missing axis names for... |
def load_model(ckpt_file: str, _config):
init_params = JNFExp.get_init_params(_config)
model = JNFExp.load_from_checkpoint(ckpt_file, **init_params)
model.to('cuda')
return model |
def get_mesh():
cs = 10.0
ncx = 4
ncy = 4
ncz = 4
npad = 2
return discretize.TensorMesh([[(cs, npad, (- 1.3)), (cs, ncx), (cs, npad, 1.3)], [(cs, npad, (- 1.3)), (cs, ncy), (cs, npad, 1.3)], [(cs, npad, (- 1.3)), (cs, ncz), (cs, npad, 1.3)]], 'CCC') |
def save_masks(masks, index, categories, mask_name, outdir):
masks = masks.cpu().detach().numpy()
for (i, (mask, category)) in enumerate(zip(masks, categories), start=index):
np.save(os.path.join(outdir, f'{mask_name}_{(i + 1)}_mask_{category}.npy'), mask) |
(scope='function')
def config_montecarlo_1e5_verysimple(example_configuration_dir):
return Configuration.from_yaml((example_configuration_dir / 'tardis_configv1_verysimple.yml')) |
def oracle_score(confidence: ConfidenceFeatures):
label = ConfidenceEstimator.convert_to_labels([confidence])[0]
oracle_confidence = ((label * ((np.random.random() / 2) + 0.5)) + ((1 - label) * (np.random.random() / 2)))
return oracle_confidence |
def weighted_sparse_xentropy(y_true, y_pred, weights, from_logits=False):
tshp = tf.shape(y_true)
tshp_stat = y_true.shape
y_true = tf.reshape(y_true, shape=[(- 1)])
y_pred = tf.reshape(y_pred, shape=[(- 1), y_pred.shape[(- 1)]])
weights = tf.gather(weights, tf.cast(y_true, tf.int32))
xent = bac... |
def phase_net_file():
with tempfile.NamedTemporaryFile(mode='w+', delete=False) as f:
f.write("name: 'pythonnet' force_backward: true\n layer { type: 'Python' name: 'layer' top: 'phase'\n python_param { module: 'test_python_layer' layer: 'PhaseLayer' } }\n ")
return f.name |
def write_vnnlib_spec(upper_bound: torch.Tensor, lower_bound: torch.Tensor, correct_label: int, path: str):
output_class = 10
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, 'w') as f:
f.write(f'''; Mnist property with label: {correct_label}.
''')
f.write(f'''; Input variab... |
def check_acc(lag, k):
try:
if ((not isinstance(lag, int)) or (lag <= 0)):
raise ValueError('Error, parameter lag must be an int type and larger than 0.')
elif ((not isinstance(k, int)) or (lag <= 0)):
raise ValueError('Error, parameter k must be an int type and larger than 0... |
def _gen_random_bool_series(size: int, random_state: Union[(int, np.random.RandomState)]=0) -> pd.Series:
rand = _resolve_random_state(random_state)
arr = rand.choice([True, False], size=size)
return pd.Series(arr) |
def rnd_uniform(low, high):
if (low == high):
return low
return np.random.uniform(low, high) |
def test_get_reference_value_3(test_case_mock):
ctx = ExecutionContext(ModuleProvider())
var_mock = MagicMock(foo=MagicMock(bar=5))
var = vr.VariableReference(test_case_mock, int)
ref = vr.FieldReference(vr.FieldReference(var, gao.GenericField(MagicMock, 'foo', int)), gao.GenericField(MagicMock, 'bar', ... |
def test_max_batch_size():
coords = np.random.randint(low=0, high=1848, size=(40000, 2))
tstart = time.time()
ensure_spacing(coords, spacing=100, min_split_size=50, max_split_size=2000)
dur1 = (time.time() - tstart)
tstart = time.time()
ensure_spacing(coords, spacing=100, min_split_size=50, max_... |
class TrackMessages(Callback):
def __init__(self, keys=['a', 'n_iter', 'direction']):
self.keys = keys
self.records = []
def __call__(self, algo, i, max_iter):
if (i == 0):
self.records = []
self.records += algo.get_edges_data(self.keys)
def get_dataframe(self):
... |
def main():
easycase12 = set()
easycase123 = set()
easycase1234 = set()
for x in range((1 << 12)):
sizes = compute_code_point_size(x)
if easy_case12(sizes):
z1 = grab_easy_case12_code_point_size(sizes)
easycase12.add(tuple(z1))
elif easy_case123(sizes):
... |
.parametrize('array', [ak.contents.NumpyArray(np.arange(4)), ak.contents.IndexedArray(ak.index.Index64(np.arange(4, dtype=np.int64)), ak.contents.NumpyArray(np.arange(4))), ak.contents.IndexedOptionArray(ak.index.Index64(np.arange(4, dtype=np.int64)), ak.contents.NumpyArray(np.arange(4))), ak.contents.ListOffsetArray(a... |
class ConformerPositionwiseFeedForward(rf.Module):
def __init__(self, out_dim: Dim, *, ff_dim: Dim, dropout: float, activation: Callable[([Tensor], Tensor)]):
super().__init__()
self.out_dim = out_dim
self.dropout = dropout
self.dropout_broadcast = rf.dropout_broadcast_default()
... |
def main(args):
cfg = get_default_cfg()
if args.cfg_file:
cfg.merge_from_file(args.cfg_file)
cfg.merge_from_list(args.opts)
cfg.freeze()
device = torch.device(cfg.DEVICE)
print('Creating model')
model = SeqNet(cfg)
model.to(device)
model.eval()
resume_from_ckpt(args.ckpt,... |
class IInt8EntropyCalibrator2(CalibratorBase, trt.IInt8EntropyCalibrator2):
def __init__(self, *args, **kwargs):
CalibratorBase.__init__(self, *args, **kwargs)
trt.IInt8EntropyCalibrator2.__init__(self) |
def is_FriCASElement(x):
from sage.misc.superseded import deprecation
deprecation(34804, 'the function is_FriCASElement is deprecated; use isinstance(x, sage.interfaces.abc.FriCASElement) instead')
return isinstance(x, FriCASElement) |
class Random(_random.Random):
VERSION = 3
def __init__(self, x=None):
self.seed(x)
self.gauss_next = None
def seed(self, a=None):
if (a is None):
try:
a = int(_hexlify(_urandom(2500)), 16)
except NotImplementedError:
import time... |
(config_path='cfgs', config_name='config')
def main(cfg):
from train_robot_ssl_hand import WorkspaceIL as W
workspace = W(cfg)
if cfg.load_bc:
snapshot = Path(cfg.bc_weight)
if snapshot.exists():
print(f'resuming bc: {snapshot}')
workspace.load_snapshot(snapshot)
... |
def SuffixNet(name, net, prefix_len, outputs):
outputs = BlobReferenceList(outputs)
for output in outputs:
assert net.BlobIsDefined(output)
new_net = net.Clone(name)
del new_net.Proto().op[:]
del new_net.Proto().external_input[:]
del new_net.Proto().external_output[:]
new_net.Proto()... |
class NezhaForMaskedLM(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
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, dat... |
def build_dataloader(dataset, image_set, cfg):
dataloader = DataLoader(dataset=dataset, batch_size=cfg['DATA'][image_set.upper()]['BATCH_SIZE'], shuffle=(image_set == 'train'), num_workers=cfg['DATA']['NUM_WORKER'])
return dataloader |
def infer_tasklet_connectors(sdfg: SDFG, state: SDFGState, node: Tasklet, inferred: TypeInferenceDict):
if (node.code.language != dtypes.Language.Python):
raise NotImplementedError('Tasklet inference for other languages than Python not supported')
if any(((inferred[(node, conn, True)].type is None) for ... |
class TFBertForNextSentencePrediction():
def __init__(self, *args, **kwargs):
requires_tf(self) |
class _operation_layer():
def __init__(self, layer: LayerPQC, num_layers: int=1, layer_number: int=1) -> None:
self.layer = layer
self.num_layers = num_layers
self.layer_number = layer_number
def change_qubits(self, value):
for operation in self.layer.operation_list:
... |
def conv2d_transpose_strided(x, W, b, output_shape=None, stride=2):
if (output_shape is None):
output_shape = x.get_shape().as_list()
output_shape[1] *= 2
output_shape[2] *= 2
output_shape[3] = W.get_shape().as_list()[2]
conv = tf.nn.conv2d_transpose(x, W, output_shape, strides=[... |
def test():
assert ak.almost_equal(ak.concatenate([ak.Array([1, 2, 3]), ak.Array([1, 2, None])]), ak.contents.ByteMaskedArray(ak.index.Index8(np.array([False, False, False, False, False, True])), ak.contents.NumpyArray(np.array([1, 2, 3, 1, 2, 3], dtype=np.int64)), valid_when=False)) |
def longest_common_prefix(strings):
if (not strings):
return ''
min_s = min(strings)
max_s = max(strings)
if (not min_s):
return ''
for i in range(len(min_s)):
if (max_s[i] != min_s[i]):
return max_s[:i]
return min_s[:] |
class LmDataset(CachedDataset2):
def __init__(self, corpus_file, skip_empty_lines=True, orth_symbols_file=None, orth_symbols_map_file=None, orth_replace_map_file=None, word_based=False, word_end_symbol=None, seq_end_symbol='[END]', unknown_symbol='[UNKNOWN]', parse_orth_opts=None, phone_info=None, add_random_phone_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.