code stringlengths 101 5.91M |
|---|
def update_and_save_stats(new_stats, label, yaml_filename):
stats = dict()
if os.path.exists(yaml_filename):
stats = yaml.load(open(yaml_filename, 'r'), Loader=yaml.FullLoader)
stats[label] = new_stats
with open(yaml_filename, 'w') as outfile:
outfile.write(yaml.dump(stats, default_flow_... |
def _translate_abs_level_to_arg(level, hparams):
translate_const = hparams['translate_const']
level = ((level / _MAX_LEVEL) * float(translate_const))
level = _randomly_negate(level)
return (level,) |
class WeiboNERLoader(CNNERLoader):
def __init__(self):
super().__init__()
def download(self) -> str:
dataset_name = 'weibo-ner'
data_dir = self._get_dataset_path(dataset_name=dataset_name)
return data_dir |
class MlpBlock(nn.Module):
def __init__(self, input_dim, mlp_dim=512):
super().__init__()
self.fc1 = nn.Linear(input_dim, mlp_dim)
self.gelu = nn.GELU()
self.fc2 = nn.Linear(mlp_dim, input_dim)
def forward(self, x):
return self.fc2(self.gelu(self.fc1(x))) |
def ask_questions_in_text(passage, bridge_entities, p_index):
QA_pairs = qg_nlp.qg_without_answer(passage)
valid_triples = []
for qa in QA_pairs:
bridge = include_bridge_entity(qa['question'], bridge_entities)
if (not (bridge is None)):
valid_triples.append([qa['question'], bridg... |
def test_min_span_tree_plot():
clusterer = HDBSCAN(gen_min_span_tree=True).fit(X)
if_matplotlib(clusterer.minimum_spanning_tree_.plot)(edge_cmap='Reds')
(H, y) = make_blobs(n_samples=50, random_state=0, n_features=10)
H = StandardScaler().fit_transform(H)
clusterer = HDBSCAN(gen_min_span_tree=True).... |
def has_indirect_component(k1, k2, k3, k4, k5, k6):
two_p = ((k2 + k4) + 1)
two_p1 = ((- 1) * ((k1 + k3) - 1))
m = ((k5 - two_p1) + 1)
m_is_zero_or_one = ((m == 0) or (m == 1))
return (is_zero_or_two(two_p) and is_zero_or_two(two_p1) and m_is_zero_or_one) |
class AttackerNode2(Node):
def config(self, **params):
super(AttackerNode2, self).config(**params)
self.cmd('ifconfig attacker2-eth1 10.0.0.2')
self.cmd('sh bridge-start2.sh')
self.cmd('openvpn openvpn-server2.conf &')
def terminate(self):
self.cmd('pkill openvpn')
... |
def _read_annotations(csv_reader, classes):
result = {}
for (line, row) in enumerate(csv_reader):
try:
(img_file, x1, y1, x2, y2, class_name) = row
except ValueError:
raise_from(ValueError("line {}: format should be 'img_file,x1,y1,x2,y2,class_name' or 'img_file,,,,,'".fo... |
class EngineType(enum.Enum):
TPU = 1
GDMA = 2
SDMA = 3
HAU = 4
Engine_TYPE_END = 5 |
class LinearReluLinearModel(torch.nn.Module):
def __init__(self):
super().__init__()
self.fc1 = torch.nn.Linear(5, 8).to(dtype=torch.float)
self.relu = torch.nn.ReLU()
self.fc2 = torch.nn.Linear(8, 5).to(dtype=torch.float)
def forward(self, x):
x = self.fc1(x)
x =... |
class MetricTracker():
def __init__(self, patience: Optional[int]=None, should_decrease: bool=None):
self._best_so_far: Optional[float] = None
self._patience = patience
self._epochs_with_no_improvement = 0
self._is_best_so_far = True
self.best_epoch_metrics: Dict[(str, float)... |
def tuple_to_short_str(the_tuple: tuple) -> str:
short_str = ''
for entry in the_tuple:
short_str += (str(entry) + ',')
return short_str[:(- 1)] |
class SciKernelInitializer(k.initializers.VarianceScaling):
def __init__(self, lay=0, seed=None):
self.lay = lay
self.w0 = 1.0
scale = 1.0
distribution = 'truncated_normal'
if (lay == 0):
mode = 'fan_in'
else:
mode = 'fan_avg'
super(Sci... |
def parse_math_answer(setting_name, raw_string):
if (setting_name == 'few-shot-CoT'):
raw_string = extract_last_line(raw_string)
if ((setting_name == 'few-shot-CoT') or (setting_name == 'few-shot')):
raw_string = remove_few_shot_prefix(raw_string)
return raw_string
def remove_boxed(s... |
class ConstraintPage():
def __init__(self, template_object: PageTemplate) -> None:
self.template_object = template_object
def page_writer(self, constraints: List[ForeignKeyConstraint], tables: List[Table], new_file: str):
page_data = PageData('constraint.html', 'constraint.js')
page_data... |
def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kwargs):
if (not quantize):
with open(filename, 'wb') as f:
f.write('PIEH'.encode('utf-8'))
np.array([flow.shape[1], flow.shape[0]], dtype=np.int32).tofile(f)
flow = flow.astype(np.float32)
... |
def test_merge_min():
dict0 = {0: 0.5, 1: 0.2}
dict1 = {0: 0.3, 1: 0.6}
ExecutionTrace._merge_min(dict0, dict1)
assert (dict0 == {0: 0.3, 1: 0.2}) |
class Block(nn.Module):
def __init__(self, dim, key_dim, num_heads, mlp_ratio=4.0, attn_ratio=2.0, drop=0.0, drop_path=0.0, act_layer=nn.ReLU, norm_cfg=dict(type='BN2d', requires_grad=True)):
super().__init__()
self.dim = dim
self.num_heads = num_heads
self.mlp_ratio = mlp_ratio
... |
def _format(val: Any, output_format: str='standard', errors: str='coarse') -> Any:
val = str(val)
result: Any = []
if (val in NULL_VALUES):
return [np.nan]
if (not validate_md_idno(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
error_r... |
class DataSetIter(BatchIter):
def __init__(self, dataset, batch_size=1, sampler=None, as_numpy=False, num_workers=0, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, batch_sampler=None):
assert isinstance(dataset, DataSet)
dataset = DataSetGetter(dataset, as_numpy)
collate_... |
def test_combine_outfile(tmp_path, script_runner):
temp_1 = tmp_path.joinpath('parsed_output.json')
temp_2 = tmp_path.joinpath('renamed_output.json')
command = f'pyhf xml2json validation/xmlimport_input/config/example.xml --basedir validation/xmlimport_input/ --output-file {temp_1} --hide-progress'
ret ... |
def register_types_ns3_TracedValueCallback(module):
root_module = module.get_root()
typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double')
typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*')
typehandlers.add... |
def main():
parser = argparse.ArgumentParser(description='PyTorch distributed benchmark diff')
parser.add_argument('file', nargs=2)
args = parser.parse_args()
if (len(args.file) != 2):
raise 'Must specify 2 files to diff'
ja = load(args.file[0])
jb = load(args.file[1])
keys = ((set(j... |
class GradleCommand(BuildCommand):
def name() -> str:
return 'gradle'
def _prepare_args(self, args: List[str]) -> List[str]:
return (args + ['--debug'])
def _get_errors(self, output: str, error: str) -> str:
lines = output.splitlines()
return '\n'.join([line for line in lines... |
def mmd(x, y):
(n, dim) = x.shape
xx = (x ** 2).sum(1, keepdim=True)
yy = (y ** 2).sum(1, keepdim=True)
outer_xx = torch.mm(x, x.t())
outer_yy = torch.mm(y, y.t())
outer_xy = torch.mm(x, y.t())
diff_xx = ((xx + xx.t()) - (2 * outer_xx))
diff_yy = ((yy + yy.t()) - (2 * outer_yy))
diff... |
def main():
app_path = os.path.dirname(os.path.realpath(__file__))
parser = argparse.ArgumentParser(description='BLASYS -- Approximate Logic Synthesis Using Boolean Matrix Factorization')
parser.add_argument('-i', help='Input verilog file', required=True, dest='input')
parser.add_argument('-o', help='Ou... |
def __generate_fingerprint(subproc_args):
(torexe, datadir, nickname, torrc) = subproc_args
listfp_cmd = '{} --list-fingerprint --DataDirectory {} --Nickname {} -f {}'.format(torexe, datadir, nickname, torrc)
completed_process = subprocess.run(shlex.split(listfp_cmd), stdout=subprocess.PIPE, stderr=subproce... |
def _serialize_to_tensor(data, group):
global _USE_HVD
if _USE_HVD:
backend = 'nccl'
else:
backend = dist.get_backend(group)
assert (backend in ['gloo', 'nccl'])
device = torch.device(('cpu' if (backend == 'gloo') else 'cuda'))
buffer = pickle.dumps(data)
if (len(buffer) > (1... |
def test_make_splits_order():
(train, val, test) = make_splits(100, 0.7, 0.2, 0.1, 1234, order=torch.arange(100, 0, (- 1), dtype=torch.int))
assert (train == torch.arange(100, 30, (- 1), dtype=torch.int)).all()
assert (val == torch.arange(30, 10, (- 1), dtype=torch.int)).all()
assert (test == torch.aran... |
def time_op(device, func, *inputs: tuple, **kwargs):
cuda_mem = 0
if (device.type == 'cuda'):
torch.cuda.reset_max_memory_allocated(device=device)
base_mem = torch.cuda.memory_allocated(device=device)
start = torch.cuda.Event(enable_timing=True)
end = torch.cuda.Event(enable_timi... |
.parametrize('shuffle', [True])
def test_simple_data_source_duplicated_order(test_data_csv_png_20, shuffle):
src_data = tuple(zip(range(100), range(100)))
def test_load_func(position):
return src_data[position]
epoch_num = 10
size = len(src_data)
ds = SimpleDataSource(test_load_func, size, s... |
def ensure_dir(path):
try:
os.makedirs(path)
except OSError as e:
if (e.errno != errno.EEXIST):
raise |
def env_runner(client: RayInferenceClient, servers: Dict[(str, RayInferenceWorkerSet)], rollout_config: Dict[(str, Any)], server_runtime_config: Dict[(str, Any)], dwriter_info_dict: Dict[(str, Tuple[(str, Queue)])]=None) -> Tuple[(List[Dict[(str, Any)]], Dict[(str, float)])]:
evaluate_on = (server_runtime_config['b... |
def register_Ns3CsmaNetDevice_methods(root_module, cls):
cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
cls.add_constructor([])
cls.add_method('SetInterframeGap', 'void', [param('ns3::Time', 't')])
cls.add_method('SetBackoffParams', 'void', [param('ns3::Time', 'slotTime'), param('uint32_... |
def get_item():
train = pd.read_csv(PATH_TO_TRAIN, sep='\t', dtype={0: str, 1: str, 2: np.float32})
test = pd.read_csv(PATH_TO_TEST, sep='\t', dtype={0: str, 1: str, 2: np.float32})
data = pd.concat([train, test])
return data.ItemId.unique() |
def cal_acc(true_label_list, pred_label_list):
cor_num = 0
slide_num = len(true_label_list)
for i in range(slide_num):
if (true_label_list[i] == pred_label_list[i]):
cor_num += 1
return (cor_num / slide_num) |
class VFE_Layer(tf.keras.layers.Layer):
def __init__(self, c_out):
super(VFE_Layer, self).__init__()
self.units = (c_out // 2)
self.fcn = tf.keras.layers.Dense(self.units, activation='relu')
self.bn = tf.keras.layers.BatchNormalization(trainable=True)
def call(self, input, mask, ... |
_test_reporter('file')
_test_reporter('default')
class TestReporter(Dataset):
class Config():
candidate_fields: List[str] = field(default_factory=(lambda : DEFAULT_CANDIDATE_FIELDS))
predict_file_format: str = 'json'
def __init__(self, datamodules: List[pl.LightningDataModule], config: Config=No... |
class TestProcessingUnit(FixtureTest):
def test_from_path_with_seed(self):
max_int = 1000000.0
seed = 1
unit_0 = DummyProcessingUnit.from_path(None, random_state=seed)
int_0 = unit_0.random_state.randint(max_int)
unit_1 = DummyProcessingUnit.from_path(None, random_state=seed)... |
def polynomial_mmd_averages(codes_g, codes_r, n_subsets=50, subset_size=50, ret_var=True, output=sys.stdout, **kernel_args):
m = min(codes_g.shape[0], codes_r.shape[0])
subset_size = m
n_subsets = (max(codes_g.shape[0], codes_r.shape[0]) // subset_size)
mmds = np.zeros(n_subsets)
if ret_var:
... |
_utils.test(exclude=[ti.opengl, ti.gles])
def test_loop_config_parallel_range_for():
n = (1024 * 1024)
val = ti.field(ti.i32, shape=n)
def fill():
ti.loop_config(parallelize=8, block_dim=8)
for i in range(n):
val[i] = i
fill()
val_np = val.to_numpy()
for i in range(n)... |
class TrackingBox(EvalBox):
def __init__(self, sample_token: str='', translation: Tuple[(float, float, float)]=(0, 0, 0), size: Tuple[(float, float, float)]=(0, 0, 0), rotation: Tuple[(float, float, float, float)]=(0, 0, 0, 0), velocity: Tuple[(float, float)]=(0, 0), ego_translation: Tuple[(float, float, float)]=(0... |
def prompt_for_aspect_inferring(context, target):
new_context = f'Given the sentence "{context}", '
prompt = (new_context + f'which specific aspect of {target} is possibly mentioned?')
return (new_context, prompt) |
def CreateConv2dFixedChannelsOperator(manifest, layout, tile_descriptions, data_type, channel_counts, conv_kinds=[ConvKind.Fprop, ConvKind.Dgrad, ConvKind.Wgrad], epilogue_functor=EpilogueFunctor.LinearCombination, swizzling_functor=SwizzlingFunctor.Identity4):
(element_a, element_b, element_c, element_epilogue) = ... |
class AttentionEnhancementModule(nn.Module):
def __init__(self, in_chan, out_chan):
super(AttentionEnhancementModule, self).__init__()
self.conv = ConvBNReLU(in_chan, out_chan, ks=3, stride=1, padding=1)
self.conv_atten = Attention(out_chan)
self.bn_atten = BatchNorm2d(out_chan)
... |
class TripleConv(nn.Module):
def __init__(self, in_channels, out_channels, reverse=False):
super().__init__()
if reverse:
self.triple_conv = nn.Sequential(Conv3x3BNReLU(in_channels, in_channels, stride=1), Conv3x3BNReLU(in_channels, in_channels, stride=1), Conv3x3BNReLU(in_channels, out_... |
def test_trident_resnet_bottleneck():
trident_dilations = (1, 2, 3)
test_branch_idx = 1
concat_output = True
trident_build_config = (trident_dilations, test_branch_idx, concat_output)
with pytest.raises(AssertionError):
TridentBottleneck(*trident_build_config, inplanes=64, planes=64, style='... |
class UnpairedImageVal(UnpairedImageBase):
def __init__(self, size=None, random_crop=False, folder1=None, folder2=None, numpy_folder1=None, numpy_folder2=None, wikiart_info1=None, wikiart_key1=None, wikiart_info2=None, wikiart_key2=None):
super().__init__()
self.data = UnpairedImagePaths(size=size, ... |
def basic_model():
random_uniform = initializers.random_uniform(0, 1)
inputs = Input(shape=(8, 8, 3))
x = Conv2D(2, 3, padding='same', name='conv2d')(inputs)
x_bn = BatchNormalization(gamma_initializer='random_normal', beta_initializer='random_normal', moving_mean_initializer='random_normal', moving_var... |
class MaskTokensDataset(BaseWrapperDataset):
def apply_mask(cls, dataset: torch.utils.data.Dataset, *args, **kwargs):
dataset = LRUCacheDataset(dataset)
return (LRUCacheDataset(cls(dataset, *args, **kwargs, return_masked_tokens=False)), LRUCacheDataset(cls(dataset, *args, **kwargs, return_masked_tok... |
class Encoder(chainer.Chain):
def __init__(self, nb_inputs, channel_list, ksize_list, pad_list=[]):
super(Encoder, self).__init__()
self.nb_layers = len(channel_list)
channel_list = ([nb_inputs] + channel_list)
if (len(pad_list) == 0):
pad_list = [0 for _ in range(len(ksi... |
class AppDirs(object):
def __init__(self, appname=None, appauthor=None, version=None, roaming=False, multipath=False):
self.appname = appname
self.appauthor = appauthor
self.version = version
self.roaming = roaming
self.multipath = multipath
def user_data_dir(self):
... |
class CNN_Text(nn.Module):
def __init__(self, args):
super(CNN_Text, self).__init__()
self.args = args
V = args.embed_num
D = args.embed_dim
C = args.class_num
Ci = 1
Co = args.kernel_num
Ks = args.kernel_sizes
self.embed = nn.Embedding(V, D)
... |
.parametrize('prior', (EP_PRIORS + [MAP_L21NormPrior(size=(2, 100), gamma=3, isotropic=False), MAP_L21NormPrior(size=(3, 100), gamma=5, isotropic=False)]))
def test_prior_grad_EP_diagonal(prior):
assert (not prior.isotropic)
df = check_prior_grad_EP_diagonal(prior)
assert_allclose(df['rx'], df['grad_bx_A1']... |
class EMAConfig(FairseqDataclass):
store_ema: bool = field(default=False, metadata={help: 'store exponential moving average shadow model'})
ema_decay: float = field(default=0.9999, metadata={'help': 'decay for exponential moving average model'})
ema_start_update: int = field(default=0, metadata={'help': 'st... |
class TorchTrainingRun(TrainingRun):
def __init__(self, config, save_dir):
super(TorchTrainingRun, self).__init__(config, save_dir)
self.workspace.add_dir('checkpoints', 'checkpoints')
_property
def checkpoints(self):
return Checkpoints(self.workspace.checkpoints)
def _finite_gra... |
class State():
def __init__(self, model, optimizer=None, scheduler=None, epoch=None):
self.model = model
self.optimizer = optimizer
self.scheduler = scheduler
self.epoch = epoch
def save(self, filepath):
model = self.model
if (not isinstance(model, dict)):
... |
class Transformer(nn.Module):
def __init__(self, config, src_vocab, target_vocab, s_v, t_v, u):
super(Transformer, self).__init__()
self.config = config
(h, N, dropout) = (self.config.h, self.config.N, self.config.dropout)
(d_model, d_ff) = (self.config.d_model, self.config.d_ff)
... |
class Gatv2MolConfig(MolConfig):
def model(self, hparams):
return GatHIVNet(hidden_dim=self.hidden, num_graph_layers=NUM_LAYERS, in_feat_drop=hparams['dropout'], residual=True, gat_version=2)
def pretrained(self, model_dir):
return load_pretrained(self, dataset_name='hiv', model_name='gatv2', hi... |
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
directory = FLAGS.log_dir
if (not os.path.exists(directory)):
os.makedirs(directory)
filename = (directory + filename)
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, (directory + 'model_best.pth.ta... |
def _linear(args, output_size, bias, bias_initializer=None, kernel_initializer=None):
if ((args is None) or (nest.is_sequence(args) and (not args))):
raise ValueError('`args` must be specified')
if (not nest.is_sequence(args)):
args = [args]
total_arg_size = 0
shapes = [a.get_shape() for... |
class AlphaDropout(_DropoutNd):
def forward(self, input):
return F.alpha_dropout(input, self.p, self.training) |
def get_mock_args(finetune_from_model=None):
args_mock = MagicMock()
args_mock.optimizer_overrides = '{}'
args_mock.reset_dataloader = False
args_mock.reset_meters = False
args_mock.reset_optimizer = False
args_mock.reset_lr_scheduler = False
args_mock.finetune_from_model = finetune_from_mod... |
class _BaseWarmupScheduler(_LRScheduler):
def __init__(self, optimizer, successor, warmup_epoch, last_epoch=(- 1), verbose=False):
self.successor = successor
self.warmup_epoch = warmup_epoch
super().__init__(optimizer, last_epoch, verbose)
def get_lr(self):
raise NotImplementedEr... |
class SyncAsyncTaskDecoFactory():
def wrapper(self, func, *args, **kwargs):
(yield)
def __call__(self, func):
self.is_coroutine = asyncio.iscoroutinefunction(func)
str_fmt = '{} Method ({}); Co-routine {}'
(func)
def sync_wrapper(*args, **kwargs):
logger.debug... |
class ActivationFinalBitwidthConfigVisualizer():
def __init__(self, final_activation_nodes_config: List[Tuple[(BaseNode, int)]]):
self.final_activation_nodes_config = final_activation_nodes_config
self.node_final_bitwidth = [node_cfg[1] for node_cfg in self.final_activation_nodes_config]
sel... |
class OthelloNNet():
def __init__(self, game, args):
(self.board_x, self.board_y) = game.getBoardSize()
self.action_size = game.getActionSize()
self.args = args
self.input_boards = Input(shape=(self.board_x, self.board_y))
x_image = Reshape((self.board_x, self.board_y, 1))(se... |
def build_trie():
from glob import glob
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('EleutherAI/gpt-neo-1.3B')
ss = []
for cmd in glob('./data/tldr/manual_trimmed/*.txt'):
cmd = os.path.basename(cmd).replace('.txt', '')
tok_cmd = tokenizer(f' {cmd... |
def stem(string, language, resources):
from snips_nlu_utils import normalize
normalized_string = normalize(string)
tokens = tokenize_light(normalized_string, language)
stemmed_tokens = [_stem(token, resources) for token in tokens]
return ' '.join(stemmed_tokens) |
def register_Ns3Ipv6AddressValue_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::Ipv6Address const &', 'value')])
cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')])
cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virt... |
class polylr(object):
def __init__(self, optimizer, nb, lr):
self.nb = nb
self.lr = lr
self.optimizer = optimizer
self.iteration = 0
def step(self):
self.iteration += 1
lr = self.calc_lr()
self.update_lr(self.optimizer, lr)
def calc_lr(self):
l... |
def show_versions():
sys_info = _get_sys_info()
deps_info = _get_deps_info()
print('\nSystem:')
for (k, stat) in sys_info.items():
print('{k:>10}: {stat}'.format(k=k, stat=stat))
print('\nPython dependencies:')
for (k, stat) in deps_info.items():
print('{k:>13}: {stat}'.format(k=... |
def fourier_ellipsoid(input, size, n=(- 1), axis=(- 1), output=None):
input = numpy.asarray(input)
if (input.ndim > 3):
raise NotImplementedError('Only 1d, 2d and 3d inputs are supported')
output = _get_output_fourier(output, input)
if (output.size == 0):
return output
axis = normali... |
.parametrize('max_kl_weight', [1.0, 2.0])
def test_compute_kl_weight_no_annealing(max_kl_weight):
assert (_compute_kl_weight(1, 1, None, None, max_kl_weight, 0.0) == max_kl_weight) |
class FWGDMAType(Enum):
DEFAULT = (- 1)
LD_INPUT_NEURON = 0
ST_OUTPUT_NEURON = 1
LD_ITM_NEURON = 2
ST_ITM_NEURON = 3
LD_COEFF = 4
LD_COEFF_NERUON = 5
LD_COEFF_WINOGRAD = 6
MV_ITM_NEURON = 7
MV_OUTPUT_NEURON = 8
MV_ITM_EXTEND_NEURON = 9
ST_ITM_EXTEND_NEURON = 10
LD_G2L... |
def create_inception_v4(nb_classes=int(args['num_classes']), load_weights=check):
init = Input((299, 299, 3))
x = inception_stem(init)
for i in range(4):
x = inception_A(x)
x = reduction_A(x)
for i in range(7):
x = inception_B(x)
x = reduction_B(x)
for i in range(3):
... |
def format_stack_entry(r):
repr_str = repr(r)
if ('\n' in repr_str):
repr_str = repr(repr_str)
if (len(repr_str) < 16):
return repr_str
else:
return ('<%s 0x%x>' % (type(r).__name__, id(r))) |
class UrsemWaves(Benchmark):
def __init__(self, dimensions=2):
Benchmark.__init__(self, dimensions)
self._bounds = [((- 0.9), 1.2), ((- 1.2), 1.2)]
self.global_optimum = [[1.2 for _ in range(self.N)]]
self.fglob = (- 8.5536)
def fun(self, x, *args):
self.nfev += 1
... |
('Direct')
def AddDirectGradient(op, g_output):
return (CopyDeviceOption(CreateOperator('DirectGradient', NeedAll(op, g_output), GIS(op)), op), GIS(op)) |
def save_npz(file, matrix, compressed=True):
arrays_dict = {}
if (matrix.format in ('csc', 'csr', 'bsr')):
arrays_dict.update(indices=matrix.indices, indptr=matrix.indptr)
elif (matrix.format == 'dia'):
arrays_dict.update(offsets=matrix.offsets)
elif (matrix.format == 'coo'):
arr... |
def test(model, test_loader, num_nodes, target, device):
model.eval()
correct = 0
total_loss = 0
n_graphs = 0
with torch.no_grad():
for (idx, data) in enumerate(test_loader):
out = model(data.to(device))
total_loss += F.nll_loss(out, target).item()
pred = ... |
def _fix_lane_names(label):
l_counter = 0
r_counter = 0
mapping = {}
lane_ids = [lane['lane_id'] for lane in label['lanes']]
for key in sorted(lane_ids):
if (key[0] == 'l'):
mapping[key] = ('l' + str(l_counter))
l_counter += 1
if (key[0] == 'r'):
m... |
class Partition14(nn.Module):
LAYER_SCOPES = ['T5ForConditionalGeneration/T5Stack[decoder]/ModuleList[block]/T5Block[21]', 'T5ForConditionalGeneration/T5Stack[decoder]/ModuleList[block]/T5Block[22]', 'T5ForConditionalGeneration/T5Stack[decoder]/ModuleList[block]/T5Block[23]', 'T5ForConditionalGeneration/T5Stack[dec... |
def do_int(value, default=0, base=10):
try:
if isinstance(value, string_types):
return int(value, base)
return int(value)
except (TypeError, ValueError):
try:
return int(float(value))
except (TypeError, ValueError):
return default |
class RandomStrongHopper(ModifiableRoboschoolHopper):
def randomize_power(self):
self.power = self.np_random.uniform(self.RANDOM_LOWER_POWER, self.RANDOM_UPPER_POWER)
def _reset(self, new=True):
if new:
self.randomize_power()
return super(RandomStrongHopper, self)._reset(new)... |
def determine_redshift_from_filename(filename):
filename = os.path.basename(filename)
filename = os.path.splitext(filename)[0]
number_strs = []
last_was_char = True
for s in filename:
if (s.isdigit() or (s == '.')):
if last_was_char:
number_strs.append([])
... |
class MORPH_TRANSFORMATIONS(Enum):
EROSION = 'erosion'
DILATION = 'dilation'
OPENING = 'opening'
CLOSING = 'closing'
GRADIENT = 'gradient' |
def load_test_data(train_path, filelist):
sent_size = 0
examples = []
instance_size = 0
for fil in filelist:
line_co = 0
readfile = codecs.open(((train_path + '/') + fil), 'r', 'utf-8')
for line in readfile:
if (line_co == 0):
line_group = []
... |
class Histogram(object):
def __init__(self, training_instances, names, granularity=(1, 1, 1), use_progress=False):
self.names = names
self.buckets = defaultdict(Counter)
self.bucket_counts = defaultdict(int)
self.granularity = granularity
self.bucket_sizes = ((360 // granular... |
class AttFusion(nn.Module):
def __init__(self, input_dim=[512, 512], hidden_dim=128):
super(AttFusion, self).__init__()
self.use_proj = (input_dim[1] != input_dim[0])
if self.use_proj:
self.proj_v = nn.Linear(input_dim[1], input_dim[0])
self.scorer_a = GRU(input_dim[0], h... |
def test_anntorchdataset_from_manager(adata):
adata_manager = generic_setup_adata_manager(adata)
bd = adata_manager.create_torch_dataset()
assert isinstance(bd, AnnTorchDataset)
bd = adata_manager.create_torch_dataset(indices=np.arange(adata.n_obs))
assert isinstance(bd, torch.utils.data.Subset) |
def test_build_vanilla_deep_gp_returns_correct_defaults() -> None:
search_space = (Box([0.0], [1.0]) ** 4)
x = search_space.sample(100)
data = mk_dataset(x, quadratic(x))
(empirical_mean, empirical_variance, _) = _get_data_stats(data)
num_inducing = min(MAX_NUM_INDUCING_POINTS, (NUM_INDUCING_POINTS_... |
class TestStreamingPickle(unittest.TestCase):
def setUp(self):
pass
def testSimpleList(self):
data = [1, [1, 2, 3, 4], [8, 9, 29]]
with tempfile.TemporaryFile() as f:
s_dump(data, f)
f.seek(0)
i = 0
for (i, element) in enumerate(s_load(f)):... |
def test_from_iter():
a = ak.Array([[1], [2, None]])
assert (to_list(ak.drop_none(a)) == [[1], [2]])
a = ak.Array([[2, None]])
assert (to_list(ak.drop_none(a)) == [[2]])
a = ak.Array([[[None]]])
assert (to_list(ak.drop_none(a)) == [[[]]])
a = ak.Array([1, 2, None])
assert to_list(ak.drop... |
def build_hidden_model(n_features, n_outputs, hidden_nodes, compile=False, optimizer='adam', lr=0.01, loss=crps_cost_function, activation='relu'):
if (type(hidden_nodes) is not list):
hidden_nodes = [hidden_nodes]
inp = Input(shape=(n_features,))
x = Dense(hidden_nodes[0], activation=activation)(inp... |
_task('new_multilingual_masked_lm', dataclass=NewMultiLingualMaskedLMConfig)
class NewMultiLingualMaskedLMTask(LegacyFairseqTask):
def __init__(self, args, dictionary):
super().__init__(args)
self.dictionary = dictionary
self.seed = args.seed
lang_list = args.langs.split(',')
... |
def setup_text_prompts(cfg, tokenizer):
entity_filepath = cfg.entity_file_path
entity_num = cfg.num_entities
content = open(entity_filepath).read().split('\n')[:entity_num]
entities = [c.split(' ')[0] for c in content]
video_prompt_templates = get_video_prompt_templates()
image_prompt_templates ... |
def _coerce_to_rr(s: Union[(str, RepoRef)]) -> RepoRef:
if isinstance(s, RepoRef):
return s
else:
return RepoRef.from_string(s) |
def add_train_command(subparsers):
subparser = subparsers.add_parser('train', help='Training with NNP.')
subparser.add_argument('-r', '--resume', help='Resume from last saved parameter', action='store_true')
subparser.add_argument('-c', '--config', help='Path to nntxt', required=True)
subparser.add_argu... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.