code stringlengths 101 5.91M |
|---|
def test_isotonic_calibration_fit_predict():
x_train = np.array([[1, 1], [2, 3.5]])
y_train = np.array([[0.9, 0.1], [0.2, 0.8]])
ic = IsotonicCalibration()
assert (len(ic.regressors) == 0)
ic.fit(x_train=x_train, y_train=y_train)
assert (ic.n_classes == 2)
x_test = np.array([[0, 1]])
y_p... |
class TestSimpleDB(unittest.TestCase):
def setUpClass(cls):
cls.sdb = SimpleDB()
cls.sdb.set_db('test_files/db.yaml')
def setUp(self):
self.new_db = TestSimpleDB.sdb
def test_get_order_status(self):
res = self.new_db.get_order_status(1)
self.assertEqual(res, 'placed b... |
def run(args, graph, feat, labels, train_idx, val_idx, test_idx, n_running):
model = gen_model(args)
model = model.to(device)
TRAIN_NUMBERS = sum([np.prod(p.size()) for p in model.parameters() if p.requires_grad])
print(f'Number of params: {TRAIN_NUMBERS}')
optimizer = optim.AdamW(model.parameters()... |
class GreedyRTSPlayer():
def __init__(self, game):
self.game = game
def play(self, board):
valids = self.game.getValidMoves(board, 1)
print('sum valids', sum(valids))
candidates = []
for a in range(self.game.getActionSize()):
if (valids[a] == 0):
... |
.parametrize('dt,n', [(ti.i8, 8), (ti.u8, 8), (ti.i16, 16), (ti.u16, 16), (ti.i32, 32), (ti.u32, 32)])
_utils.test(exclude=[ti.opengl, ti.gles, ti.vulkan, ti.dx11])
def test_overflow(dt, n):
_test_overflow(dt, n) |
def add_export_config(cfg):
is_frozen = cfg.is_frozen()
cfg.defrost()
cfg.EXPORT_CAFFE2 = CfgNode()
cfg.EXPORT_CAFFE2.USE_HEATMAP_MAX_KEYPOINT = False
if is_frozen:
cfg.freeze()
return cfg |
def test_build_gaussian_pyramid_gray():
(rows, cols) = image_gray.shape
pyramid = pyramids.pyramid_gaussian(image_gray, downscale=2, channel_axis=None)
for (layer, out) in enumerate(pyramid):
layer_shape = ((rows / (2 ** layer)), (cols / (2 ** layer)))
assert_array_equal(out.shape, layer_sha... |
def register_optimizer_builder(name, builder):
if (name in _OPTIMIZER_BUILDERS):
raise KeyError('Duplicate keys for {:s} with {} and {}.Solve key conflicts first!'.format(name, _OPTIMIZER_BUILDERS[name], builder))
_OPTIMIZER_BUILDERS[name] = builder |
class AlgebraicScheme_subscheme_projective_field(AlgebraicScheme_subscheme_projective):
def _morphism(self, *args, **kwds):
return SchemeMorphism_polynomial_projective_subscheme_field(*args, **kwds)
def Chow_form(self):
I = self.defining_ideal()
P = self.ambient_space()
R = P.coo... |
def segment_window_test(x_test, y_test, window_size, n_sensor_val):
segments = np.zeros((((len(x_test) // window_size) + 1), window_size, n_sensor_val))
labels = np.zeros(((len(y_test) // window_size) + 1))
i_segment = 0
i_label = 0
for (start, end) in windowz(x_test, window_size, use_overlap=False)... |
def test_convert_units_file(tokenizer):
with tempfile.TemporaryDirectory(dir=TEST_WORKING_DIR) as test_dir:
labels = '\n\n000\n\n'
raw_text = 'This is a test.\n\nfoo\n\n'
(txt_file, label_file) = write_tokenizer_input(test_dir, raw_text, labels)
batches = DataLoader(tokenizer.co... |
def translate_strips_operator_aux(operator, dictionary, ranges, mutex_dict, mutex_ranges, implied_facts, condition):
effects_by_variable = defaultdict((lambda : defaultdict(list)))
add_conds_by_variable = defaultdict(list)
for (conditions, fact) in operator.add_effects:
eff_condition_list = translat... |
('Sigmoid')
def TranslateSigmoid(layer, pretrained_blobs, is_test, **kwargs):
caffe_op = BaseTranslate(layer, 'Sigmoid')
return (caffe_op, []) |
def create_branch_coverage_fitness_functions(executor: AbstractTestCaseExecutor, branch_goal_pool: BranchGoalPool) -> OrderedSet[BranchCoverageTestFitness]:
return OrderedSet([BranchCoverageTestFitness(executor, goal) for goal in branch_goal_pool.branch_coverage_goals]) |
class TransformerConfig(object):
def __init__(self, hidden_size: int=768, num_hidden_layers: int=3, num_attention_heads: int=12, intermediate_size: int=3072, hidden_act: str='gelu', hidden_dropout_prob: float=0.1, attention_probs_dropout_prob: float=0.1, initializer_range: float=0.02, layer_norm_eps: float=1e-12, s... |
def test_check_sampling_strategy_error():
with pytest.raises(ValueError, match="'sampling_type' should be one of"):
check_sampling_strategy('auto', np.array([1, 2, 3]), 'rnd')
error_regex = "The target 'y' needs to have more than 1 class."
with pytest.raises(ValueError, match=error_regex):
c... |
class TestCensoredData():
def test_basic(self):
uncensored = [1]
left = [0]
right = [2, 5]
interval = [[2, 3]]
data = CensoredData(uncensored, left=left, right=right, interval=interval)
assert_equal(data._uncensored, uncensored)
assert_equal(data._left, left)
... |
_config
def task_finetune_tgifqa():
exp_name = 'finetune_tgif_qa'
datasets = ['tgif']
loss_names = _loss_names({'openend_vqa': 1})
batch_size = 512
msrvttqa_label_size = 1541
max_epoch = 20
max_steps = None
warmup_steps = 0.1
draw_false_image = 0
learning_rate = 0.0001
val_ch... |
_torch
_sentencepiece
_tokenizers
class TrainerIntegrationPrerunTest(TestCasePlus, TrainerIntegrationCommon):
def setUp(self):
super().setUp()
args = TrainingArguments('.')
self.n_epochs = args.num_train_epochs
self.batch_size = args.train_batch_size
trainer = get_regression_... |
def register_Ns3HeCapabilities_methods(root_module, cls):
cls.add_output_stream_operator()
cls.add_constructor([param('ns3::HeCapabilities const &', 'arg0')])
cls.add_constructor([])
cls.add_method('DeserializeInformationField', 'uint8_t', [param('ns3::Buffer::Iterator', 'start'), param('uint8_t', 'leng... |
class CONV_AE(nn.Module):
def __init__(self, input_dims, encoding_dim, kernel, stride, in_channels=1, h_channels=[1]):
super(CONV_AE, self).__init__()
conv_dim = len(input_dims)
all_channels = ([in_channels] + h_channels)
num_layers = (len(all_channels) - 1)
if isinstance(ker... |
def register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::DownlinkLteGlobalPathlossDatabase const &', 'arg0')])
cls.add_method('UpdatePathloss', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::SpectrumPhy >', 'txPhy'... |
def possible_mu0s(SUK, v):
beta_and_ns = [[beta, beta.valuation(v)] for beta in SUK.fundamental_units()]
(betak, nk) = beta_k(beta_and_ns)
ns = [beta[1] for beta in beta_and_ns if (beta[0] != betak)]
betas = [beta[0] for beta in beta_and_ns if (beta[0] != betak)]
mu0s = []
for rs in combinations... |
def calc_kl_scaler_by_batch(batch_num, min_kl, max_kl, batches_to_anneal_over):
kl_scaler = ((1.0 * batch_num) / batches_to_anneal_over)
kl_scaler = min(kl_scaler, max_kl)
return kl_scaler |
def experiment(args):
logger = TensorBoardLogger(save_dir=args.save_dir, version=args.model_name, name=None)
lr_logger = LearningRateLogger()
checkpoint_callback = MyModelCheckpoint(verbose=True, save_top_k=1, period=(- 1), save_last=True, prefix='lm_')
early_stop_callback = EarlyStopping(monitor='val_l... |
class AttentionDecoderOutput(namedtuple('DecoderOutput', ['logits', 'predicted_ids', 'cell_output', 'attention_scores', 'attention_context'])):
pass |
def test_sorted_slice_sampler():
batch_size = 16
max_length = (16000 * 5)
lengths = [random.randint((16000 * 3), (16000 * 8)) for index in range(1000)]
sampler = SortedSliceSampler(lengths, batch_size=batch_size, max_length=max_length)
for epoch in range(5):
sampler.set_epoch(epoch)
... |
def test_raises_when_source_is_sink():
with pytest.raises(ValueError):
graph = csr_matrix([[0, 1], [0, 0]])
maximum_flow(graph, 0, 0)
maximum_flow(graph, 0, 0, method='edmonds_karp') |
def combine_bc(a: Tensor, kind: str, b: Tensor, *, dim_order: Optional[Sequence[Dim]]=None) -> Tensor:
return combine(a, kind, b, allow_broadcast_all_sources=True, dim_order=dim_order) |
def get_class_labels(data):
class_labels_map = {}
index = 0
for class_label in data['labels']:
class_labels_map[class_label] = index
index += 1
return class_labels_map |
def inference_segmentor_panoptic(model, img):
cfg = model.cfg
device = next(model.parameters()).device
test_pipeline = ([LoadImage()] + cfg.data.test['pipeline'][1:])
test_pipeline = Compose(test_pipeline)
data = dict(img=img)
data = test_pipeline(data)
data = collate([data], samples_per_gpu... |
def _find_parent_directory_containing(base: Path, target: str, predicate) -> Optional[str]:
resolved_base: str = base.resolve(strict=False)
for candidate_directory in itertools.chain([resolved_base], resolved_base.parents):
candidate_path = (candidate_directory / target)
try:
if pred... |
class CppEnum(EnumBuilder, CppBase):
def string_cast_type(self):
storage_name = str(self.storage_type)
return {'int8_t': 'int16_t'}.get(storage_name, storage_name) |
class Communication():
def __init__(self, vehicle_id):
self.vehicle_type = 'rover'
self.vehicle_id = vehicle_id
self.local_pose = None
self.target_motion = PositionTarget()
self.arm_state = False
self.motion_type = 0
self.flight_mode = None
self.missio... |
def main():
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0', '--caffe2_gpu_memory_tracking=1'])
logger = setup_logging(__name__)
logging.getLogger('detectron.roi_data.loader').setLevel(logging.INFO)
args = parse_args()
logger.info('Called with args:')
logger.info(args)
if (args.cfg_fi... |
class RegressionErrorsTest(TestCase):
y = np.array([0.0, 0.1, 1.0, 0.5, 0.1, 0.1, 0.0, 0.5]).reshape((- 1), 1)
y_hat = np.array([0.1, 2.0, 0.5, 0.0, 3.0, 0.1, 5.0, 0.5]).reshape((- 1), 1)
def _run(self, smoothing_window, smooth, expected):
sequences = regression_errors(self.y, self.y_hat, smoothing_... |
class RandomHorizontalFlip(object):
def __call__(self, img):
if (random.random() < 0.5):
return img.transpose(Image.FLIP_LEFT_RIGHT)
return img |
def _setup_learning_rate(config, global_step):
if (config.learning_rate_decay_factor > 0):
learning_rate = tf.train.exponential_decay(learning_rate=float(config.learning_rate), global_step=global_step, decay_steps=config.learning_rate_decay_steps, decay_rate=config.learning_rate_decay_factor, staircase=Fals... |
def random(mode='RGB'):
from random import randint
palette = []
for i in range((256 * len(mode))):
palette.append(randint(0, 255))
return ImagePalette(mode, palette) |
def display_checks_statistics(total: dict[(str, dict[((str | Status), int)])]) -> None:
padding = 20
col1_len = (max(map(len, total.keys())) + padding)
col2_len = ((len(str(max(total.values(), key=(lambda v: v['total']))['total'])) * 2) + padding)
col3_len = padding
click.secho('Performed checks:', ... |
def make_unet_encoder_decoder_args(encoder_args, decoder_args):
encoder_args = tuple(((in_chan, out_chan, tuple(kernel_size), tuple(stride), (tuple([(n // 2) for n in kernel_size]) if (padding == 'auto') else tuple(padding)), tuple(dilation)) for (in_chan, out_chan, kernel_size, stride, padding, dilation) in encode... |
def cosine_sim(lf_input, rt_input):
lf_norm = tf.sqrt((tf.reduce_sum((lf_input ** 2), axis=(- 1), keep_dims=True) + 1e-06), name='lf_norm')
lf_norm_hidden = tf.div(lf_input, lf_norm, name='lf_norm_hidden')
rt_norm = tf.sqrt((tf.reduce_sum((rt_input ** 2), axis=(- 1), keep_dims=True) + 1e-06), name='rt_norm'... |
class HostAPICodegen():
_output_path = ''
def __init__(self, output_path: str):
self._output_path = output_path
def generateRoutines(self, routines: List[fblas_routine.FBLASRoutine]):
routine_id = 0
json_routines = []
for r in routines:
print(('Generating: ' + r.u... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [313])
.parametrize('num_groups', [2, 3])
.parametrize('x_shape , batch_axis, channel_axis', [((2, 6, 3, 3), 0, 1), ((2, 3, 3, 6), 0, 3), ((8, 6), 0, 1), ((4, 3, 6), [0, 1], 2), ((4, 3, 6), [0, (- 2)], (- 1))])
.parametrize('eps', [1e-05])
.parametrize('output_s... |
class Seq2SeqModel(BaseModel):
def set_src_vocab_size(self, vocab_size):
self._src_vocab_size = vocab_size
def set_tgt_vocab_size(self, vocab_size):
self._tgt_vocab_size = vocab_size
def set_max_src_len(self, l):
self._max_src_len = l
def set_max_tgt_len(self, l):
self._m... |
def split_vertex(G, u, v=None, edges=None):
if (v is None):
v = G.add_vertex()
elif (v not in G):
G.add_vertex(v)
elif G.degree(v):
raise ValueError('v must be a new vertex or an isolated vertex')
if (edges is None):
edges = []
edges_on_u = G.edges_incident(u)
for... |
def calculate_fid(mu1, sigma1, mu2, sigma2, eps=1e-06):
assert (mu1.shape == mu2.shape), 'Two mean vectors have different lengths'
assert (sigma1.shape == sigma2.shape), 'Two covariances have different dimensions'
(cov_sqrt, _) = linalg.sqrtm((sigma1 sigma2), disp=False)
if (not np.isfinite(cov_sqrt).a... |
def get_env_module() -> Tuple[str]:
var_name = 'ENV_MODULE'
return (var_name, os.environ.get(var_name, '<not set>')) |
.parametrize('data_dict', [pytest.param('full_spark_dataset', marks=pytest.mark.spark), pytest.param('full_pandas_dataset', marks=pytest.mark.core)])
def test_feature_schema_schema_dict(data_dict, request):
dataset = create_dataset(request.getfixturevalue(data_dict))
assert (dataset.feature_schema.items() is no... |
def ratio_iou(x1, y1, w1, h1, x2, y2, w2, h2, eps=1e-05):
xi = torch.max(x1, x2)
yi = torch.max(y1, y2)
wi = torch.clamp((torch.min((x1 + w1), (x2 + w2)) - xi), min=0)
hi = torch.clamp((torch.min((y1 + h1), (y2 + h2)) - yi), min=0)
area_i = (wi * hi)
area_u = (((w1 * h1) + (w2 * h2)) - (wi * hi)... |
def _ntuple(n):
def parse(x):
if isinstance(x, container_abcs.Iterable):
return x
return tuple(repeat(x, n))
return parse |
def test_intglobal():
some_glob = 124
def func(A):
var = some_glob
tmp = 1
for it in range(100):
if ((123 == it) or (it == (var - 1))):
tmp = 0
A[...] = tmp
func(np.empty((10,))) |
(name='start')
('-p', '--plan', required=False, help='Federated learning plan [plan/plan.yaml]', default='plan/plan.yaml', type=ClickPath(exists=True))
('-c', '--authorized_cols', required=False, help='Authorized collaborator list [plan/cols.yaml]', default='plan/cols.yaml', type=ClickPath(exists=True))
('-s', '--secur... |
def aux_models(in_channels, num_domains, num_classes, layers_dis=[], layers_cls=[]):
dis_model = DisNet(in_channels, num_domains, layers_dis)
c_model = ClsNet(in_channels, num_domains, num_classes, reverse=False, layers=layers_cls)
cp_model = ClsNet(in_channels, num_domains, num_classes, reverse=True, layer... |
def GenerateSM80_TensorOp_1688(manifest, cuda_version):
if (not CudaToolkitVersionSatisfies(cuda_version, 11, 0)):
return
layouts = [(LayoutType.ColumnMajor, LayoutType.ColumnMajor, LayoutType.ColumnMajor), (LayoutType.ColumnMajor, LayoutType.RowMajor, LayoutType.ColumnMajor), (LayoutType.RowMajor, Layo... |
def check_prior_BO_limit(prior):
df = simple_run_experiments(get_prior_BO_limit, prior=prior, mx_hat=np.linspace(1, 3, 10), tx0_hat=1.0)
return df |
class EpicFHIRGetPatientDetails(VirtualFunctionTool):
name = 'EpicFHIRGetPatientDetails'
summary = 'Retrieve patient demographics and clinical data, such as medications, allergies, and conditions.'
parameters: List[ArgParameter] = [{'name': 'patient_id', 'type': 'string', 'description': 'The unique identifi... |
class ImgGenerator(nn.Module):
def __init__(self, opt=None, input_nc=3, output_nc=3, ngf=32, n_down=6, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=9, padding_type='reflect'):
assert (n_blocks >= 0)
super(ImgGenerator, self).__init__()
self.opt = opt
self.state_dim = opt.st... |
class AlternatingBlock():
def __init__(self, var_names, size_per_variable, start_index=0, reverse=False):
self.var_names = var_names
self.size_per_variable = size_per_variable
self.reverse = reverse
indices = range(start_index, (start_index + size_per_variable))
if reverse:
... |
class TestBatchMomentsOp(serial.SerializedTestCase):
def batch_moments_nchw_ref(self, X):
dims = X.shape
N = dims[0]
C = dims[1]
X = X.reshape(N, C, (- 1))
mu = np.mean(X, axis=(0, 2))
var = np.mean(np.square(X), axis=(0, 2))
return [mu, var]
def batch_mom... |
def kl_loss_gaussian(mu1, mu2, sigma1, sigma2):
with tf.name_scope('KL_loss'):
return ((tf.log(tf.clip_by_value((sigma2 / sigma1), 1e-06, 1000000.0)) + (((sigma1 ** 2) + ((mu1 - mu2) ** 2)) / (2 * (sigma2 ** 2)))) - 0.5) |
class SymplecticFormParal(SymplecticForm, DiffFormParal):
_poisson: TensorFieldParal
def __init__(self, manifold: Union[(VectorFieldModule, DifferentiableManifold)], name: Optional[str], latex_name: Optional[str]=None):
try:
vector_field_module = manifold.vector_field_module()
except... |
class DropExecutor(ActionExecutor):
def execute(self, script: Script, state: EnvironmentState, info: ExecutionInfo):
current_line = script[0]
info.set_current_line(current_line)
node = state.get_state_node(current_line.object())
if (node is None):
info.object_found_error(... |
def get_config_list(ranking, ckpt_path2is_3class):
config_list = []
for (ckpt_path, value) in ranking:
is3_class = ckpt_path2is_3class[ckpt_path]
ckpt_info = {'ckpt_path': str(ckpt_path), 'is_3class': is3_class, 'value': value}
config_list.append(ckpt_info)
return config_list |
class CountNode(ASTNode):
def __init__(self, data_type, fields):
super().__init__('COUNT', 'COUNT', data_type, fields)
def textual_form_core(self):
return ('how many ' + self.fields[0].textual_form()) |
def load_pkl(filename: Path) -> Dict[(str, np.ndarray)]:
with open(filename, 'rb') as f:
return pickle.load(f) |
(frozen=True)
class PDistMetricWrapper():
metric_name: str
def __call__(self, X, *, out=None, **kwargs):
X = np.ascontiguousarray(X)
(m, n) = X.shape
metric_name = self.metric_name
metric_info = _METRICS[metric_name]
(X, typ, kwargs) = _validate_pdist_input(X, m, n, metri... |
def train_segmentor(model, dataset, cfg, distributed=False, validate=False, timestamp=None, meta=None):
logger = get_root_logger(cfg.log_level)
dataset = (dataset if isinstance(dataset, (list, tuple)) else [dataset])
data_loaders = [build_dataloader(ds, cfg.data.samples_per_gpu, cfg.data.workers_per_gpu, le... |
def count_arithmetic_ops_state(state: dace.SDFGState, symbols: Dict[(str, Any)]) -> int:
global INDENT
stree_root = state.scope_tree()[None]
sdict = state.scope_dict(node_to_children=True)
result = 0
def traverse(scope: Scope) -> int:
global INDENT
result = 0
repetitions = 1
... |
def module_cppgen(parser: argparse.ArgumentParser):
parser.add_argument('MODOLE', help='Path to the module directory.')
parser.add_argument('-n', '--namespace', type=str, help='C++ namespace if wanted.')
parser.add_argument('-m', '--module-name', type=str, help="Module name to be a part of the module class.... |
def write_supported_languages(path):
languages = sorted([lang_ontology['language'] for lang_ontology in ONTOLOGY])
table = _build_supported_languages_table(languages)
content = ((LANGUAGES_DOC_HEADER + table) + LANGUAGES_DOC_FOOTER)
with path.open(mode='w') as f:
f.write(content) |
def read_hyperparameter_grid(method: str) -> pd.DataFrame:
with open(GRID_SEARCH_JSON, 'r', encoding='utf-8') as file:
all_grids = json.load(file)
if (method not in all_grids):
raise ValueError(f'No available hyperparameter grid for {method} in {str(GRID_SEARCH_JSON)}.')
grid = all_grids[met... |
def LF_history_of(span):
rgx = '\\bfamily (history of|hx)'
text = get_left_span(span, span.sentence, window=6).text
return (OTHER if re.search(rgx, text.strip(), re.I) else ABSTAIN) |
class LinearAssignment(Benchmark):
sizes = range(100, 401, 100)
shapes = [(i, i) for i in sizes]
shapes.extend([(i, (2 * i)) for i in sizes])
shapes.extend([((2 * i), i) for i in sizes])
cost_types = ['uniform', 'spatial', 'logarithmic', 'integer', 'binary']
param_names = ['shape', 'cost_type']
... |
def lrs2pretrain_max_inplen_checker():
maxInpLen = 0
numWords = args['PRETRAIN_NUM_WORDS']
for (root, dirs, files) in os.walk((args['DATA_DIRECTORY'] + '/pretrain')):
for file in files:
if file.endswith('.mp4'):
visualFeaturesFile = (os.path.join(root, file[:(- 4)]) + '.n... |
def compare_optimizer(config, parameters, config_cpu, parameters_cpu, result_array):
loaded_data = {}
for (opt, opt_cpu) in zip(config.optimizers.values(), config_cpu.optimizers.values()):
o = opt.optimizer
o_cpu = opt_cpu.optimizer
opts = [o, o_cpu]
result_name = ("optimizer '%s... |
class GradientAccumulator(object):
def __init__(self):
self._gradients = []
self._accum_steps = None
def step(self):
if (self._accum_steps is None):
self._accum_steps = tf.Variable(tf.constant(0, dtype=tf.int64), trainable=False, synchronization=tf.VariableSynchronization.ON_... |
def sanity_check(state_dict, pretrained_weights, semi_supervised):
if semi_supervised:
print('SKIPPING SANITY CHECK for semi-supervised learning')
return
print("=> loading '{}' for sanity check".format(pretrained_weights))
checkpoint = torch.load(pretrained_weights, map_location='cpu')
s... |
def module_init():
root_module = Module('ns.click', cpp_namespace='::ns3')
return root_module |
class Trainer():
def __init__(self):
self.args = args
self.input_transform = Compose([Resize((512, 512)), ToTensor(), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
self.label_transform = Compose([Resize((512, 512)), CenterCrop(512), ToLabel(), Relabel()])
self.net = model... |
def rebuild_val_unit_col(valid_col_units, val_unit, kmap):
if (val_unit is None):
return val_unit
(unit_op, col_unit1, col_unit2) = val_unit
col_unit1 = rebuild_col_unit_col(valid_col_units, col_unit1, kmap)
col_unit2 = rebuild_col_unit_col(valid_col_units, col_unit2, kmap)
return (unit_op, ... |
def create_tensorkey_dicts(tensor_dict, metric_dict, col_name, round_num, logger, tensor_dict_split_fn_kwargs):
origin = col_name
tags = ('trained',)
output_metric_dict = {}
for (k, v) in metric_dict.items():
tk = TensorKey(k, origin, round_num, True, ('metric',))
output_metric_dict[tk] ... |
class BlockGather(MPINode):
implementations = {'MPI': ExpandBlockGatherMPI}
default_implementation = 'MPI'
subarray_type = properties.Property(dtype=str, default='tmp')
gather_grid = properties.Property(dtype=str, default='tmp')
reduce_grid = properties.Property(dtype=str, allow_none=True, default=N... |
class NimbleInferenceWrapper(EventSynchronizedInferenceWrapperBase):
def __init__(self, model, dummy_input, use_multi_stream):
super(NimbleInferenceWrapper, self).__init__()
self.nimble_model = torch.cuda.Nimble(model)
self.nimble_model.prepare(dummy_input, use_multi_stream=use_multi_stream)... |
class Graph(Model):
def _build_graph(self, inputs):
is_training = get_current_tower_context().is_training
(images, truemap_coded) = inputs
orig_imgs = images
true = truemap_coded[(..., 0)]
true = tf.cast(true, tf.int32)
true = tf.identity(true, name='truemap')
... |
def get_global_memlet_path_src(sdfg: SDFG, state: SDFGState, edge: MultiConnectorEdge) -> nd.Node:
src = state.memlet_path(edge)[0].src
if (isinstance(src, nd.AccessNode) and (not sdfg.arrays[src.data].transient) and (sdfg.parent is not None)):
psdfg = sdfg.parent_sdfg
pstate = sdfg.parent
... |
def load_replay_buffer(agent, load_path=None):
if (agent.config.other_args['env'] in DATASET_NAMES):
dummy_env = gym.make(agent.config.other_args['env'])
dataset = dummy_env.get_dataset()
dummy_env.close()
dataset = (dataset['observations'][:(- 1)], dataset['actions'][:(- 1)], datase... |
def tensor_to_img(tensor, transpose=False):
im = np.asarray(np.clip((np.squeeze(tensor.numpy()) * 255), 0, 255), dtype=np.uint8)
if transpose:
im = im.transpose((1, 2, 0))
return im |
def split_by_parents(self, valid_names: 'ItemList') -> 'ItemLists':
return self.split_by_valid_func((lambda o: (o.parent.name in valid_names))) |
def build_detection_test_loader(cfg, dataset_name, mapper=None):
_add_category_whitelists_to_metadata(cfg)
_add_category_maps_to_metadata(cfg)
_maybe_add_class_to_mesh_name_map_to_metadata([dataset_name], cfg)
dataset_dicts = combine_detection_dataset_dicts([dataset_name], keep_instance_predicate=_get_t... |
def from_config(model, control_params, env):
control_params = control_params.copy()
control_type = control_params.pop('control_type')
return CONTROL_MAP[control_type](model, env, **control_params) |
class MTask(nn.Module):
def __init__(self, vision, audio):
super(MTask, self).__init__()
self.vision = vision
self.audio = audio
self.avc = nn.Sequential(nn.Linear(1024, 128), nn.ReLU(True), nn.Linear(128, 2))
self.class_a = nn.Conv2d(512, 7, 1, bias=False)
self.class... |
def reinit_layer_(layer: torch.nn.Module, nonlinearity='relu'):
for (name, param) in layer.named_parameters():
if name.startswith('bias'):
torch.nn.init.zeros_(param.data)
elif name.startswith('weight'):
if (nonlinearity.lower() in ('relu', 'leaky_relu')):
tor... |
def blink(clip, d_on, d_off):
newclip = copy.copy(clip)
if (newclip.mask is None):
newclip = newclip.with_mask()
D = (d_on + d_off)
newclip.mask = newclip.mask.fl((lambda gf, t: (gf(t) * ((t % D) < d_on))))
return newclip |
def SO(n, R, e=None, var='a', invariant_form=None):
return _OG(n, R, True, e=e, var=var, invariant_form=invariant_form) |
class FloatVector():
x: np.float32
y: np.float32
def to_protobuf(self) -> pb.FloatVector:
vector = pb.FloatVector()
vector.x = self.x
vector.y = self.y
assert vector.IsInitialized()
return vector
def from_protobuf(vector: pb.FloatVector) -> 'FloatVector':
... |
def process_main(device, eval_mode: bool, enable_render: bool, queue):
env = os.environ.copy()
env['CUDA_VISIBLE_DEVICES'] = str(device)
while True:
task = queue.get()
if (len(task) == 0):
break
run_exp(env, eval_mode, enable_render, **task) |
def job_fssdJ1q_med(p, data_source, tr, te, r, J=1, null_sim=None):
if (null_sim is None):
null_sim = gof.FSSDH0SimCovObs(n_simulate=2000, seed=r)
data = (tr + te)
X = data.data()
with util.ContextTimer() as t:
med = util.meddistance(X, subsample=1000)
k = kernel.KGauss((med ** 2... |
(Output('clustering-parsing-param-table', 'children'), Input('parsing-algo-select', 'value'))
def select_parsing_algorithm(algorithm):
param_info = LogPattern().get_parameter_info(algorithm)
param_table = create_param_table(param_info)
return param_table |
def bcs(CG1, geometry):
return cashocs.create_dirichlet_bcs(CG1, Constant(0), geometry.boundaries, [1, 2, 3, 4]) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.