code stringlengths 101 5.91M |
|---|
def _normalize_tabular_data(tabular_data, headers):
if (hasattr(tabular_data, 'keys') and hasattr(tabular_data, 'values')):
if hasattr(tabular_data.values, '__call__'):
keys = list(tabular_data.keys())
rows = list(zip_longest(*list(tabular_data.values())))
elif hasattr(tabula... |
def run_experiment(hparams, run_opts, datasets):
idx_examples = np.arange(datasets['train'].dataset.tensors[0].shape[0])
n_examples_perclass = [idx_examples[np.where((datasets['train'].dataset.tensors[1] == c))[0]].shape[0] for c in range(hparams['n_classes'])]
n_examples_perclass = np.array(n_examples_perc... |
def label_payload_parser(accessor, label):
return dict_payload_parser(accessor, {'label': label}) |
class QuotedString(Token):
def __init__(self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
super(QuotedString, self).__init__()
quoteChar = quoteChar.strip()
if (not quoteChar):
warnings.warn('quo... |
def mkdir_p(path):
try:
os.makedirs(path)
except OSError as exc:
if ((exc.errno == errno.EEXIST) and os.path.isdir(path)):
pass
else:
raise |
.parametrize('backend_name', ['numpy', 'tensorflow', 'pytorch', 'PyTorch'])
def test_backend_slotted_attributes(backend_name):
pyhf.set_backend(backend_name)
for attr in ['name', 'precision', 'dtypemap', 'default_do_grad']:
assert (getattr(pyhf.tensorlib, attr) is not None) |
class FreezeCommand(Command):
usage = '\n %prog [options]'
log_streams = ('ext://sys.stderr', 'ext://sys.stderr')
def add_options(self):
self.cmd_opts.add_option('-r', '--requirement', dest='requirements', action='append', default=[], metavar='file', help='Use the order in the given requirement... |
def test_clean_inplace(df_broken_email: pd.DataFrame) -> None:
df_clean = clean_email(df_broken_email, 'messy_email', inplace=True)
df_check = pd.DataFrame({'messy_email_clean': ['', '', None, '', None, None, None, None]})
assert df_check.equals(df_clean) |
def load_data(file):
data = pd.read_pickle(file)
data.drop('Meth', axis=1, inplace=True)
data.drop('Eth', axis=1, inplace=True)
data.drop('Time', axis=1, inplace=True)
return data |
def search_network(nnp, name):
for n in nnp.protobuf.network:
if (n.name == name):
return n
return None |
def mk_auto_soundness_step_instr(ctx: LeanGenContext):
instr = ctx.func.lean_desc[ctx.lean_desc_num]
if isinstance(instr, LeanPreprocessedNop):
return
if isinstance(instr, LeanPreprocessedAddAp):
mk_auto_soundness_add_ap(ctx, instr)
elif isinstance(instr, LeanPreprocessedConst):
... |
def buildDataFeatures(usedFeatures):
Q = '\ndataFeatures as (\nSELECT distinct ip, p, server FROM (\n'
format_i = 0
for f in usedFeatures:
(format_i, breakl) = formatUnions(format_i)
Q += (breakl + f)
Q += '\n)),'
return Q |
class DeepEnsembleTrajectorySampler(TrajectorySampler[DeepEnsembleModel]):
def __init__(self, model: DeepEnsembleModel, diversify: bool=False, seed: Optional[int]=None):
if (not isinstance(model, DeepEnsembleModel)):
raise NotImplementedError(f'EnsembleTrajectorySampler only works with DeepEnsem... |
class DivNode(NumBinopNode):
cdivision = None
truedivision = None
ctruedivision = False
cdivision_warnings = False
zerodivision_check = None
def find_compile_time_binary_operator(self, op1, op2):
func = compile_time_binary_operators[self.operator]
if ((self.operator == '/') and (... |
class ErrorHandler(pybindgen.settings.ErrorHandler):
def handle_error(self, dummy_wrapper, dummy_exception, dummy_traceback_):
return True |
def csv_rel2abs_path_convertor(csv_filenames: str, delimiter: str=' ', encoding='utf8') -> None:
for filename in tqdm(csv_filenames):
(absolute_path, basename) = os.path.split(os.path.abspath(filename))
relative_paths = list()
labels = list()
with open(filename, 'r', encoding=encodin... |
class TestRedis():
(scope='class', autouse=True)
def flush_db(self):
urls_con.flushall()
def test_store_and_fetch_cookies(self):
assert (Cookies.fetch_cookies() is None)
Cookies.store_cookies(FAKE_STR, FAKE_STR)
assert (Cookies.fetch_cookies() is not None)
def test_del_co... |
def add_boolean_modifier(mesh_object: bpy.types.Object, another_mesh_object: bpy.types.Object, operation: str='DIFFERENCE') -> None:
modifier: bpy.types.SubsurfModifier = mesh_object.modifiers.new(name='Boolean', type='BOOLEAN')
modifier.object = another_mesh_object
modifier.operation = operation |
class DDPMPipeline(DiffusionPipeline):
def __init__(self, unet, scheduler):
super().__init__()
scheduler = scheduler.set_format('pt')
self.register_modules(unet=unet, scheduler=scheduler)
_grad()
def __call__(self, batch_size: int=1, generator: Optional[torch.Generator]=None, output_... |
_checkpoint_hooks
class EpochCounter():
def __init__(self, limit):
self.current = 0
self.limit = int(limit)
def __iter__(self):
return self
def __next__(self):
if (self.current < self.limit):
self.current += 1
logger.info(f'Going into epoch {self.curre... |
class PathTableaux(UniqueRepresentation, Parent):
def __init__(self):
Parent.__init__(self, category=Sets())
def _element_constructor_(self, *args, **kwds):
return self.element_class(self, *args, **kwds) |
class LAR_reg(atomic_reg):
OP_NAME = 'LAR'
_fields_ = [('opd0_w_str', ctypes.c_uint64, 1), ('opd1_w_str', ctypes.c_uint64, 1), ('opd2_const', ctypes.c_uint64, 1), ('res0_prec', ctypes.c_uint64, 3), ('opd0_prec', ctypes.c_uint64, 3), ('opd1_prec', ctypes.c_uint64, 3), ('opd2_n_str', ctypes.c_uint64, 3), ('opd0_s... |
def generate_png(all_iter, net, gt_hsi, Dataset, device, total_indices, path):
pred_test = []
for (X, y) in all_iter:
X = X.permute(0, 3, 1, 2)
X = X.to(device)
net.eval()
pred_test.extend(net(X).cpu().argmax(axis=1).detach().numpy())
gt = gt_hsi.flatten()
x_label = np.ze... |
def test_create_digraph_1d(graph_1d):
ground_truth = nx.DiGraph()
ground_truth.add_nodes_from(np.array(['a', 'b', 'c', 'd']))
graph_1d._create_digraph()
assert nx.is_isomorphic(ground_truth, graph_1d.hierarchy_)
assert (list(ground_truth.nodes) == list(graph_1d.hierarchy_.nodes))
assert (list(gr... |
def sim_data(N=100, T=120, init_state={'pos': {'mean': np.array([0.0, 0.0, 0.3]), 'cov': np.diag((np.array([0.5, 1, 0.01]) ** 2))}, 'vel': {'mean': np.array([(- 1.4), 4.5, 2.3]), 'cov': np.eye(3)}}, deltaT=0.005, max_bounces=None, bounce_fac=np.array([0.9, 0.9, 0.8]), lin_air_drag=np.array([0, 0, 0]), quad_air_drag=0.1... |
class Exp(Flow):
def __init__(self):
super().__init__()
self.epsilon = 1e-08
def forward(self, x):
y = x.exp()
log_det_jac = x
return (y, log_det_jac)
.export
def inverse(self, y):
x = (y + self.epsilon).log()
inv_log_det_jac = (- y)
return... |
def compute_statistics_of_path(path, model, batch_size, dims, device, num_workers=1):
if path.endswith('.npz'):
with np.load(path) as f:
(m, s) = (f['mu'][:], f['sigma'][:])
else:
files = ((list(glob.glob((path + '/**/*.JPEG'), recursive=True)) + list(glob.glob((path + '/**/*.png'), ... |
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='\nPrediction script for a 3D stardist model, usage: stardist-predict -i input.tif -m model_folder_or_pretrained_name -o output_folder\n\n')
parser.add_argument('-i', '--input', type=str, nargs='+', ... |
def graphVisIntersection(node_neighbor, region, filename, size=2048):
img = np.zeros((size, size), dtype=np.uint8)
for (node, nei) in node_neighbor.iteritems():
loc0 = node
if (len(nei) != 2):
x0 = int((((loc0[1] - region[1]) / (region[3] - region[1])) * size))
y0 = int((... |
class SignLanguageTokenizer(BaseTokenizer):
def __init__(self, **kwargs) -> None:
self.hamnosys_tokenizer = HamNoSysTokenizer(**kwargs)
self.signwriting_tokenizer = SignWritingTokenizer(**kwargs, starting_index=len(self.hamnosys_tokenizer))
super().__init__([])
self.i2s = {**self.ham... |
()
def pytest_itemcollected(item):
global _old_fpu_mode
mode = get_fpu_mode()
if (_old_fpu_mode is None):
_old_fpu_mode = mode
elif (mode != _old_fpu_mode):
_collect_results[item] = (_old_fpu_mode, mode)
_old_fpu_mode = mode |
def get_logger_model(name, log_level=logging.DEBUG):
logger = logging.root.manager.loggerDict[name]
logger_es = logging.root.manager.loggerDict['EarlyStopping']
logger_es.addFilter(TimeFilter())
logger_es.addHandler(logger.handlers[0])
logger_es.setLevel(log_level)
logger.setLevel(log_level)
... |
def plot_rws(X, window=100, k=5, lim=1000):
shift = 75
X = X[window:]
t = range(len(X))
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
num_figs = (int(np.ceil((k / 5))) + 1)
fig = plt.figure(figsize=(15, (num_figs * 2)))
j = 0
ax = fig.add_subplot(num_figs, 5, (j + 1))
id... |
def worker_urls(urls):
assert isinstance(urls, list)
assert isinstance(urls[0], str)
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_workers)):
... |
def test_array_as_generated_dataset():
array = ak.Array([[{'x': 1, 'y': [1.1]}, {'x': 2, 'y': [2.2, 0.2]}], [], [{'x': 3, 'y': [3.0, 0.3, 3.3]}]])
generator = ak._connect.cling.togenerator(array.layout.form, flatlist_as_rvec=False)
lookup = ak._lookup.Lookup(array.layout)
source_code = f'''
double g... |
def dna_transformation(prev_image, dna_input):
prev_image_pad = tf.pad(prev_image, [[0, 0], [2, 2], [2, 2], [0, 0]])
image_height = int(prev_image.get_shape()[1])
image_width = int(prev_image.get_shape()[2])
inputs = []
for xkern in range(DNA_KERN_SIZE):
for ykern in range(DNA_KERN_SIZE):
... |
class HomsetWithBase(Homset):
def __init__(self, X, Y, category=None, check=True, base=None):
if (base is None):
base = X.base_ring()
Homset.__init__(self, X, Y, check=check, category=category, base=base) |
class BackgroundConsumer(Thread):
def __init__(self, queue, source, max_len):
Thread.__init__(self)
self._queue = queue
self._source = source
self._max_len = max_len
self.count = 0
def run(self):
try:
for item in self._source:
self._que... |
def write_sentences_to_conllu(filename, sents):
with open(filename, 'w', encoding='utf-8') as outfile:
for lines in sents:
lines = maybe_add_fake_dependencies(lines)
for line in lines:
print(line, file=outfile)
print('', file=outfile) |
class TFOpenAIGPTLMHeadModel():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
def html_per_unit(task, layer, unit, alignment, num_align):
html = ('\n <tr>\n <td align="left">[%s / layer %02d / Unit %04d]<br>\n ' % (task, layer, unit))
for i in range(num_align):
(concept, doa) = alignment[unit][i]
concept = concept.replace('MORPH_', '[#]')
html += ('<s... |
def _reindent_code(codestr):
codestr = io.StringIO(codestr)
ret = io.StringIO()
run_reindent(codestr, ret, config={'dry-run': False, 'help': False, 'to': 4, 'from': (- 1), 'tabs': True, 'encoding': 'utf-8', 'is-tabs': False, 'tabsize': 4, 'all-tabs': False})
return ret.getvalue() |
def test_transpose():
A = np.random.rand(M, N).astype(np.float32)
B = np.zeros([M, N], dtype=np.float32)
transpose_test(A, B)
realB = np.transpose(A)
rel_error = (np.linalg.norm((B - realB)) / np.linalg.norm(realB))
print('Relative_error:', rel_error)
assert (rel_error <= 1e-05) |
def get_array_prepare(*args):
wrappers = sorted(((getattr(x, '__array_priority__', 0), (- i), x.__array_prepare__) for (i, x) in enumerate(args) if hasattr(x, '__array_prepare__')))
if wrappers:
return wrappers[(- 1)][(- 1)]
return None |
def weights_init_kaiming(m):
classname = m.__class__.__name__
if (classname.find('Linear') != (- 1)):
nn.init.kaiming_normal_(m.weight, a=0, mode='fan_out')
if m.bias:
nn.init.constant_(m.bias, 0.0)
elif (classname.find('Conv') != (- 1)):
nn.init.kaiming_normal_(m.weight,... |
_model
def mobilenetv3_large_075(pretrained=False, **kwargs):
model = _gen_mobilenet_v3('mobilenetv3_large_075', 0.75, pretrained=pretrained, **kwargs)
return model |
class ContextNLU():
def __init__(self):
self.word2index = pickle.load(open((THIS_PATH + '/vocab.pkl'), 'rb'))
slot2index = pickle.load(open((THIS_PATH + '/slot.pkl'), 'rb'))
intent2index = pickle.load(open((THIS_PATH + '/intent.pkl'), 'rb'))
self.index2intent = {v: k for (k, v) in in... |
((not workspace.has_gpu_support), 'No gpu support.')
class BrewGPUTest(unittest.TestCase):
def test_relu(self):
Xpos = (np.ones((5, 5)).astype(np.float32) - 0.5)
Xneg = (np.ones((5, 5)).astype(np.float32) - 1.5)
workspace.FeedBlob('xpos', Xpos)
workspace.FeedBlob('xneg', Xneg)
... |
.parametrize('seed', [313])
.parametrize('axis', [0, 1, 2, (- 1)])
.parametrize('decay_rate', [0.9])
.parametrize('eps', [1e-05])
.parametrize('output_stat, batch_stat', [[False, False], [False, True], [True, True]])
.parametrize('ctx, func_name', ctxs)
.parametrize('no_scale, no_bias', [[False, False], [True, True]])
... |
def main(args):
Rankings = defaultdict(list)
for path in args.input:
print_message(f'#> Loading the rankings in {path} ..')
with open(path) as f:
for line in file_tqdm(f):
(qid, pid, rank, score) = line.strip().split('\t')
(qid, pid, rank) = map(int, [... |
def convert(data_dir: str, out_data_dir: str):
images_dir_name = os.path.join(out_data_dir, 'images')
pose_dir_name = os.path.join(out_data_dir, 'pose')
os.makedirs(images_dir_name, exist_ok=True)
os.makedirs(pose_dir_name, exist_ok=True)
def get_subdir(name):
if name.endswith('_train.json')... |
def compute_A_inv_b(A: TensorType, b: TensorType) -> tf.Tensor:
L = tf.linalg.cholesky(A)
L_inv_b = tf.linalg.triangular_solve(L, b)
A_inv_b = tf.linalg.triangular_solve(L, L_inv_b, adjoint=True)
return A_inv_b |
def register_Ns3Ipv4EndPoint_methods(root_module, cls):
cls.add_constructor([param('ns3::Ipv4EndPoint const &', 'arg0')])
cls.add_constructor([param('ns3::Ipv4Address', 'address'), param('uint16_t', 'port')])
cls.add_method('BindToNetDevice', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'netdevice')])
c... |
def test_before_add_examples(testdir, simple_openapi):
testdir.make_test('\\ndef before_add_examples(context, examples):\n new = schemathesis.models.Case(\n operation=context.operation,\n query={"foo": "bar"}\n )\n examples.append(new)\n\()\(phases=[Phase.explicit])\ndef test_a(case):\n as... |
class LimeImage(ExplainerBase):
explanation_type = 'local'
alias = ['lime']
def __init__(self, predict_function: Callable, mode: str='classification', **kwargs):
super().__init__()
assert (mode == 'classification'), 'Only supports classification tasks for image data.'
self.mode = mod... |
class SEATestsUniform(unittest.TestCase):
def setUp(self):
super(SEATestsUniform, self).setUp()
self.testval = 5
self.unidata = ([self.testval] * 200)
time = list(range(200))
self.epochs = [20, 40, 60, 80, 100, 120, 140, 160, 180]
with warnings.catch_warnings():
... |
class _ProfileReBenchDB(_ReBenchDB):
def _send_data(self, cache):
self.ui.debug_output_info('ReBenchDB: Prepare data for sending\n')
num_profiles = 0
all_data = []
for (run_id, data_points) in cache.items():
profile_data = [dp.as_dict() for dp in data_points]
... |
def compute_fitness(chromesome, code_2, codebert_tgt, tokenizer_tgt, orig_prob, orig_label, true_label, code_1, names_positions_dict, args):
temp_replace = map_chromesome(chromesome, code_1, 'java')
new_feature = convert_code_to_features(temp_replace, code_2, tokenizer_tgt, true_label, args)
new_dataset = C... |
def save_model(model, optimizer, opt, epoch, save_file):
print('==> Saving...')
state = {'opt': opt, 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'epoch': epoch}
torch.save(state, save_file)
del state |
def test_native_torch_tensor_sub():
batch_dim = Dim(2, name='batch_dim')
feature_dim = Dim(3, name='feature_dim')
tensor_bf = Tensor('tensor', dims=[batch_dim, feature_dim], dtype='float32', raw_tensor=torch.ones(2, 3))
tensor_f = Tensor('tensor', dims=[feature_dim], dtype='float32', raw_tensor=torch.ar... |
_method
class Constant():
def __init__(self, name, conversions=None, latex=None, mathml='', domain='complex'):
self._conversions = (conversions if (conversions is not None) else {})
self._latex = (latex if (latex is not None) else name)
self._mathml = mathml
self._name = name
... |
def get_data(split, repeats, batch_size, images_per_class, shuffle_buffer):
data = data_builder.as_dataset(split=split)
if (split == 'train'):
data = data.batch(50000)
data = data.as_numpy_iterator().next()
data = tf.data.Dataset.zip((tf.data.Dataset.from_tensor_slices(data['image']), tf... |
class ResidualBlock(nn.Module):
def __init__(self, linear_size, p_dropout=0.5):
super(ResidualBlock, self).__init__()
self.l_size = linear_size
self.relu = nn.ReLU(inplace=True)
self.dropout = nn.Dropout(p_dropout)
self.w1 = nn.Linear(self.l_size, self.l_size)
self.ba... |
def _register_cleanup(processes):
def _cleanup_processes():
print('Cleaning up process...')
time.sleep(0.5)
for p in processes:
p.terminate()
atexit.register(_cleanup_processes) |
class SecStructFeature(EdgeFeature):
def __init__(self, include_from=False, include_to=True):
self.include_from = include_from
self.include_to = include_to
assert (include_from or include_to)
def get_values(self, seq, from_index, to_index):
feature_values = {}
if self.inc... |
def main():
gui = ti.GUI('Mandelbrot set zoom', res=(width, height))
for i in range(100000):
render((i * 0.03))
gui.set_image(pixels)
gui.show() |
def mnasnet_075(pretrained=False, **kwargs):
model = _gen_mnasnet_b1('mnasnet_075', 0.75, pretrained=pretrained, **kwargs)
return model |
def force_out_of_place(model: torch.nn.Module):
state = dict()
for m in model.modules():
if (hasattr(m, 'inplace') and isinstance(m.inplace, bool)):
state[m] = m.inplace
m.inplace = False
(yield)
for (m, s) in state.items():
m.inplace = s |
def package_path():
global _pkg_path
if _pkg_path:
return _pkg_path
if (_EnvPkgPath in os.environ):
path = os.environ[_EnvPkgPath]
assert os.path.isdir(path), ('import pkg path via env %s: is not a dir: %r' % (_EnvPkgPath, path))
else:
path = _DefaultPkgPath
os.ma... |
class ToTensor(object):
def __init__(self, norm_value=255):
self.norm_value = norm_value
def __call__(self, pic):
if isinstance(pic, np.ndarray):
img = torch.from_numpy(pic.transpose((2, 0, 1)))
return img.float().div(self.norm_value)
if ((accimage is not None) an... |
def mk_pat_db_internal(inputFilePath, outputFilePath):
with open(inputFilePath, 'r') as fin:
with open(outputFilePath, 'w') as fout:
fout.write('static char const g_pattern_database[] =\n')
for line in fin:
fout.write(('"%s\\n"\n' % line.strip('\n')))
fout... |
def densepose_inference(densepose_predictor_output: Any, detections: List[Instances]):
k = 0
for detection_i in detections:
if (densepose_predictor_output is None):
continue
n_i = len(detection_i)
PredictorOutput = type(densepose_predictor_output)
output_i_dict = {}
... |
def test_singling_out_queries():
df = pd.DataFrame({'c1': [1, 1], 'c2': [2, 3]})
queries = UniqueSinglingOutQueries()
queries.check_and_append('c1 == 1', df=df)
assert (len(queries) == 0)
queries.check_and_append('c1 == 1 and c2 == 3', df=df)
assert (len(queries) == 1) |
def get_inference_engine(cfg):
engines = all_subclasses(BaseInferenceEngine)
try:
class_index = [cls.__name__ for cls in engines].index(cfg.INFERENCE.ENGINE)
except:
raise ValueError('Inference engine {} not found.'.format(cfg.INFERENCE.ENGINE))
engine = list(engines)[class_index]
re... |
class Flickr8k(data.Dataset):
def __init__(self, root, ann_file, transform=None, target_transform=None):
self.root = os.path.expanduser(root)
self.ann_file = os.path.expanduser(ann_file)
self.transform = transform
self.target_transform = target_transform
parser = Flickr8kPars... |
def test_point_precision(expected, observed):
expected_return = float((1 / 5))
returned = point_precision(expected, observed)
assert (returned == expected_return) |
def main():
total_count = 0
greedy_succ = 0
with open('./attack_gi.csv') as rf:
reader = csv.DictReader(rf)
for row in reader:
if (not (int(row['Index']) > 42)):
if (not (row['Is Success'] == '-4')):
total_count += 1
if ((row['I... |
class SubprocVecEnv(VecEnv):
def __init__(self, env_fns):
self.waiting = False
self.closed = False
nenvs = len(env_fns)
(self.remotes, self.work_remotes) = zip(*[Pipe() for _ in range(nenvs)])
self.ps = [Process(target=worker, args=(work_remote, remote, CloudpickleWrapper(env... |
class SumPricesRegression(BaseDataset):
def __init__(self, root: str=C.ROOT, load_jsonl: bool=False, download: bool=False):
self.download = download
if load_jsonl:
self.__load_jsonl(root=root)
else:
root = os.path.join(root, C.Tasks.SUM_PRICES_REGRESSION)
... |
def _ensure_spacing(coord, spacing, p_norm, max_out):
tree = cKDTree(coord)
indices = tree.query_ball_point(coord, r=spacing, p=p_norm)
rejected_peaks_indices = set()
naccepted = 0
for (idx, candidates) in enumerate(indices):
if (idx not in rejected_peaks_indices):
candidates.rem... |
class djbfft_info(system_info):
section = 'djbfft'
dir_env_var = 'DJBFFT'
notfounderror = DJBFFTNotFoundError
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend((self.combine_paths(d, ['djbf... |
class DatasetFile(DatasetRaw):
def __init__(self, args, split='train'):
data_dir = osp.join(args.data_dir, split)
if (not ('class2id' in args.keys())):
class2id = dict()
for i in range(args.num_classes):
class2id[str(i)] = i
else:
class2id ... |
def _worker_start():
env = None
policy = None
max_length = None
try:
while True:
msgs = {}
while True:
try:
msg = queue.get_nowait()
msgs[msg[0]] = msg[1:]
except Empty:
break
... |
def broadcast_all(*values):
values = list(values)
scalar_idxs = [i for i in range(len(values)) if isinstance(values[i], Number)]
tensor_idxs = [i for i in range(len(values)) if (values[i].__class__.__name__ == 'Tensor')]
if ((len(scalar_idxs) + len(tensor_idxs)) != len(values)):
raise ValueError... |
class TestOldSerialization(TestCase, SerializationMixin):
def _test_serialization_container(self, unique_key, filecontext_lambda):
tmpmodule_name = 'tmpmodule{}'.format(unique_key)
def import_module(name, filename):
import importlib.util
spec = importlib.util.spec_from_file_l... |
def nested_ner_performance(pred_start, pred_end, pred_span, gold_start, gold_end, gold_span, ner_cate, label_lst, threshold=0.5, dims=2):
cate_idx2label = {idx: value for (idx, value) in enumerate(label_lst)}
if (dims == 1):
ner_cate = cate_idx2label[ner_cate]
pred_span_triple = nested_transform... |
class MVTecDataset(AnomalibDataset):
def __init__(self, task: TaskType, transform: A.Compose, root: (Path | str), category: str, split: ((str | Split) | None)=None) -> None:
super().__init__(task=task, transform=transform)
self.root_category = (Path(root) / Path(category))
self.split = split... |
class MemDevSim(NICSim):
def __init__(self) -> None:
super().__init__()
self.mem_latency = 500
self.addr =
self.size = ((1024 * 1024) * 1024)
self.as_id = 0
def full_name(self) -> str:
return ('mem.' + self.name)
def sockets_cleanup(self, env: ExpEnv) -> tp.L... |
_utils.test(debug=True)
def test_vector_swizzle_taichi():
def foo():
v = ti.math.vec3(0)
v = ti.math.vec3(0, 0, 0)
v = ti.math.vec3([0, 0], 0)
v = ti.math.vec3(0, v.xx)
v = ti.math.vec3(0, v.xy)
v.rgb += 1
assert all((v.xyz == (1, 1, 1)))
v.zyx += ti.m... |
def assert_list(x, msg='not a list: {}'):
if isinstance(x, list):
return (True, None)
return (False, msg.format(type(x))) |
class NLabelsPerPatientLabeler(Labeler):
def __init__(self, labeler: Labeler, num_labels: int=1, seed: int=1):
self.labeler: Labeler = labeler
self.num_labels: int = num_labels
self.seed: int = seed
def label(self, patient: Patient) -> List[Label]:
labels: List[Label] = self.labe... |
def encode(buf, width, height):
assert (((width * height) * 3) == len(buf))
bpp = 3
def raw_data():
row_bytes = (width * bpp)
for row_start in range((((height - 1) * width) * bpp), (- 1), (- row_bytes)):
(yield b'\x00')
(yield buf[row_start:(row_start + row_bytes)])
... |
class RealTopologicalStructure(Singleton):
chart = RealChart
name = 'topological'
scalar_field_algebra = ScalarFieldAlgebra
homset = TopologicalManifoldHomset
def subcategory(self, cat):
return cat |
def get_all_images(path: Union[(str, List[str])]) -> List[str]:
print(path, len(os.listdir(path)))
if os.path.isdir(path):
images = os.listdir(path)
images = [os.path.join(path, item) for item in images if is_image_file(item)]
return images
elif is_image_file(path):
return [p... |
def capture_image():
stream = io.BytesIO()
with PiCamera() as camera:
camera.resolution = (640, 480)
camera.capture(stream, format='jpeg')
stream.seek(0)
return Image.open(stream) |
def add_track_to_constraint(camera_object: bpy.types.Object, track_to_target_object: bpy.types.Object) -> None:
constraint = camera_object.constraints.new(type='TRACK_TO')
constraint.target = track_to_target_object
constraint.track_axis = 'TRACK_NEGATIVE_Z'
constraint.up_axis = 'UP_Y' |
def predict(model, data, batch_size):
batcher = Batcher(data, batch_size)
predicted = []
for (batch, size, start, end) in batcher:
d = prepare(batch)
model.eval()
logits = model(d).cpu()
predicted.extend(torch.max(logits, 1)[1])
return torch.stack(predicted) |
def get_backend_from_tensors(*args):
for x in args:
if isinstance(x, Tensor):
return x._raw_backend
return _global_rf |
def pipe_and_output(input, output=None, num_threads=1, processor=None, name=None, capacity=None, group=None, num_runtime_threads=1, final_outputs=None):
assert (num_threads > 0)
(result, task) = _pipe_step(input, output, num_threads, processor, name, capacity, group, num_runtime_threads, final_outputs)
outp... |
class SSLCherryPyServer(ServerAdapter):
def run(self, handler):
cert = SSL_CERT
privkey = SSL_PRIVKEY
server = WSGIServer((self.host, self.port), handler)
server.ssl_adapter = SecuredSSLServer(cert, privkey)
try:
server.start()
finally:
server.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.