code stringlengths 101 5.91M |
|---|
def words_vec(w2v, words, use_norm=False):
if callable(getattr(w2v, 'words_vec', None)):
return w2v.words_vec(words, use_norm)
return {word: w2v.wv.word_vec(word, use_norm) for word in words if (word in w2v.wv)} |
_module()
class DistillCls(BaseCls):
def __init__(self, encoder_args=None, cls_args=None, distill_args=None, criterion_args=None, **kwargs):
super().__init__(encoder_args, cls_args, criterion_args)
self.distill = encoder_args.get('distill', True)
in_channels = self.encoder.distill_channels
... |
def even_quantile_labels(vals, nclasses, verbose=True):
label = ((- 1) * np.ones(vals.shape[0], dtype=np.int))
interval_lst = []
lower = (- np.inf)
for k in range((nclasses - 1)):
upper = np.quantile(vals, ((k + 1) / nclasses))
interval_lst.append((lower, upper))
inds = ((vals >=... |
.parametrize('seed', [313, 314])
.parametrize('op', ['+', '-'])
def test_variable_arithmetic_unary_ops(seed, op):
rng = np.random.RandomState(seed)
vx = nn.Variable.from_numpy_array(rng.randn(2, 3, 4).astype(np.float32))
with nn.auto_forward():
vz = eval('{0} vx'.format(op))
ref_z = eval('{0... |
_level_function(module='ak.str')
def ltrim(array, characters, *, highlevel=True, behavior=None, attrs=None):
(yield (array,))
return _impl(array, characters, highlevel, behavior, attrs) |
def register_Ns3CidFactory_methods(root_module, cls):
cls.add_constructor([param('ns3::CidFactory const &', 'arg0')])
cls.add_constructor([])
cls.add_method('Allocate', 'ns3::Cid', [param('ns3::Cid::Type', 'type')])
cls.add_method('AllocateBasic', 'ns3::Cid', [])
cls.add_method('AllocateMulticast', ... |
def general_pattern(pattern):
general_pattern_list = []
for x in pattern.split(' '):
if (x in KEY_KEYWORD_SET):
general_pattern_list.append(x)
return ' '.join(general_pattern_list) |
def defend(list1, list2, r_in=0.02, r_out=0.02, mintime=42):
datasize = 1
buf = [0, 0]
listind = 0
starttime = list1[0][0]
lastpostime = starttime
lastnegtime = starttime
curtime = starttime
count = [0, 0]
lastind = [0, 0]
for i in range(0, len(list1)):
if (list1[i][1] > ... |
def masked_metric_iou(mask, reg_weight=0, norm_by_mask=True):
def iou_metric(y_true, y_pred):
axis = ((- 1) if backend_channels_last() else 1)
y_pred = K.maximum(0.0, y_pred)
inter = K.mean(K.square(K.minimum(y_true, y_pred)), axis=axis)
union = K.mean(K.square(K.maximum(y_true, y_pr... |
def unify_batches(name: str, train_registry: Path, val_registry: Path, train_dir: Path, val_dir: Path, index_dir: Path, batch_formats: Tuple[(Tuple[(str, Tuple[(str, ...)])], ...)], max_epochs: int=400, initial_final_alpha: float=0.2) -> None:
overwatch.info(f'Phase 3 Preprocessing :: Assembling *Data-Locked* Batch... |
def recurrent_fn(params, rng_key, action, state):
del params
current_player = state.current_player
state = env.step(state, action)
logits = policy_fn(state.legal_action_mask)
value = value_fn(rng_key, state)
reward = state.rewards[current_player]
value = jax.lax.select(state.terminated, 0.0,... |
_utils.test(require=ti.extension.sparse, exclude=[ti.metal])
def test_append_u8():
x = ti.field(ti.u8)
pixel = ti.root.dynamic(ti.j, 20)
pixel.place(x)
def make_list():
ti.loop_config(serialize=True)
for i in range(20):
x[()].append(((i * i) * i))
make_list()
for i in... |
def plot_belief_grad_b(belief, **kwargs):
df = check_belief_grad_b(belief, **kwargs)
(fig, axs) = plt.subplots(1, 2, figsize=(8, 4))
axs[0].plot(df['b'], df['r'], '-', label='r')
axs[0].plot(df['b'], df['A1'], '--', label='$\\partial_{b} A$')
axs[0].set(xlabel='b')
axs[0].legend()
axs[1].plo... |
class GradientPTQTest(GradientPTQBaseTest):
def compare(self, quantized_model, float_model, input_x=None, quantization_info=None):
y = float_model(input_x)
y_hat = quantized_model(input_x)
cs = cosine_similarity(y.numpy(), y_hat.numpy())
self.unit_test.assertTrue(np.isclose(cs, 1, rt... |
class create_model_3(torch.nn.Module):
def __init__(self):
super(create_model_3, self).__init__()
self.conv1 = Conv2d(3, 3, kernel_size=1, stride=1)
self.bn = BatchNorm2d(3)
self.bn = bn_weight_change(self.bn)
self.bn2 = BatchNorm2d(3)
self.bn2 = bn_weight_change(self... |
def z_cost(z, errors, mean, std):
epsilon = (mean + (z * std))
(delta_mean, delta_std) = deltas(errors, epsilon, mean, std)
(above, consecutive) = count_above(errors, epsilon)
numerator = (- ((delta_mean / mean) + (delta_std / std)))
denominator = (above + (consecutive ** 2))
if (denominator == ... |
def ones_d(shape):
if isinstance(shape, (list, tuple)):
shape = tf.stack(shape)
return tf.ones(shape) |
class MininetTopoFromNxGraph(Topo):
def build(self, graph):
hosts = {}
for node in graph.nodes(data=True):
name = node[0]
params = node[1]
if ('is_not_mininet_switch' in params):
hosts[name] = self.addSwitch(name)
else:
... |
def test_crossover_wrong_type(chromosome):
with pytest.raises(AssertionError):
chromosome.cross_over(0, 0, 0) |
def get_task(config: configure_finetuning.FinetuningConfig, task_name, tokenizer):
if (task_name == 'cola'):
return classification_tasks.CoLA(config, tokenizer)
elif (task_name == 'mrpc'):
return classification_tasks.MRPC(config, tokenizer)
elif (task_name == 'mnli'):
return classifi... |
def save_img(save_dir, img, unnormalize=True, max_num=200, size=64, nrow=10, dataname='imagenet'):
img = img[:max_num].detach()
if unnormalize:
img = img_denormlaize(img, dataname=dataname)
img = torch.clamp(img, min=0.0, max=1.0)
if (img.shape[(- 1)] > size):
img = F.interpolate(img, si... |
def create_optimizer(cfg: DictConfig, *args: List, **kwargs: Dict) -> Optimizer:
if (cfg is None):
return None
return OPTIMIZER.get(cfg.name)(cfg, *args, **kwargs) |
_context(matplotlib_settings)
def scale_wavefunctions(wavefunc_list: List['WaveFunction'], potential_vals: np.ndarray, scaling: Optional[float]) -> List['WaveFunction']:
scale_factors = np.array([wavefunc.amplitude_scale_factor(potential_vals) for wavefunc in wavefunc_list])
for wavefunc in wavefunc_list:
... |
def apply_half(t):
if (t.dtype is torch.float32):
return t.to(dtype=torch.half)
return t |
def make_response_filter(status_code: str, all_status_codes: list[str]) -> FilterFunction:
if (status_code == 'default'):
return default_status_code(all_status_codes)
return match_status_code(status_code) |
class DataPrefetcher1():
def __init__(self, loader):
self.loader = iter(loader)
self.stream = torch.cuda.Stream()
self.input_cuda = self._input_cuda_for_image
self.record_stream = DataPrefetcher._record_stream_for_image
self.preload()
def preload(self):
try:
... |
def define(n_eigs=20, tau=0.0):
l = common(fun_v, get_exact=get_exact, n_eigs=n_eigs, tau=tau)
return l |
class FirstOrderOptimizer(Serializable):
def __init__(self, tf_optimizer_cls=None, tf_optimizer_args=None, learning_rate=0.001, beta1=0.9, max_epochs=1000, tolerance=1e-06, batch_size=32, callback=None, verbose=False, num_slices=1, ignore_last=False, **kwargs):
Serializable.quick_init(self, locals())
... |
class Embedder(nn.Module):
def __init__(self, padding, in_channels, out_channels, num_channels, max_num_channels, embed_channels, embed_num_blocks, average_function):
super().__init__()
def get_down_block(in_channels, out_channels, padding):
return blocks.ResBlock(in_channels, out_channe... |
def subsets_with_hereditary_property(f, X, max_obstruction_size=None, ncpus=1):
from sage.data_structures.bitset import Bitset
X_labels = list(X)
n = len(X_labels)
X = set(range(n))
if (max_obstruction_size is None):
max_obstruction_size = n
bs = [Bitset([], 1) for _ in range(n)]
nfo... |
class LambdaWarmUpCosineScheduler():
def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0):
self.lr_warm_up_steps = warm_up_steps
self.lr_start = lr_start
self.lr_min = lr_min
self.lr_max = lr_max
self.lr_max_decay_steps = max_deca... |
class Physics(mujoco.Physics):
def torso_upright(self):
return self.named.data.xmat[('torso', 'zz')]
def head_height(self):
return self.named.data.xpos[('head', 'z')]
def center_of_mass_position(self):
return self.named.data.subtree_com['torso'].copy()
def center_of_mass_velocity... |
class TestBohman(object):
def test_basic(self):
assert_allclose(windows.bohman(6), [0, 0., 0., 0., 0., 0])
assert_allclose(windows.bohman(7, sym=True), [0, 0., 0., 1.0, 0., 0., 0])
assert_allclose(windows.bohman(6, False), [0, 0., 0., 1.0, 0., 0.]) |
def test_DeepWalk():
G = nx.read_edgelist('./tests/Wiki_edgelist.txt', create_using=nx.DiGraph(), nodetype=None, data=[('weight', int)])
model = DeepWalk(G, walk_length=3, num_walks=2, workers=1)
model.train(window_size=3, iter=1)
embeddings = model.get_embeddings() |
class RNNLogic(DeepModel):
include_id = False
include_user_features = False
include_item_features = False
include_context_features = False
data_loader = 'ProLogicDL'
data_processor = 'RNNLogicDP'
def parse_model_args(parser, model_name='RNNLogic'):
parser.add_argument('--rnn_type', t... |
def extract_clip(sb, in_filepath, out_filepath):
cmd = ['ffmpeg', '-ss', hhmmss(sb[0]), '-i', in_filepath, '-t', hhmmss((sb[1] - sb[0])), '-c', 'copy', '-avoid_negative_ts', '1', '-reset_timestamps', '1', '-y', '-hide_banner', '-loglevel', 'panic', '-map', '0', out_filepath]
run(cmd)
if (not os.path.isfile(... |
.gpu
def test_tasklets_with_same_local_name():
sdfg = dace.SDFG('tester')
sdfg.add_array('A', [4], dace.float32, dace.StorageType.GPU_Global)
state = sdfg.add_state()
(me, mx) = state.add_map('kernel', dict(i='0:1'), schedule=dace.ScheduleType.GPU_Device)
t1 = state.add_tasklet('sgn', {'a'}, {'b'}, ... |
def test_maml_trpo_dummy_named_env():
env = GarageEnv(normalize(DummyMultiTaskBoxEnv(), expected_action_scale=10.0))
policy = GaussianMLPPolicy(env_spec=env.spec, hidden_sizes=(64, 64), hidden_nonlinearity=torch.tanh, output_nonlinearity=None)
value_function = GaussianMLPValueFunction(env_spec=env.spec, hid... |
class Feature_Nov27():
def get_split_feature(self, split_tuple, parent_sentence, children_sentence_list, boxer_graph):
split_pattern = boxer_graph.get_pattern_4_split_candidate(split_tuple)
split_feature = split_pattern
return split_feature
def get_drop_ood_feature(self, ood_node, nodese... |
def create_RepVGG_B1g2(last_stride, norm_type):
return RepVGG(last_stride, norm_type, num_blocks=[4, 6, 16, 1], width_multiplier=[2, 2, 2, 4], override_groups_map=g2_map) |
class ResNetGenerator(torch.nn.Module):
def __init__(self, ch=64, dim_z=128, bottom_width=4, activation=torch.nn.functional.relu, n_classes=0):
super().__init__()
self.bottom_width = bottom_width
self.activation = activation
self.dim_z = dim_z
self.n_classes = n_classes
... |
class RoIAlignAvg(Module):
def __init__(self, aligned_height, aligned_width, spatial_scale):
super(RoIAlignAvg, self).__init__()
self.aligned_width = int(aligned_width)
self.aligned_height = int(aligned_height)
self.spatial_scale = float(spatial_scale)
def forward(self, features,... |
def plot_data(ax, alg, mean_lc, mean_stderr, best_params, exp_attrs, second_time=False, is_smoothed=False, smoothing_window=1):
zoomed_in = (True if is_smoothed else False)
alpha = 1.0
if PLOT_RERUN_AND_ORIG:
alpha = (1.0 if second_time else 0.5)
print(alg)
lbl = ((((alg + '$\\alpha=$ ') + s... |
class ChannelGrouping():
def __init__(self, prunable_nodes: List[BaseNode], fw_info: FrameworkInfo):
self.prunable_nodes = prunable_nodes
self.fw_info = fw_info
self._simd_groups_indices = {}
def simd_groups_indices(self) -> Dict[(BaseNode, List[np.ndarray])]:
return self._simd_g... |
def _certifi_where():
try:
return __import__('certifi').where()
except (ImportError, ResolutionError, ExtractionError):
pass |
def get_sparse_graph(graph):
return nx.to_scipy_sparse_matrix(graph, format='csr', dtype=float, nodelist=graph.nodes) |
class RowStandardTableauTuples_residue_shape(RowStandardTableauTuples_residue):
def __init__(self, residue, shape):
if (residue.size() != shape.size()):
raise ValueError('the size of the shape and the length of the residue defence must coincide!')
super().__init__(residue)
self._... |
def text_preprocessor(t, tokenize=False):
tokens = tokenizer.tokenize(cleaning(normalizer.normalize(t)))
return (tokens if tokenize else ' '.join(tokens)) |
def init(rng: jax.random.KeyArray) -> State:
(rng1, rng2, rng3, rng4, rng5, rng6) = jax.random.split(rng, num=6)
hand = jnp.arange(0, 52)
hand = jax.random.permutation(rng2, hand)
vul_NS = jax.random.choice(rng3, jnp.bool_([False, True]))
vul_EW = jax.random.choice(rng4, jnp.bool_([False, True]))
... |
class DetectionMetricDataList():
def __init__(self):
self.md = {}
def __getitem__(self, key):
return self.md[key]
def __eq__(self, other):
eq = True
for key in self.md.keys():
eq = (eq and (self[key] == other[key]))
return eq
def get_class_data(self, d... |
def get_degree(entity: str):
degree = 0
query1 = ((('\n PREFIX rdf: < PREFIX rdfs: < PREFIX : < \n SELECT count(?x0) as ?value WHERE {\n ?x1 ?x0 ' + ':') + entity) + '. \n FILTER regex(?x0, " }\n ')
sparql.setQuery(query1)
try:
r... |
class Up(nn.Module):
def __init__(self, in_channels, out_channels, scale_factor=2):
super().__init__()
self.up = nn.Upsample(scale_factor=scale_factor, mode='bilinear', align_corners=True)
self.conv = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False), n... |
def train_step(original_sql, model_image, estimator_string, datasource, select, validation_select, model_params, train_params, validation_params, feature_column_map, label_column, save, load=None, pai_table=None, pai_val_table=None):
if (model_params is None):
model_params = {}
if (train_params is None)... |
_MASK_PREDICTOR.register('MaskRCNNConv1x1Predictor')
class MaskRCNNConv1x1Predictor(nn.Module):
def __init__(self, cfg, in_channels):
super(MaskRCNNConv1x1Predictor, self).__init__()
num_classes = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
num_inputs = in_channels
self.mask_fcn_logits = Conv... |
def state2img(input_nc=3, output_nc=3, ngf=32, n_down=6, norm='batch', use_dropout=False, init_type='normal', init_gain=0.02, gpu_id='cuda:0'):
norm_layer = get_norm_layer(norm_type=norm)
net = ImgGenerator(input_nc, output_nc, ngf, n_down, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=9)
return ... |
def modify_frame_indices(video_dir_path, frame_indices):
modified_indices = []
for i in frame_indices:
image_path = os.path.join(video_dir_path, 'image_{:05d}.jpg'.format(i))
if (not os.path.exists(image_path)):
return modified_indices
modified_indices.append(i)
return mo... |
def upd_params(old: dict, new: dict) -> dict:
for k in new:
if ((type(new[k]) is dict) and (k in old) and (type(old[k]) is dict)):
upd_params(old[k], new[k])
else:
old[k] = new[k]
return old |
class _CopyToModelParallelRegion(torch.autograd.Function):
def forward(ctx, input_):
return input_
def backward(ctx, grad_output):
return _reduce(grad_output) |
def inconsistent_item_full_pandas_dataset():
events = pd.DataFrame({'user_id': [0, 0, 1, 1, 1, 2], 'item_id': [0, 1, 0, 2, 3, 5], 'timestamp': [0, 1, 2, 3, 4, 5], 'rating': [1.1, 1.2, 1.3, 2, 3, 4]})
users = pd.DataFrame({'user_id': [0, 1, 2], 'gender': [0, 1, 0]})
items = pd.DataFrame({'item_id': [0, 1, 2,... |
class Function_sinh_integral(BuiltinFunction):
def __init__(self):
BuiltinFunction.__init__(self, 'sinh_integral', nargs=1, latex_name='\\operatorname{Shi}', conversions=dict(maxima='expintegral_shi', sympy='Shi', fricas='Shi'))
def _eval_(self, z):
if isinstance(z, Expression):
if z... |
def test_ufunc_add_reduce_simple():
A = np.random.randint(1, 10, size=(10,), dtype=np.int32)
s = ufunc_add_reduce_simple(A)[0]
assert np.array_equal(np.add.reduce(A), s) |
def get_char_vocab_language(language):
get_char_vocab(['{}.{}.jsonlines'.format(partition, language) for partition in ('train', 'dev', 'test')], 'char_vocab.{}.txt'.format(language)) |
class EnergyScoring(Model):
def __init__(self, model: Model, temperature: float=1.0):
super().__init__(None)
self.model = model
self.temp = temperature
def forward(self, data: Data) -> Prediction:
return self.forward_impl(data)
def forward_impl(self, data) -> Prediction:
... |
def test_rmul():
value = 42
proxy = tt.ObjectProxy(value)
assert ((2 * value) == (2 * proxy))
assert (int in tt.UsageTraceNode.from_proxy(proxy).children['__rmul__'].arg_types[0]) |
class MemoryEfficientFP16Optimizer(optim.FairseqOptimizer):
def __init__(self, args, params, optimizer):
if (not optimizer.supports_memory_efficient_fp16):
raise ValueError('Unsupported optimizer: {}'.format(optimizer.__class__.__name__))
super().__init__(args)
self.wrapped_optim... |
.parametrize('loss_type', ['logistic', 'softmax'])
def test_FM(loss_type):
model_name = 'FM'
(x, y, user_feature_columns, item_feature_columns) = get_xy_fd(False)
if (tf.__version__ >= '2.0.0'):
tf.compat.v1.disable_eager_execution()
else:
K.set_learning_phase(True)
if (loss_type == ... |
def learning_proposal(n=100):
scale = np.random.choice([0.5, 1, 1.5, 2], 1)
return (((np.random.standard_normal() * scale) / np.sqrt(n)) + observed_target) |
def calculate_parameters(model):
return (sum((param.numel() for param in model.parameters())) / 1000000.0) |
def merge_dicts(dict_old: Dict[(Any, List[float])], dict_new: Dict[(Any, List[float])], op=min) -> Dict[(Any, List[float])]:
d_out = {**dict_old}
for (k, v) in dict_new.items():
if (k in dict_old):
d_out[k] = [op(new, old) for (old, new) in zip(dict_new[k], dict_old[k])]
else:
... |
_utils.test()
def test_running_loss():
return
steps = 16
total_loss = ti.field(ti.f32)
running_loss = ti.field(ti.f32)
additional_loss = ti.field(ti.f32)
ti.root.place(total_loss)
ti.root.dense(ti.i, steps).place(running_loss)
ti.root.place(additional_loss)
ti.root.lazy_grad()
de... |
class Logger():
def __init__(self):
self.loss_dict = OrderedDict()
self.acc_dict = OrderedDict()
self.result_dict = OrderedDict()
self.log_dict = OrderedDict()
self.log = []
def loss_update(self, loss_dict):
for (k, v) in loss_dict.items():
if (k not i... |
def prep_plt():
plt.rc('font', size=MEDIUM_SIZE)
plt.rc('axes', labelsize=LARGE_SIZE)
plt.rc('xtick', labelsize=MEDIUM_SIZE)
plt.rc('ytick', labelsize=MEDIUM_SIZE)
plt.rc('legend', fontsize=SMALL_SIZE)
plt.style.use('seaborn-muted')
spine_alpha = 0.5
plt.gca().spines['right'].set_alpha(0... |
def compute_IoU(preds, labels, num_classes, ignore_index=None):
hist = confusion_matrix(preds, labels, num_classes)
return compute_IoU_from_cmatrix(hist, ignore_index) |
def trieste_deep_ensemble_model(example_data: Dataset, ensemble_size: int, bootstrap_data: bool=False, independent_normal: bool=False) -> Tuple[(DeepEnsemble, KerasEnsemble, KerasOptimizer)]:
keras_ensemble = trieste_keras_ensemble_model(example_data, ensemble_size, independent_normal)
optimizer = tf.keras.opti... |
def _random_queries(df: pd.DataFrame, n_queries: int, n_cols: int) -> List[str]:
random_columns = [rng.choice(df.columns, size=n_cols, replace=False).tolist() for _ in range(n_queries)]
unique_values = {col: df[col].unique() for col in df.columns}
queries: List[str] = [_random_query(unique_values=unique_val... |
def generate_random_basis(n_points=1000, n_dims=3, radius=1.0, random_seed=13):
np.random.seed(random_seed)
x = np.random.normal(size=[n_points, n_dims])
x_norms = np.sqrt(np.sum(np.square(x), axis=1)).reshape([(- 1), 1])
x_unit = (x / x_norms)
r = np.random.uniform(size=[n_points, 1])
u = np.po... |
def convert(input, output):
img = np.asarray(Image.open(input))
assert (img.dtype == np.uint8)
img = (img - 1)
Image.fromarray(img).save(output) |
def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, uns... |
def main():
global best_prec
global opt
if (opt['id'] != ''):
model_id = opt['id']
else:
model_id = time.strftime('%m_%d_%H-%M-%S')
sys.stdout = Logger(osp.join(opt['log_dir'], (('log.' + model_id) + '.txt')))
checkpoint_dir = osp.join(opt['checkpoint_dir'], model_id)
mkdir_i... |
def ms_ssim(X, Y, data_range=255, size_average=True, win_size=11, win_sigma=1.5, win=None, weights=None, K=(0.01, 0.03)):
if (not (X.shape == Y.shape)):
raise ValueError('Input images should have the same dimensions.')
for d in range((len(X.shape) - 1), 1, (- 1)):
X = X.squeeze(dim=d)
Y ... |
class SetPartitionsSk_k(SetPartitionsAk_k):
def _repr_(self):
return (SetPartitionsAk_k._repr_(self) + (' with propagating number %s' % self.k))
def __contains__(self, x):
if (not SetPartitionsAk_k.__contains__(self, x)):
return False
if (propagating_number(x) != self.k):
... |
class Decoder(nn.Module):
def __init__(self):
super(Decoder, self).__init__()
self.layer13 = nn.Sequential(nn.Conv2d(128, 128, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(128, 128, kernel_size=3, padding=1))
self.layer14 = nn.Sequential(nn.Conv2d(128, 128, kernel_size=3, padding=1), nn.R... |
class TensorRef():
def __init__(self, pointer=None, layout=0):
self.pointer = pointer
self.layout = layout
def __str__(self):
return ('(%x, %d)' % (self.pointer._ptr, self.layout)) |
class SampledHeterogeneousBreadthFirstWalk(GraphWalk):
def run(self, nodes, n_size, n=1, seed=None):
self._check_sizes(n_size)
self._check_common_parameters(nodes, n, len(n_size), seed)
(rs, _) = self._get_random_state(seed)
adj = self.get_adjacency_types()
walks = []
... |
def bert_config():
bert_config = AutoConfig.from_pretrained(BERT_MODEL_NAME)
bert_config.hidden_dropout_prob = 0.0
return bert_config |
class TextEncoder(object):
def __init__(self, encoder_path, bpe_path):
self.nlp = spacy.load('en', disable=['parser', 'tagger', 'ner', 'textcat'])
self.encoder = json.load(open(encoder_path))
self.decoder = {v: k for (k, v) in self.encoder.items()}
merges = open(bpe_path, encoding='u... |
def get_world_size():
assert torch.distributed.deprecated._initialized
return torch._C._dist_get_num_processes() |
class CaptionGenerator(object):
def __init__(self, model, vocab, beam_size=3, max_caption_length=20, length_normalization_factor=0.0):
self.vocab = vocab
self.model = model
self.beam_size = beam_size
self.max_caption_length = max_caption_length
self.length_normalization_facto... |
def main(settings):
print('start processig with settings', settings)
utils.set_seed(settings['seed'])
global elapsed_time
logdir = os.path.join(settings['logdir'], settings['method'], settings['dataset'], utils.get_runname(settings))
pathlib.Path(logdir).mkdir(parents=True, exist_ok=True)
train_... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--filelist', type=str, help='list of nii files')
parser.add_argument('--file', type=str, help='single nii file, if given, filelist will be ignored')
parser.add_argument('--outputdir', type=str, help='folder to store result')
parser.... |
def pre_caption(caption, max_words):
caption = re.sub('([,.\'!?\\"()*#:;~])', '', caption.lower()).replace('-', ' ').replace('/', ' ').replace('<person>', 'person')
caption = re.sub('\\s{2,}', ' ', caption)
caption = caption.rstrip('\n')
caption = caption.strip(' ')
caption_words = caption.split(' '... |
def get_iterator(args):
with open((osp.join(args.data, args.split) + '.tsv'), 'r') as fp:
lines = fp.read().split('\n')
root = lines.pop(0).strip()
files = [osp.join(root, line.split('\t')[0]) for line in lines if (len(line) > 0)]
num = len(files)
reader = Wav2VecFeatureReade... |
def test_multiple_inheritance_cpp():
mt = m.MIType(3, 4)
assert (mt.foo() == 3)
assert (mt.bar() == 4) |
class FixedResize(object):
def __init__(self, size):
self.size = tuple(reversed(size))
def __call__(self, sample):
img = sample['image']
mask = sample['label']
assert (img.size == mask.size)
img = img.resize(self.size, Image.BILINEAR)
mask = mask.resize(self.size,... |
class MocHRBackbone(object):
def __init__(self, configer):
self.configer = configer
def __call__(self):
arch = self.configer.sub_arch
from lib.models.backbones.hrnet.hrnet_config import MODEL_CONFIGS
if (arch in ['hrnet32', 'hrnet48', 'hrnet64']):
arch_net = HighResol... |
_metric
def fid50k_realtrans(opts):
opts.dataset_kwargs.update(max_size=None, xflip=False)
fid = frechet_inception_distance.compute_fid_realtrans(opts, max_real=None, num_gen=50000)
return dict(fid50k_realtrans=fid) |
def _nanmedian_small(a, axis=None, out=None, overwrite_input=False):
a = np.ma.masked_array(a, np.isnan(a))
m = np.ma.median(a, axis=axis, overwrite_input=overwrite_input)
for i in range(np.count_nonzero(m.mask.ravel())):
warnings.warn('All-NaN slice encountered', RuntimeWarning, stacklevel=4)
i... |
class StyleContentModel_style(tf.keras.models.Model):
def __init__(self, style_layers, content_layers, rotation_weight):
super(StyleContentModel_style, self).__init__()
self.vgg = vgg_layers((style_layers + content_layers))
self.style_layers = style_layers
self.content_layers = conte... |
def runKoG2P(graph, rulebook):
[rule_in, rule_out] = readRules(ver_info[0], rulebook)
if (ver_info[0] == 2):
prono = graph2prono(unicode(graph), rule_in, rule_out)
elif (ver_info[0] == 3):
prono = graph2prono(graph, rule_in, rule_out)
print(prono) |
.parametrize('n_player', [2, 4])
def test_payoff_table(n_player: int):
agents = [f'player_{i}' for i in range(n_player)]
shape = ([0] * n_player)
simulation_flag = SimulationFlag(np.zeros(shape).astype(bool))
table = PayoffTable(identify=agents[0], agents=agents, shared_simulation_flag=simulation_flag)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.