code stringlengths 101 5.91M |
|---|
def number_double_double_solutions(vrblvl=0):
if (vrblvl > 0):
print('in number_double_double_solutions ...')
phc = get_phcfun()
aaa = pointer(c_int32(0))
bbb = pointer(c_int32(0))
ccc = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> number_double_dou... |
def lightgbm_eval_metric(ml_task, automl_eval_metric):
if (automl_eval_metric == 'user_defined_metric'):
return ('custom', automl_eval_metric)
metric_name_mapping = {BINARY_CLASSIFICATION: {'auc': 'auc', 'logloss': 'binary_logloss', 'f1': 'custom', 'average_precision': 'custom', 'accuracy': 'custom'}, M... |
def build_model(obs_space, action_space, args, device):
name = args.model
if ('single' in name):
model = A3C_Single(obs_space, action_space, args, device)
elif ('multi' in name):
model = A3C_Multi(obs_space, action_space, args, device)
model.train()
return model |
.xfail('env.PYPY')
def test_non_final_final():
with pytest.raises(TypeError) as exc_info:
class PyNonFinalFinalChild(m.IsNonFinalFinal):
pass
assert str(exc_info.value).endswith('is not an acceptable base type') |
def lang_type(filename):
if filename.endswith('.py'):
return 'Python'
elif filename.endswith('.go'):
return 'go'
elif filename.endswith('.proto'):
return 'go'
elif filename.endswith('.sh'):
return 'shell'
elif filename.endswith('.cc'):
return 'cpp'
elif fi... |
class SBXCrossoverTestCases(unittest.TestCase):
def test_should_constructor_assign_the_correct_probability_value(self):
crossover_probability = 0.1
crossover: SBXCrossover = SBXCrossover(crossover_probability, 2.0)
self.assertEqual(crossover_probability, crossover.probability)
def test_s... |
def save_git_diff_to_file(git_diff_file_path):
import subprocess
git_diff_file = open(git_diff_file_path, 'w')
p = subprocess.Popen(['git', 'diff', '--patch', 'HEAD'], stdout=git_diff_file)
p.wait() |
class Params():
def __init__(self, weight_path):
self.device = settings.torch_device()
self.weight_path = weight_path
self.batch_size = 200
self.num_batches = 100
time_run = strftime('%y-%m-%d_%H:%M:%S', gmtime())
f_name_weights = path.splitext(path.basename(self.weig... |
def vgg10_w4a4_radioml(target_platform=None):
target_platform = resolve_target_platform(target_platform)
driver_mode = get_driver_mode()
model_name = 'vgg10-radioml-w4a4'
filename = find_bitfile(model_name, target_platform)
fclk_mhz = 250.0
return FINNExampleOverlay(filename, driver_mode, _radio... |
class CNN(models.Sequential):
def __init__(self, input_shape, num_classes):
super().__init__()
self.add(layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
self.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.add(layers.MaxPooling2D(pool_size=(2,... |
class TrexSpoLoader(Loader):
def __init__(self, debug=False):
super().__init__()
self.debug = debug
def _load(self, path):
datas = load_json(path)
if self.debug:
datas = datas[0:100]
dataset = DataTable()
for data in tqdm(datas):
text = dat... |
def get_systems(user_id):
with closing(getDb().cursor(dictionary=True)) as cur:
sql = 'SELECT system_id, system_name, api_key, active\n FROM systems WHERE admin_user_id = %s'
cur.execute(sql, (user_id,))
return cur.fetchall() |
def double_estimated_distance(vrblvl=0):
if (vrblvl > 0):
print('in double_estimated_distance ...')
phc = get_phcfun()
apar = pointer(c_int32(0))
bvrb = pointer(c_int32(0))
cdist = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> double_estimated_distan... |
('weak_label')
class WeakLabelDatasetReader(DatasetReader):
def __init__(self, token_indexers: Dict[(str, TokenIndexer)]=None, split_sentences: bool=False) -> None:
super().__init__(lazy=False)
self.token_indexers = token_indexers
self.split_sentences = split_sentences
def text_to_instan... |
class CIFAR100_LT(CIFAR10_LT):
base_folder = 'cifar-100-python'
url = '
filename = 'cifar-100-python.tar.gz'
tgz_md5 = 'eb9058c3a382ffc7106e4002c42a8d85'
train_list = [['train', '16019d7e3df5f24257cddd939b257f8d']]
test_list = [['test', 'f0ef6b0ae62326f3e7ffdfab6717acfc']]
meta = {'filename'... |
.parametrize('time_limit', [3, 4, 5])
def test_rubiks_cube__done(time_limit: int) -> None:
env = RubiksCube(time_limit=time_limit)
(state, timestep) = env.reset(jax.random.PRNGKey(0))
action = env.action_spec().generate_value()
episode_length = 0
step_fn = jax.jit(env.step)
while (not timestep.l... |
def get_libc_version():
import platform
if (get_platform() != 'linux'):
return 'N/A'
return '-'.join(platform.libc_ver()) |
def ncbi_annotators(docs):
dict_core = set()
dict_core_exact = set()
with open('../Dependency/AutoNER_dicts/NCBI/dict_core.txt') as f:
for line in f.readlines():
line = line.strip().split()
term = tuple(line[1:])
if ((len(term) > 1) or (len(term[0]) > 3)):
... |
class DiffusionDetDatasetMapper():
def __init__(self, cfg, is_train=True):
if (cfg.INPUT.CROP.ENABLED and is_train):
self.crop_gen = [T.ResizeShortestEdge([400, 500, 600], sample_style='choice'), T.RandomCrop(cfg.INPUT.CROP.TYPE, cfg.INPUT.CROP.SIZE)]
else:
self.crop_gen = No... |
class DPTDepthModel(DPT):
def __init__(self, path=None, non_negative=True, scale=1.0, shift=0.0, invert=False, **kwargs):
features = (kwargs['features'] if ('features' in kwargs) else 256)
self.scale = scale
self.shift = shift
self.invert = invert
head = nn.Sequential(nn.Conv... |
def convert_document_to_read_ready_string(path_read, path_write, fname_without_suffix: str, grammar, rules=None, max_sent=40, data_name='dm', merge_sz=5, depth=3, topk=10, set_of_del=[1, 2]):
doc_file = os.path.join(path_read, (fname_without_suffix + '.doc.json'))
abs_file = os.path.join(path_read, (fname_witho... |
class ParallelTextAndSchemaCopyingPipeline(ParallelSchemaCopyingPipeline):
def _get_copying_decoder(self, tokens_feature_name, length_feature_name, prepend_token, append_token, delimiter):
return copying_decoder.SchemaAndWordCopyingDecoder(tokens_feature_name=tokens_feature_name, length_feature_name=length_... |
def set_seed(seed):
if (seed is not None):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
random.seed(seed)
np.random.seed(seed) |
def mnasnet1_3(pretrained: bool=False, progress: bool=True, **kwargs: Any) -> MNASNet:
model = MNASNet(1.3, **kwargs)
if pretrained:
_load_pretrained('mnasnet1_3', model, progress)
return model |
def build_model(num_chars, embedding_vector_length, maxlen):
model = Sequential()
model.add(Embedding(num_chars, embedding_vector_length, input_length=maxlen))
model.add(Bidirectional(LSTM(256, dropout=0.3, recurrent_dropout=0.3, return_sequences=True)))
model.add(Bidirectional(LSTM(256, dropout=0.3, re... |
def test_r2r_vln_dataset():
vln_config = get_config(CFG_TEST)
if (not r2r_vln_dataset.VLNDatasetV1.check_config_paths_exist(vln_config.DATASET)):
pytest.skip('Please download Matterport3D R2R dataset to data folder.')
dataset = make_dataset(id_dataset=vln_config.DATASET.TYPE, config=vln_config.DATAS... |
def efficientnet_b7b(in_size=(600, 600), **kwargs):
return get_efficientnet(version='b7', in_size=in_size, tf_mode=True, bn_eps=0.001, model_name='efficientnet_b7b', **kwargs) |
def test_builtin_key_type():
if hasattr(__builtins__, 'keys'):
keys = __builtins__.keys()
else:
keys = __builtins__.__dict__.keys()
assert ({type(k) for k in keys} == {str}) |
def standard_pade_coefficients(idx):
from phcpy.phcpy2c3 import py2c_padcon_standard_numerator_coefficient
from phcpy.phcpy2c3 import py2c_padcon_standard_denominator_coefficient
numdeg = get_degree_of_numerator()
dendeg = get_degree_of_denominator()
numcfs = []
for col in range((numdeg + 1)):
... |
class LegacySubMobileResnetGenerator(BaseNetwork):
def __init__(self, input_nc, output_nc, config, norm_layer=nn.BatchNorm2d, dropout_rate=0, n_blocks=9, padding_type='reflect'):
assert (n_blocks >= 0)
super(LegacySubMobileResnetGenerator, self).__init__()
if (type(norm_layer) == functools.p... |
def get_subsequent_mask(seq):
(sz_b, len_s) = seq.size()
mask = (torch.triu(torch.ones(len_s, len_s)) == 1).transpose(0, 1)
mask = mask.float().masked_fill((mask == 0), float('-inf')).masked_fill((mask == 1), float(0.0))
return mask |
def init_detector(config, checkpoint=None, device='cuda:0', cfg_options=None):
if isinstance(config, (str, Path)):
config = mmcv.Config.fromfile(config)
elif (not isinstance(config, mmcv.Config)):
raise TypeError(f'config must be a filename or Config object, but got {type(config)}')
if (cfg_... |
class Prediction():
def __init__(self, fname, gpu=0):
self.gpu = gpu
self.model = PretrainedWav2VecModel(fname).cuda(gpu)
def __call__(self, x):
x = torch.from_numpy(x).float().cuda(self.gpu)
with torch.no_grad():
(z, c) = self.model(x.unsqueeze(0))
return (z.... |
class TestBasicTuningStrategy(unittest.TestCase):
def setUpClass(self):
self.constant_graph = build_fake_model()
build_fake_yaml()
build_fake_yaml2()
build_fake_yaml3()
build_fake_yaml4()
build_fake_yaml_recipe()
def tearDownClass(self):
os.remove('fake_ya... |
def _dict_generator(nested_vals):
iters = {k: iter(nested_generator(v)) for (k, v) in nested_vals.items()}
try:
while True:
(yield {k: next(i) for (k, i) in iters.items()})
except StopIteration:
pass |
def log_results(results, dataset, main_logger, test=False):
if test:
pre = 'test'
else:
pre = 'val'
main_logger.info('{}: Caption to audio: r1: {:.2f}, r5: {:.2f}, r10: {:.2f}, r50: {:.2f}, medr: {:.2f}, meanr: {:.2f}, mAP10: {:.3f}'.format(dataset, *results['t2a']))
main_logger.info('{}... |
def main():
pygame.init()
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()
running = True
font = pygame.font.SysFont('Arial', 16)
sound = pygame.mixer.Sound('sfx.wav')
img = pygame.image.load('xmasgirl1.png')
space = pymunk.Space()
space.gravity = (0, (- ... |
class parentWrapperPotential():
def __new__(cls, *args, **kwargs):
if kwargs.pop('_init', False):
return object.__new__(cls)
pot = kwargs.get('pot', None)
if (_dim(pot) == 2):
parentWrapperPotential = planarWrapperPotential
elif (_dim(pot) == 3):
p... |
class HGNN_conv(nn.Module):
def __init__(self, in_ft, out_ft, bias=True):
super(HGNN_conv, self).__init__()
self.weight = Parameter(torch.Tensor(in_ft, out_ft))
if bias:
self.bias = Parameter(torch.Tensor(out_ft))
else:
self.register_parameter('bias', None)
... |
def make_iterable(target, library='torch'):
import tensorflow as tf
import torch
tensor_checker = (torch.is_tensor if (library == 'torch') else tf.is_tensor)
def flatten(target):
if ((not hasattr(target, '__iter__')) or tensor_checker(target)):
(yield target)
else:
... |
class AdvCheckpointHook(CheckpointHook):
def __int__(self, **kwargs):
super(AdvCheckpointHook, self).__init__(**kwargs)
_only
def after_train_epoch(self, runner):
if (not self.every_n_epochs(runner, self.interval)):
return
if (not self.out_dir):
self.out_dir =... |
class MeanSigmaMetricLogger(object):
def __init__(self, delimiter='\t', meter_creator=SmoothedValue):
from src.tools.logger import MetricLogger
self.mean_meters = MetricLogger(delimiter=delimiter, meter_creator=SmoothedValue)
self.sq_meters = MetricLogger(delimiter=delimiter, meter_creator=S... |
def _make_np_bool(arr):
if ((not isinstance(arr, list)) and (not isinstance(arr, np.ndarray))):
arr = np.asarray([arr]).astype(np.bool)
elif isinstance(arr, list):
arr = np.asarray(arr).astype(np.bool)
elif (arr.dtype != np.bool):
arr = arr.astype(np.bool)
return arr |
def test_digits_cosine_greedi_ln():
model = SaturatedCoverageSelection(100, 'cosine', optimizer='greedi', optimizer_kwds={'optimizer1': 'lazy', 'optimizer2': 'naive'}, random_state=0)
model.fit(X_digits)
assert_array_equal(model.ranking[:2], digits_cosine_greedi_ranking[:2])
assert_array_almost_equal(mo... |
class MyUnpickler(pickle.Unpickler):
def find_class(self, module, name):
return pickle.Unpickler.find_class(self, PickleMapName(module), PickleMapName(name)) |
def main(argv):
trainIds = False
try:
(opts, args) = getopt.getopt(argv, 'ht')
except getopt.GetoptError:
printError('Invalid arguments')
for (opt, arg) in opts:
if (opt == '-h'):
printHelp()
sys.exit(0)
elif (opt == '-t'):
trainIds = T... |
def make_data_loader(cfg):
(train_spatial_transforms, _) = build_transforms_ST(cfg, is_train=True)
(val_spatial_transforms, val_temporal_transforms) = build_transforms_ST(cfg, is_train=False)
num_workers = cfg.DATALOADER.NUM_WORKERS
if (cfg.MODEL.SETTING == 'video'):
dataset = init_dataset(cfg.D... |
class CLIPTextConfig(PretrainedConfig):
model_type = 'clip_text_model'
def __init__(self, vocab_size=49408, hidden_size=512, intermediate_size=2048, num_hidden_layers=12, num_attention_heads=8, max_position_embeddings=77, hidden_act='quick_gelu', layer_norm_eps=1e-05, dropout=0.0, attention_dropout=0.0, initial... |
class HumanUser(User):
def __init__(self):
super(User, self).__init__()
def _prompt_response():
response = None
while (not response):
response = input('USER> ')
return response
def init_dialog(self):
return self._prompt_response()
def generate_response... |
class TestMaskedLM(unittest.TestCase):
def test_masks_tokens(self):
with TemporaryDirectory() as dirname:
raw_file = os.path.join(dirname, 'raw')
data = make_data(out_file=raw_file)
vocab = build_vocab(data)
binarizer = VocabularyDatasetBinarizer(vocab, append... |
def preprocess(tbl):
tbl = tbl.fillna('', 'present_media')
tbl = tbl.cast((bool_cols + count_cols), 'int')
tbl = tbl.cut_bins(columns=count_cols, bins=[1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, .0], out_cols=count_cols)
if ('present_media' in cat_cols):
process_media = (lambda x: '_'.join(... |
class SemiPrimalDualTrainer(SemiEntropyTrainer):
def __init__(self, model: Model, labeled_loader: DataLoader, unlabeled_loader: DataLoader, val_loader: DataLoader, max_epoch: int=100, save_dir: str='base', checkpoint_path: str=None, device='cpu', config: dict=None, max_iter: int=100, prior: Tensor=None, inverse_kl=... |
def _create_dummy_dict_file(dict_file):
dict_str = '0123'
list_to_file(dict_file, list(dict_str)) |
.parametrize(['tree', 'i', 'element', 'expected_tree'], [((jnp.array([3, 6]),), 1, (1,), (jnp.array([3, 1]),)), ({'a': jnp.array([0, 1]), 'b': (jnp.array([(- 1), (- 1)]),)}, 0, {'a': 4, 'b': (2,)}, {'a': jnp.array([4, 1]), 'b': (jnp.array([2, (- 1)]),)})])
def test_tree_add_element(tree: T, i: chex.Numeric, element: T,... |
.register('ShuffleNetV2')
class ShuffleNetV2(BaseRecognizer):
def __init__(self, cfg):
super().__init__(cfg)
def _init_weights(self, cfg):
pretrained_local = cfg.MODEL.RECOGNIZER.PRETRAINED_LOCAL
pretrained_num_classes = cfg.MODEL.RECOGNIZER.PRETRAINED_NUM_CLASSES
num_classes = c... |
def preprocess_tf(x):
(batch, height, width, channels) = x.shape
x = tf.cast(x, tf.float32)
mean_tensor = np.asarray([[[[127.5, 127.5, 127.5]]]], dtype=np.float32)
one_tensor = np.asarray([[[[1.0, 1.0, 1.0]]]], dtype=np.float32)
x = tf.keras.backend.reshape(x, ((- 1), 3))
result = ((x / mean_ten... |
def adjust_opt(optimizer, epoch):
lr = np.interp(epoch, knots, vals)
for param_group in optimizer.param_groups:
param_group['lr'] = lr |
def _best_distance(a_feature, pos_features, squared_d_dists, d_max_squared, f_max_squared):
(scaled_d_dists, scaled_f_dists) = _scale_distances(a_feature, pos_features, squared_d_dists, d_max_squared, f_max_squared)
squared_diffs = tf.squared_difference(scaled_f_dists, scaled_d_dists)
return tf.reduce_min(s... |
class MegaForMaskedLM(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def convert_mzml_ipc(source: Path, target: Path, max_charge: int=10, use_old_schema: bool=False, verbose: bool=True) -> None:
schema = {'experiment_name': str, 'evidence_index': int, 'scan_number': int, 'sequence': str, 'modified_sequence': str, 'precursor_mass': float, 'precursor_mz': pl.Float64, 'precursor_charge... |
class Model():
name = 'alexnet'
kernels = 29
baseidle = 0.1
act_popt = []
l2cache = 0
powers = []
k_l2 = 1
tmpl2cache = 0
transferdata = 1000
def p(self):
print(self.name, self.kernels, self.baseidle, self.act_popt, self.l2cache, self.k_l2) |
class ToyConvNeXt(nn.Module):
def __init__(self):
super().__init__()
self.stages = nn.ModuleList()
for i in range(4):
stage = nn.Sequential(ConvModule(3, 4, kernel_size=1, bias=True))
self.stages.append(stage)
self.norm0 = nn.BatchNorm2d(2)
self.cls_to... |
class _cuda_SO3_mm(torch.autograd.Function):
def forward(ctx, x, y):
assert (x.is_cuda and (x.dtype == torch.float32))
assert (y.is_cuda and (y.dtype == torch.float32))
assert (y.size(3) == 2)
assert (x.size(3) == 2)
nbatch = x.size(1)
nfeature_in = x.size(2)
... |
def generate_model(input_shape_cdr3, num_outputs, filter_size):
features_cdr3 = Input(shape=input_shape_cdr3)
features_quantity = Input(shape=[])
feature_age = Input(batch_shape=[1])
weight = Input(batch_shape=[1])
level = Input(batch_shape=[1])
features_mask = Masking(mask_value=0.0)(features_c... |
_registry(pattern_type='TextEncoder_AttentionReshape')
class TextEncoder_AttentionReshape(Pattern):
def __call__(self, model):
pattern_mapping_config = {'TextEncoder_AttentionReshape': [{'patterns': {'in': [[(0, 'Shape'), (1, 'Gather'), (2, 'Unsqueeze'), (9, 'Concat'), (10, 'Reshape'), (11, 'MatMulWithBias'... |
def _get_train_val_test_data(corpus, batch_size):
return [_batchify(corpus.train, batch_size), _batchify(corpus.valid, batch_size), _batchify(corpus.test, batch_size)] |
def construct_primitive_prompt(summary, objects):
primitive_prompt_template = '# Summary: Pick and place clothes, pick and toss snacks.\nobjects = ["granola bar", "hat", "toy car", "Lego brick", "fruit snacks", "shirt"]\npick_and_toss("granola bar")\npick_and_place("hat")\npick_and_place("toy car")\npick_and_place(... |
class AlexNet(nn.Module):
def __init__(self, args):
super(AlexNet, self).__init__()
self.taskcla = args.taskcla
self.features = AlexNetFeature(args)
self.last_dim = self.features.fc2.out_features
self.classifier = nn.ModuleList()
for (t, n) in self.taskcla:
... |
class TestTensorflowGpu(unittest.TestCase):
mb_model_url = '
pb_path = '/tmp/.neural_compressor/mobilenet_fp32.pb'
platforms = platform.system().lower()
if (platforms == 'windows'):
pb_path = 'C:\\tmp\\.neural_compressor\\mobilenet_fp32.pb'
def setUpClass(cls):
sys.meta_path.insert(0... |
class LearnedPositionalEmbedding(nn.Embedding):
def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int):
super().__init__(num_embeddings, embedding_dim, padding_idx)
self.onnx_trace = False
def forward(self, input, incremental_state=None, positions=None):
assert ((p... |
def _is_tpu_tensor(tensor):
if (not isinstance(tensor, ops.Tensor)):
return False
try:
tensor.op.get_attr(tpu._OUTSIDE_COMPILATION_ATTR)
except ValueError:
return True
else:
return False |
def convert_dataset(data_dir, tfrecords_dir, tfrecords_name, redo_matching=True, remove_zeros=True, policy='autopilot'):
print(f'Reading dataset from {data_dir}')
print(f'TFRecord will be saved at {tfrecords_dir}/{tfrecords_name}')
if (policy == 'autopilot'):
processed_frames_file_name = 'matched_fr... |
def _sgdr_learning_rate(name):
return hp.pchoice(name, [(0.5, 'invscaling'), (0.25, 'optimal'), (0.25, 'constant')]) |
def interactively_kill_instances(instance_killer):
while True:
instances = instance_killer.get_running_instances()
if (not instances):
print('No instances to kill!')
return
print('Active instances:')
for (i, instance) in enumerate(instances):
print... |
def run_uncertainty(image_folder):
subj_acq_lst = [file.name.split('_pred')[0] for file in Path(image_folder).iterdir() if (file.name.endswith('.nii.gz') and ('_pred' in file.name))]
subj_acq_lst = list(set(subj_acq_lst))
subj_acq_lst = [file for file in subj_acq_lst if (not Path(image_folder, (file + '_unc... |
def make_chain():
chain = [1]
while (chain[(- 1)] != states[(- 1)]):
choices = transitions[chain[(- 1)]]
j = np.random.randint(len(choices))
chain.append(choices[j])
return chain |
_legacy_interface(weights=('pretrained', EfficientNet_B6_Weights.IMAGENET1K_V1))
def efficientnet_b6(*, weights: Optional[EfficientNet_B6_Weights]=None, progress: bool=True, **kwargs: Any) -> EfficientNet:
weights = EfficientNet_B6_Weights.verify(weights)
(inverted_residual_setting, last_channel) = _efficientne... |
def print_dag_chart(dag_file: str, path: str, dag: str):
dag_pic = '{}_{}.png'.format(dag, 'pic')
cmd = 'python {} output-dot | dot -Tpng -o {}/{}'.format(dag_file, path, dag_pic)
os.system(cmd)
return dag_pic |
def build_and_train(slot_affinity_code, log_dir, run_ID, config_key):
affinity = affinity_from_code(slot_affinity_code)
config = configs[config_key]
variant = load_variant(log_dir)
config = update_config(config, variant)
sampler = SerialSampler(EnvCls=gym_make, env_kwargs=config['env'], CollectorCls... |
class BasicConv(nn.Module):
def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True, bn=True, bias=False):
super(BasicConv, self).__init__()
self.out_channels = out_planes
self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size... |
def parse_xml(args):
(xml_path, img_path) = args
tree = ET.parse(xml_path)
root = tree.getroot()
size = root.find('size')
w = int(size.find('width').text)
h = int(size.find('height').text)
bboxes = []
labels = []
bboxes_ignore = []
labels_ignore = []
for obj in root.findall('... |
def compute_in_batches(f, calc_batch_size, *args, n=None):
if (n is None):
n = args[0].size(0)
n_batches = (((n + calc_batch_size) - 1) // calc_batch_size)
if (n_batches == 1):
return f(*args)
all_res = [f(*(arg[(i * calc_batch_size):((i + 1) * calc_batch_size)] for arg in args)) for i i... |
def iob2bio(iob_labels):
bio_labels = []
for (prev_label, cur_label) in zip((['O'] + iob_labels[:(- 1)]), iob_labels):
if (((prev_label[0] == 'O') and (cur_label[0] == 'I')) or ((prev_label[0] != 'O') and (cur_label[0] == 'I') and (prev_label[2:] != cur_label[2:]))):
bio_labels.append(('B' +... |
def plot_pictures(indexes: list, images=all_images, labels=all_labels):
num_pics = len(indexes)
(_, axarr) = plt.subplots(1, num_pics)
for (idx, im_idx) in enumerate(indexes):
assert (idx < 10000), 'Cannot get such index, there are only 10000'
pic = np.rollaxis(images[im_idx].squeeze().numpy... |
def convert_size(size_bytes: int):
if (size_bytes == 0):
return '0B'
size_name = ('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB')
i = int(math.floor(math.log(size_bytes, 1024)))
p = math.pow(1024, i)
s = round((size_bytes / p), 2)
return ('%s %s' % (s, size_name[i])) |
def bloom_tokenize(ctx: c_void_p, prompt: bytes, bos: bool=False) -> List[int]:
n_tokens = c_int(0)
c_tokens = _lib.tokenize_api(ctx, prompt, bos, pointer(n_tokens))
tokens = [c_tokens[i] for i in range(0, n_tokens.value)]
c_free(c_tokens)
return tokens |
def load_config(path: Union[(Path, str)]='configs/default.yaml') -> Dict:
if isinstance(path, str):
path = Path(path)
with path.open('r', encoding='utf-8') as ymlfile:
cfg = yaml.safe_load(ymlfile)
return cfg |
def cc(net):
device = torch.device(('cuda' if torch.cuda.is_available() else 'cpu'))
return net.to(device) |
def train_and_eval():
(train_generator, test_generator, train_size, test_size, input_num, dims_num) = build_dataset(batch_size)
print('train_size {}, test_size {}, input_num {}, dims_num {}'.format(train_size, test_size, input_num, dims_num))
train(train_generator, train_size, input_num, dims_num)
test(... |
def init_device(args, local_rank):
global logger
device = torch.device(('cuda' if torch.cuda.is_available() else 'cpu'), local_rank)
n_gpu = torch.cuda.device_count()
logger.info('device: {} n_gpu: {}'.format(device, n_gpu))
args.n_gpu = n_gpu
if (((args.batch_size % args.n_gpu) != 0) or ((args.... |
def diaresnet20_svhn(num_classes=10, **kwargs):
return get_diaresnet_cifar(num_classes=num_classes, blocks=20, bottleneck=False, model_name='diaresnet20_svhn', **kwargs) |
def _sync_variables_ops():
return [array_ops.check_numerics(v.read_value(), ('Gradient for %s is NaN' % v.name)).op for v in variables.trainable_variables()] |
def initialize_weights(shape, name, init_type, gain='1.0', divisor=1.0):
if (init_type == 'random'):
return tf.get_variable(name, initializer=tf.truncated_normal(shape, stddev=0.1))
if (init_type == 'xavier'):
return tf.get_variable(name, shape=shape, initializer=tf.contrib.layers.xavier_initial... |
class CocoDistEvalMRHook(DistEvalHook):
def __init__(self, dataset, interval=1, res_types=['bbox']):
super().__init__(dataset, interval)
self.res_types = res_types
def evaluate(self, runner, results):
tmp_file = osp.join(runner.work_dir, 'temp_0')
result_files = results2json(self... |
def contract(a, sequence, axis=0, dimension=None):
shape = np.array(a.shape)
ii = [slice(i) for i in shape]
jj = copy.deepcopy(ii)
if (axis == (- 1)):
axis += a.ndim
axis_dimension = (np.amax(sequence) + 1)
if (dimension is None):
dimension = axis_dimension
else:
asse... |
def clear_quad_double_track_data(vrblvl=0):
if (vrblvl > 0):
print('in clear_quad_double_track_data ...')
phc = get_phcfun()
aaa = pointer(c_int32(0))
bbb = pointer(c_int32(0))
ccc = pointer(c_double(0.0))
vrb = c_int32(vrblvl)
if (vrblvl > 0):
print('-> clear_quad_double_tra... |
def generate_weights_batch(n_dim, delta_weight):
weights_batch = []
generate_weights_batch_dfs(0, n_dim, 0.0, 1.0, delta_weight, [], weights_batch)
return np.array(weights_batch) |
.parametrize('kwargs', [dict(embedding_sizes=(10, 10, 10)), dict(embedding_sizes=((10, 3), (10, 2), (10, 1))), dict(x_categoricals=['x1', 'x2', 'x3'], embedding_sizes=dict(x1=(10, 10))), dict(x_categoricals=['x1', 'x2', 'x3'], embedding_sizes=dict(x1=(10, 2), xg1=(10, 3)), categorical_groups=dict(xg1=['x2', 'x3']))])
d... |
def MobileNet(input_shape=None, alpha=1.0, depth_multiplier=1, dropout=0.001, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000):
if (not ((weights in {'imagenet', None}) or os.path.exists(weights))):
raise ValueError('The `weights` argument should be either `None` (random ... |
def swap_layer_connection(old_layer: Layer, new_layer: Layer) -> None:
inbound_layers = set()
for node in old_layer._inbound_nodes:
Node(new_layer, node.inbound_layers, node.node_indices, node.tensor_indices, node.input_tensors, node.output_tensors, node.input_masks, node.output_masks, node.input_shapes... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.