code stringlengths 101 5.91M |
|---|
class Collator(object):
def __init__(self, lthresh=None):
self.lthresh = lthresh
def __call__(self, batch):
(waveforms, targets) = ([], [])
for data in batch:
if (self.lthresh == None):
waveforms += [data['array'].numpy().flatten()]
else:
... |
.parametrize('seed', [412])
.parametrize('batch_size', [2, 16])
.parametrize('grid_size', [2, 8])
.parametrize('feature_size', [4])
.parametrize('m, M', [((- 1), 1)])
def test_query_on_triplane_forward_backward(seed, batch_size, grid_size, feature_size, m, M):
nn.clear_parameters()
ctx = get_extension_context('... |
class BodyDef(BaseDef):
ctype: str = Field(regex='^(application/x-www-form-urlencoded|application/json)$')
content: Dict[(str, FieldDefUnion)] |
def main():
args = _parse_args()
if args.tsv:
(data, discrete_columns) = read_tsv(args.data, args.metadata)
else:
(data, discrete_columns) = read_csv(args.data, args.metadata, args.header, args.discrete)
if args.load:
model = CTGAN.load(args.load)
else:
generator_dim ... |
def _get_activation_fn(activation: str) -> Callable[([Tensor], Tensor)]:
if (activation == 'relu'):
return F.relu
elif (activation == 'gelu'):
return F.gelu
raise RuntimeError('activation should be relu/gelu, not {}'.format(activation)) |
class NormalNoise(Explorer):
_mean: float
_std: float
def __init__(self, mean: float=0.0, std: float=0.1):
self._mean = mean
self._std = std
def sample(self, algo: QLearningAlgoProtocol, x: Observation, step: int) -> NDArray:
action = algo.predict(x)
noise = np.random.nor... |
def gen_truth(fname, modulename):
with open((fname + '.v')) as file:
f = open((fname + '_tb.v'), 'w+')
line = file.readline()
inp = 0
out = 0
n_inputs = 0
n_outputs = 0
while line:
line.strip()
tokens = re.split('[ ,;\n]', line)
... |
def should_strip_ansi(stream=None, color=None):
if (color is None):
if (stream is None):
stream = sys.stdin
return ((not isatty(stream)) and (not _is_jupyter_kernel_output(stream)))
return (not color) |
def uniform32_from_uint(x, bits):
if (bits == 64):
return uniform32_from_uint64(x)
elif (bits == 53):
return uniform32_from_uint53(x)
elif (bits == 32):
return uniform32_from_uint32(x)
else:
raise NotImplementedError |
def main():
(rank, world_size) = dist_init()
logger.info('init done')
cfg.merge_from_file(args.cfg)
if (rank == 0):
if (not os.path.exists(cfg.TRAIN.LOG_DIR)):
os.makedirs(cfg.TRAIN.LOG_DIR)
init_log('global', logging.INFO)
if cfg.TRAIN.LOG_DIR:
add_file_h... |
class WheelFile(ZipFile):
_default_algorithm = hashlib.sha256
def __init__(self, file, mode='r'):
basename = os.path.basename(file)
self.parsed_filename = WHEEL_INFO_RE.match(basename)
if ((not basename.endswith('.whl')) or (self.parsed_filename is None)):
raise WheelError('B... |
.operations('failure', 'multiple_failures')
def test_exit_first(any_app_schema):
results = list(from_schema(any_app_schema, exit_first=True).execute())
assert (results[(- 1)].has_failures is True)
assert (results[(- 1)].failed_count == 1) |
def create_stmt_from_unaryop(unaryop: ast.UnaryOp, testcase: tc.TestCase, constant_provider: ConstantProvider) -> (stmt.VariableCreatingStatement | None):
val = unaryop.operand.value
if isinstance(val, bool):
return stmt.BooleanPrimitiveStatement(testcase, (not val))
if isinstance(val, float):
... |
class Diagram(ClonableArray, metaclass=InheritComparisonClasscallMetaclass):
def __classcall_private__(self, cells, n_rows=None, n_cols=None, check=True):
return Diagrams()(cells, n_rows, n_cols, check)
def __init__(self, parent, cells, n_rows=None, n_cols=None, check=True):
self._cells = frozen... |
class ModelEma():
def __init__(self, model, decay=0.9999, device='', resume='', batch_size=1024, epoch=350):
self.ema = deepcopy(model)
self.ema.eval()
self.decay = decay
self.device = device
if device:
self.ema.to(device=device)
self.ema_has_module = hasa... |
def generic_setup_mudata_manager(mdata: MuData, layer_mod, layer: Optional[str]=None, batch_mod: Optional[str]=None, batch_key: Optional[str]=None, categorical_covariate_mod: Optional[str]=None, categorical_covariate_keys: Optional[list[str]]=None, continuous_covariate_mod: Optional[str]=None, continuous_covariate_keys... |
class Converter():
def __init__(self, use_fake_div=False):
self.use_fake_div = use_fake_div
def __call__(self, ex=None):
if (ex is None):
ex = self.ex
try:
obj = ex.pyobject()
return self.pyobject(ex, obj)
except TypeError as err:
i... |
class Tensor(bb.Object):
def __init__(self, shape: List[int]=None, *, dtype=bb.DType.FP32, host_only=False, core_tensor=None):
if (core_tensor is None):
if (shape is not None):
core_tensor = core.Tensor(shape, dtype.value, host_only)
super(Tensor, self).__init__(core_obje... |
def constrained_birkhoff_von_neumann_decomposition(X, constraint_structure):
S = {index for (index, x) in np.ndenumerate(X)}
feasibility_test(X, constraint_structure)
return solution_cleaner(X, iterate_constrained_birkhoff_von_neumann_iterator(X, graph_constructor(X, bihierarchy_test(constraint_structure), ... |
def test_arrow_union_dense_null():
a = pyarrow.UnionArray.from_dense(pyarrow.array([0, 1, 0, 0, 0, 1, 1], type=pyarrow.int8()), pyarrow.array([0, 0, 1, 2, 3, 1, 2], type=pyarrow.int32()), [pyarrow.array([0.0, 1.1, None, 3.3]), pyarrow.array([True, True, False])])
assert (to_list(ak._connect.pyarrow.handle_arrow... |
class FP16(nn.Module):
def __init__(self, module):
super(FP16, self).__init__()
self.module = BN_convert_float(module.half())
def forward(self, input, **kwargs):
return self.module(input.half(), **kwargs) |
def split_by_worker(urls):
import torch
urls = [url for url in urls]
assert isinstance(urls, list)
worker_info = torch.utils.data.get_worker_info()
if (worker_info is not None):
wid = worker_info.id
num_workers = worker_info.num_workers
if ((wid == 0) and (len(urls) < num_wor... |
def load_weights(weight_file):
if (weight_file == None):
return
try:
weights_dict = np.load(weight_file).item()
except:
weights_dict = np.load(weight_file, encoding='bytes').item()
return weights_dict |
def create_causal_relation_table(relations=None, height=500):
if ((relations is None) or (len(relations) == 0)):
data = [{'Node A': '', 'Relation': '', 'Node B': ''}]
else:
data = []
for (key, val) in relations.items():
(i, j) = key.split('<split>')
data.append({'... |
def _imgpath(img_dir, name):
img_path = os.path.join(img_dir, name)
if (not os.path.exists(img_path)):
return 'nofile'
return img_path |
class Trainer(RONet):
def __init__(self):
RONet.__init__(self, FLAGS)
def placeholder_inputs(self, batch_size, img_size, lab_size, channels):
images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, img_size, img_size, channels))
labels_placeholder = tf.placeholder(tf.float32, ... |
def find_all_experiment_configuration(experiments_path: str, ext='.json'):
if experiments_path.endswith(ext):
(yield experiments_path)
for (root, _, files) in os.walk(experiments_path):
for file in files:
if file.endswith(ext):
(yield os.path.join(root, file)) |
def run_experiment_mem(input_config):
experiments = []
experiments.append(analyzer_experiment(instances=1, name='mem-single', experiment_type='memory', input_config=input_config, port=8081))
experiments.append(analyzer_experiment(instances=5, name='mem-multiple', experiment_type='memory', input_config=input... |
def main_loop():
for i_iter in range(args.max_iter_num):
discrim_net.to(torch.device('cpu'))
(batch, log) = agent.collect_samples(args.min_batch_size)
discrim_net.to(device)
t0 = time.time()
update_params(batch, i_iter)
t1 = time.time()
if ((i_iter % args.log_... |
class GcdDomains(Category_singleton):
def super_categories(self):
return [IntegralDomains()]
def additional_structure(self):
return None
class ParentMethods():
pass
class ElementMethods():
pass |
def load_reference(path_to_reference):
with open(path_to_reference, 'r') as f:
qids_to_relevant_documentids = load_reference_from_stream(f)
return qids_to_relevant_documentids |
class LabelledBinaryTrees(LabelledOrderedTrees):
def _repr_(self):
return 'Labelled binary trees'
def _an_element_(self):
LT = self._element_constructor_
t = LT([], label=3)
t1 = LT([t, t], label=42)
t2 = LT([[], []], label=5)
return LT([t1, t2], label='toto')
... |
class DummyEnv():
def __init__(self, ep_len=2, reward_mag=1):
self.ep_len = ep_len
self.reward_mag = reward_mag
self.reset()
def step(self, action):
self.step_num += 1
if (action == 0):
reward = self.reward_mag
else:
reward = (- self.reward... |
def create_profile(profiler):
profiler.disable()
ps = pstats.Stats(profiler).sort_stats('cumulative')
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
results = {}
for item in ['ifftn', 'ifft', 'irfftn', 'irfft2', 'irfft', 'rfftn', 'rfft2', 'rfft', 'fftn', 'fft', 'dct', 'ifst', 'ifct', 'fst', 'fct',... |
def register_Ns3EdcaParameterSetChecker_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::EdcaParameterSetChecker const &', 'arg0')])
return |
class MMOE(BaseModel):
def __init__(self, dnn_feature_columns, num_experts=3, expert_dnn_hidden_units=(256, 128), gate_dnn_hidden_units=(64,), tower_dnn_hidden_units=(64,), l2_reg_linear=1e-05, l2_reg_embedding=1e-05, l2_reg_dnn=0, init_std=0.0001, seed=1024, dnn_dropout=0, dnn_activation='relu', dnn_use_bn=False, ... |
class FSymBases(Category_realization_of_parent):
def super_categories(self):
R = self.base().base_ring()
return [self.base().Realizations(), HopfAlgebras(R).Graded().Realizations(), HopfAlgebras(R).Graded().WithBasis().Graded().Connected()]
class ParentMethods():
def _repr_(self):
... |
def other_headings(cells):
previous_valid_heading_level = 1
first_invalid_heading_level = None
errors = []
for cell in cells[1:]:
if (not isinstance(cell, MarkdownCell)):
continue
for (elem, entering) in cell.ast.walker():
if ((not is_heading(elem)) or (not enteri... |
class TestDataset(Dataset):
def __init__(self, triples, all_true_triples, nentity, rel_mask=None):
self.len = len(triples)
self.triple_set = all_true_triples
self.triples = triples
self.nentity = nentity
self.rel_mask = rel_mask
self.hr2t_all = ddict(set)
for ... |
def run(args):
db = {'circuit_rtt': [], 'client_goodput': [], 'client_goodput_5MiB': [], 'circuit_build_times': [], 'download_times': {}, 'daily_counts': {}, 'relay_goodput': {}}
if (args.bandwidth_data_path is not None):
logging.info(f"Parsing bandwidth data stored in '{args.bandwidth_data_path}'")
... |
def visualize_result(data, pred, pred_prob, args):
(img, info) = data
img_name = info.split('/')[(- 1)]
water_mask = (pred == 21)
sea_mask = (pred == 26)
river_mask = (pred == 60)
pool_mask = (pred == 109)
fall_mask = (pred == 113)
lake_mask = (pred == 128)
water_mask = (((((water_ma... |
def exec_cmds(cmds):
cmd_file = 'z3_tmp.cmd'
f = open(cmd_file, 'w')
for cmd in cmds:
f.write(cmd)
f.write('\n')
f.close()
res = 0
try:
res = subprocess.call(cmd_file, shell=True)
except:
res = 1
try:
os.erase(cmd_file)
except:
pass
... |
def AnoaTime(direction, r_in, r_out, extra=None):
del extra
if (direction == 0):
return r_out
if (direction == 1):
return r_in |
def test_read_snippets_two_columns(tmp_path):
filename = (tmp_path / 'foo.csv')
with open(filename, 'w', encoding='utf-8') as fout:
fout.write('FOO\tThis is a test\thappy\tfoo\n')
fout.write('FOO\tThis is a second sentence\tsad\tbar\n')
fout.write('FOO\tThis is a third sentence\tsad\tfoo... |
def get_spanish_datasets() -> List[Tuple[(str, Optional[str])]]:
return ([(name, None) for name in ['head_qa', 'sab']] + [('amazon_reviews_multi', 'es')]) |
class MinSymbolic(MinMax_base):
def __init__(self):
BuiltinFunction.__init__(self, 'min', nargs=0, latex_name='\\min', conversions=dict(sympy='Min'))
def _eval_(self, *args):
return self.eval_helper(min_symbolic, builtin_min, float('inf'), args)
def _evalf_(self, *args, **kwds):
retu... |
def parse_vocab(filename):
if filename.endswith('.gz'):
import gzip
raw = gzip.open(filename, 'r').read().decode('utf8')
else:
raw = open(filename, 'r').read()
if raw.startswith('{'):
py_vocab = eval(raw)
assert isinstance(py_vocab, dict)
labels = {idx: label ... |
def extend_cfg(cfg):
from yacs.config import CfgNode as CN
cfg.TRAINER.OURS = CN()
cfg.TRAINER.OURS.N_CTX = 10
cfg.TRAINER.OURS.CSC = False
cfg.TRAINER.OURS.CTX_INIT = ''
cfg.TRAINER.OURS.WEIGHT_U = 0.1 |
class FlaxRobertaPreLayerNormForQuestionAnswering(metaclass=DummyObject):
_backends = ['flax']
def __init__(self, *args, **kwargs):
requires_backends(self, ['flax']) |
def FNN(linear_feature_columns, dnn_feature_columns, dnn_hidden_units=(256, 128, 64), l2_reg_embedding=1e-05, l2_reg_linear=1e-05, l2_reg_dnn=0, seed=1024, dnn_dropout=0, dnn_activation='relu', task='binary'):
features = build_input_features((linear_feature_columns + dnn_feature_columns))
inputs_list = list(fea... |
def _batch_thread(index_queue: queue.Queue[Optional[Tuple[(int, int)]]], batch_queue: queue.Queue[Optional[Tuple[(Any, int)]]], data_path: str, batch_info_path: str, token_dropout: float, split: str) -> None:
thread_loader = BatchLoader(data_path, batch_info_path, token_dropout=token_dropout)
while True:
... |
def summarize_jsons(test_list: TestList, interested_folders: List[str], coverage_only: List[str], platform: TestPlatform) -> None:
start_time = time.time()
if (detect_compiler_type(platform) == CompilerType.GCC):
html_oriented_report()
else:
parse_jsons(test_list, interested_folders, platfor... |
def firmmax_sample(logits, temperature, dim=1):
if (temperature == 0):
return F.softmax(logits, dim=dim)
y = (logits + (sample_gumbel(logits.shape, tens_type=type(logits.data)) / temperature))
return F.softmax(y, dim=dim) |
(5, 4, FOptsDir.DOWNLINK, fOptsDownlink)
class RXParamSetupReq(FOpt):
_MASK_RX1DROFFSET = 112
_MASK_RX2DATARATE = 15
def __init__(self, rx1drOffset=None, rx2dataRate=None, freq=0, **kwargs):
super().__init__(**kwargs)
if (rx1drOffset is not None):
self.rx1drOffset = rx1drOffset
... |
def test_nested_exis_0():
arrays = {'x': np.arange(4), 'y': ['this', 'that', 'foo', 'bar!']}
result = ak.cartesian(arrays, nested=True, axis=0)
assert (result.to_list() == [[{'x': 0, 'y': 'this'}, {'x': 0, 'y': 'that'}, {'x': 0, 'y': 'foo'}, {'x': 0, 'y': 'bar!'}], [{'x': 1, 'y': 'this'}, {'x': 1, 'y': 'tha... |
def plot_lightcurves_from_hdf5(settings, SNID_idxs):
with h5py.File(settings.hdf5_file_name, 'r') as hf:
features = hf['features'][:].astype(str)
n_features = len(features)
plt.figure(figsize=(20, 10))
gs = gridspec.GridSpec(4, 4, hspace=0.4)
for (idx, SNID_idx) in enumerate(... |
def dicenet_seg(args, classes):
weights = args.weights
model = DiCENetSegmentation(args, classes=classes)
if weights:
import os
if os.path.isfile(weights):
num_gpus = torch.cuda.device_count()
device = ('cuda' if (num_gpus >= 1) else 'cpu')
pretrained_dict... |
.usefixtures('num_cpus', 'io_type')
class BaseTest():
qbt = None
(autouse=True)
def set_tmpdir(self, request):
setattr(self, 'tmpdir', request.getfixturevalue('tmpdir'))
def teardown_class(cls):
plt.close('all')
def eigenvals(self, io_type, evals_reference):
evals_count = len... |
class DownBlock3D(nn.Module):
def __init__(self, in_channels: int, out_channels: int, temb_channels: int, dropout: float=0.0, num_layers: int=1, resnet_eps: float=1e-06, resnet_time_scale_shift: str='default', resnet_act_fn: str='swish', resnet_groups: int=32, resnet_pre_norm: bool=True, output_scale_factor=1.0, ad... |
def coinfo(X, ks):
info = 0.0
S = len(X)
for T in range(1, (S + 1)):
sgn = ((- 1) ** T)
info += (sgn * numpy.sum(from_data(X, ks=ks, r=T)))
return (- info) |
_task('masked_lm')
class MaskedLMTask(LegacyFairseqTask):
def add_args(parser):
parser.add_argument('data', help='colon separated path to data directories list, will be iterated upon during epochs in round-robin manner')
parser.add_argument('--sample-break-mode', default=... |
class Fpr(Critic):
def __init__(self, recall_level=0.95):
super().__init__()
self.recall_level = recall_level
def get_name(self):
return (('FPR(' + str((self.recall_level * 100))) + ')')
def stable_cumsum(self, arr, rtol=1e-05, atol=1e-08):
out = np.cumsum(arr, dtype=np.float... |
def setup_environment(dry_run, volume_start, volume_stop, volume_size, volume_path, max_ram_size, output_patch_size, input_patch_size, channel_num, dtype, output_patch_overlap, crop_chunk_margin, mip, thumbnail_mip, max_mip, thumbnail, encoding, voxel_size, overwrite_info):
assert (not ((volume_stop is None) and (v... |
def show_mesh_info(options):
mesh = Mesh.from_file(options.filename)
output(mesh.cmesh)
output('element types:', mesh.descs)
output('nodal BCs:', sorted(mesh.nodal_bcs.keys()))
bbox = mesh.get_bounding_box()
output(('bounding box:\n%s' % '\n'.join((('%s: [%14.7e, %14.7e]' % (name, bbox[(0, ii)],... |
def filter_dict(example_dict, threshold):
to_pop_key_list = []
for key in example_dict:
if (len(example_dict[key]) < threshold):
to_pop_key_list.append(key)
for key in to_pop_key_list:
example_dict.pop(key)
return example_dict |
_quantizer(quantization_target=QuantizationTarget.Weights, quantization_method=[QuantizationMethod.UNIFORM], identifier=TrainingMethod.STE)
class STEUniformWeightQATQuantizer(BaseKerasQATTrainableQuantizer):
def __init__(self, quantization_config: TrainableQuantizerWeightsConfig):
super().__init__(quantizat... |
def get_validation_recalls(r_list, q_list, k_values, gt, print_results=True, faiss_gpu=False, dataset_name='dataset without name ?', testing=False):
embed_size = r_list.shape[1]
if faiss_gpu:
res = faiss.StandardGpuResources()
flat_config = faiss.GpuIndexFlatConfig()
flat_config.useFloat... |
class GraphProfilerCsvWriter():
def __init__(self, gb, file=sys.stdout):
self.file = file
self.gb = gb
self.fields = ['parameter_scope', 'function_name', 'inputs_shape', 'args_info', 'forward', 'backward', 'forward_n_run', 'backward_n_run']
self.write_header()
def write_header(se... |
class miniImageNet(ImageFolder):
def __init__(self, root: str, mode: str, image_sz=84) -> None:
assert (mode in ['train', 'val', 'test'])
IMAGE_PATH = os.path.join(root, mode)
if ((mode == 'val') or (mode == 'test')):
transform = transforms.Compose([transforms.Resize([92, 92]), t... |
def apply_impulse(vf: ti.template(), dyef: ti.template(), imp_data: ti.types.ndarray()):
g_dir = ((- ti.Vector([0, 9.8])) * 300)
for (i, j) in vf:
(omx, omy) = (imp_data[2], imp_data[3])
mdir = ti.Vector([imp_data[0], imp_data[1]])
(dx, dy) = (((i + 0.5) - omx), ((j + 0.5) - omy))
... |
class ProgressBar():
def __init__(self, iterable, epoch=None, prefix=None, quiet=False):
self.epoch = epoch
self.quiet = quiet
self.prefix = ((prefix + ' | ') if (prefix is not None) else '')
if (epoch is not None):
self.prefix += f'epoch {epoch:02d}'
self.iterabl... |
class ImageType():
Scene = 0
DepthPlanner = 1
DepthPerspective = 2
DepthVis = 3
DisparityNormalized = 4
Segmentation = 5
SurfaceNormals = 6
Infrared = 7 |
def logging_config(folder=None, name=None, level=logging.INFO, console_level=logging.DEBUG):
if (name is None):
name = inspect.stack()[1][1].split('.')[0]
if (folder is None):
folder = os.path.join(os.getcwd(), name)
if (not os.path.exists(folder)):
os.makedirs(folder)
for handle... |
class ConstantSchedule(object):
def __init__(self, value):
self._v = value
def value(self, t):
return self._v |
class SysCommonNlg(object):
templates = {SystemAct.GREET: ['Hello.', 'Hi.', 'Greetings.', 'How are you doing?'], SystemAct.ASK_REPEAT: ['Can you please repeat that?', 'What did you say?'], SystemAct.ASK_REPHRASE: ['Can you please rephrase that?', 'Can you say it in another way?'], SystemAct.GOODBYE: ['Goodbye.', 'S... |
def ResNeXt29_2x64d(feature_dim=128):
return ResNeXt(num_blocks=[3, 3, 3], cardinality=2, bottleneck_width=64, feature_dim=feature_dim) |
class NominalAttributeMultiwayTest(InstanceConditionalTest):
def __init__(self, att_idx, branch_mapping):
super().__init__()
self._att_idx = att_idx
self._branch_mapping = branch_mapping
self._reverse_branch_mapping = {b: v for (v, b) in branch_mapping.items()}
def branch_for_ins... |
def create_clones(config, model_fn, args=None, kwargs=None, gpu_offset=0):
clones = []
args = (args or [])
kwargs = (kwargs or {})
variables_device = config.variables_device()
with slim.arg_scope([slim.model_variable, slim.variable], device=variables_device):
for i in range(0, config.num_clo... |
def gaussian_noise_layer(x, is_training=False):
if is_training:
noise = tf.random_normal(shape=tf.shape(x), mean=0.0, stddev=1.0, dtype=tf.float32)
return (x + noise)
else:
return x |
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_ch_esr(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
error_re... |
def get_cluster_manager(params, config_proto):
return cnn_util.GrpcClusterManager(params, config_proto) |
_properties
class MapTiling(transformation.SingleStateTransformation):
map_entry = transformation.PatternNode(nodes.MapEntry)
prefix = Property(dtype=str, default='tile', desc='Prefix for new range symbols')
tile_sizes = ShapeProperty(dtype=tuple, default=(128, 128, 128), desc='Tile size per dimension')
... |
class SlurmQueueConf(BaseQueueConf):
_target_: str = 'hydra_plugins.hydra_submitit_launcher.submitit_launcher.SlurmLauncher'
partition: Optional[str] = None
qos: Optional[str] = None
comment: Optional[str] = None
constraint: Optional[str] = None
exclude: Optional[str] = None
gres: Optional[s... |
def test_model(model, goal_path, show_goal=False, env_steps=1000, new_plan_frec=20, show_video=False, save_video=False, save_folder='./analysis/videos/model_trials/', save_filename='video.mp4'):
goal = plt.imread(goal_path)
if show_goal:
plt.axis('off')
plt.suptitle('Goal')
plt.imshow(go... |
def json2instanceImg(inJson, outImg, encoding='ids'):
annotation = Annotation()
annotation.fromJsonFile(inJson)
instanceImg = createInstanceImage(annotation, encoding)
instanceImg.save(outImg) |
def is_match(modules, node, pattern, max_uses=sys.maxsize):
if isinstance(pattern, tuple):
(self_match, *arg_matches) = pattern
if (self_match is getattr):
assert (len(pattern) == 2), 'Expecting getattr pattern to have two elements'
arg_matches = []
else:
self_mat... |
def find_typeshed() -> Optional[Path]:
current_directory: pathlib.Path = Path(__file__).parent
bundled_typeshed_relative_path = 'pyre_check/typeshed/'
bundled_typeshed = find_parent_directory_containing_directory(current_directory, bundled_typeshed_relative_path)
if bundled_typeshed:
return (bun... |
.skip(reason='Shared function')
def test_region(region):
client = SkyplaneClient().object_store()
key = str(uuid.uuid4()).replace('-', '')
src_filename = f'src_{key}'
dst_filename = f'dst_{key}'
provider = region.split(':')[0]
if (provider == 'azure'):
bucket_name = ((str(uuid.uuid4()).r... |
def register_Ns3QueueLimits_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::QueueLimits const &', 'arg0')])
cls.add_method('Available', 'int32_t', [], is_pure_virtual=True, is_const=True, is_virtual=True)
cls.add_method('Completed', 'void', [param('uint32_t', 'count')... |
def add_arguments(parser):
parser.add_argument('files', nargs='+', help='path to input box files')
parser.add_argument('--invert-y', action='store_true', help='invert (mirror) the y-axis particle coordinates. appears to be necessary for .tiff compatibility with EMAN2')
parser.add_argument('--imagedir', help... |
def varlen_lstm_backward_setup(forward_output, seed=None):
if seed:
torch.manual_seed(seed)
rnn_utils = torch.nn.utils.rnn
sequences = forward_output[0]
padded = rnn_utils.pad_sequence(sequences)
grad = torch.randn_like(padded)
return (padded, grad) |
def _squeeze_and_excite(x, hidden_dim, activation_fn=tf.nn.relu6, normalization_op_params=None):
if (normalization_op_params is None):
raise ValueError('Normalization params cannot be `None`')
(_, height, width, channels) = x.get_shape().as_list()
u = tf.keras.layers.AveragePooling2D([height, width]... |
def main():
parser = argparse.ArgumentParser(description='Validates that the descriptions in notebooks follow the expected format, so that the notebooks read consistently and render nicely.')
parser.add_argument('locations', nargs='+', help='Paths(s) to search for Jupyter notebooks to check')
args = parser.... |
def get_partition_dataset(data_path, data_name, part_id):
part_name = os.path.join(data_name, ('partition_' + str(part_id)))
path = os.path.join(data_path, part_name)
if (not os.path.exists(path)):
print('Partition file not found.')
exit()
train_path = os.path.join(path, 'train.txt')
... |
def test_dont_record_objectproxy_instance_check():
proxy = tt.ObjectProxy(42)
with tt.shim_isinstance():
assert isinstance(proxy, tt.ObjectProxy)
assert (len(tt.UsageTraceNode.from_proxy(proxy).type_checks) == 0) |
class SequenceTranslation(object):
def __init__(self, max_shift: int):
self.max_shift = max_shift
def __call__(self, x: LongTensor, shift=None):
if (shift is None):
shift = random.randint((- self.max_shift), self.max_shift)
else:
shift = min(shift, self.max_shift)... |
def test_torootname():
model_1 = pyhf.simplemodels.correlated_background([5], [50], [52], [48])
model_2 = pyhf.simplemodels.uncorrelated_background([5], [50], [7])
model_3 = pyhf.simplemodels.uncorrelated_background([5, 6], [50, 50], [7, 8])
assert (pyhf.compat.paramset_to_rootnames(model_1.config.param... |
class CosineWarmup(torch.optim.lr_scheduler.CosineAnnealingLR):
def __init__(self, optimizer, T_max, eta_min=0, warmup_step=0, **kwargs):
self.warmup_step = warmup_step
super().__init__(optimizer, (T_max - warmup_step), eta_min, *kwargs)
def get_lr(self):
if (not self._get_lr_called_with... |
_model('transformer_from_pretrained_xlm')
class TransformerFromPretrainedXLMModel(TransformerModel):
def add_args(parser):
TransformerModel.add_args(parser)
parser.add_argument('--pretrained-xlm-checkpoint', type=str, metavar='STR', help='XLM model to use for initializing transformer encoder and/or ... |
class SEWDForSequenceClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.