code stringlengths 101 5.91M |
|---|
def test_type_tracing_max_depth_after_get_attr():
mock = MagicMock()
mock.foo = mock
proxy = tt.ObjectProxy(mock)
for i in range((tt._MAX_PROXY_NESTING + 1)):
proxy = proxy.foo
assert (not isinstance(proxy, tt.ObjectProxy)) |
.parametrize('teacher,student', [(likelihood, AbsLikelihood(y=None)) for likelihood in LIKELIHOODS])
def test_likelihood_grad_RS(teacher, student):
df = check_likelihood_grad_RS(teacher, student)
assert_allclose(df['mz'], df['grad_mz_hat_A'], rtol=0, atol=EPSILON)
assert_allclose(df['qz'], ((- 2) * df['grad... |
class DataManager(object):
def __init__(self, data, num_epoch, batch_size, *, shuffle=True, align=False, simple=True, infinite=False):
self.data = data
self.data_length = len(data)
self.num_epochs = num_epoch
self.batch_size = batch_size
self.cur_epoch = 1
self.cur_ba... |
def generate_csrf(secret_key=None, token_key=None):
secret_key = _get_config(secret_key, 'WTF_CSRF_SECRET_KEY', current_app.secret_key, message='A secret key is required to use CSRF.')
field_name = _get_config(token_key, 'WTF_CSRF_FIELD_NAME', 'csrf_token', message='A field name is required to use CSRF.')
i... |
_assert
class LocLabel(Node):
def __init__(self, loc_id_str: str) -> None:
super().__init__()
self.loc_id_str = loc_id_str.strip()
def id(self):
if (len(self.loc_id_str) == 4):
return (- 1)
return int(self.loc_id_str[4:])
def dump(self):
return f'loc({self... |
def test_setup_path_invalid_dir(tmp_path):
gen.set_configuration(configuration=MagicMock(log_file=None, project_path=(tmp_path / 'nope')))
assert (gen._setup_path() is False) |
def reduce_max(seq_batch):
sums = tf.reduce_sum(seq_batch.mask, 1, keep_dims=True)
with tf.control_dependencies([tf.assert_positive(sums)]):
seq_batch = seq_batch.with_pad_value(float('-inf'))
result = tf.reduce_max(seq_batch.values, 1)
return result |
class SE_Block(nn.Module):
def __init__(self, c, r=16):
super().__init__()
self.squeeze = nn.AdaptiveAvgPool2d(1)
self.excitation = nn.Sequential(nn.Linear(c, (c // r), bias=False), nn.ReLU(inplace=True), nn.Linear((c // r), c, bias=False), nn.Sigmoid())
def forward(self, x):
(bs... |
class EdgeAndMatcher(BaseEdgeMatcher):
def __init__(self, matcher_a: BaseEdgeMatcher, matcher_b: BaseEdgeMatcher):
self.matcher_a = matcher_a
self.matcher_b = matcher_b
def apply(self, input_object) -> bool:
return (self.matcher_a.apply(input_object) and self.matcher_b.apply(input_object... |
class UnetGenerator(nn.Module):
def __init__(self, input_nc, output_nc, num_downs, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, att_mode=False):
super(UnetGenerator, self).__init__()
unet_block = UnetSkipConnectionBlock((ngf * 8), (ngf * 8), input_nc=None, submodule=None, norm_layer=norm_la... |
class Status(object):
Waiting = 'waiting'
Chat = 'chat'
Finished = 'finished'
Survey = 'survey'
Redirected = 'redirected'
Incomplete = 'incomplete'
Reporting = 'reporting' |
class ScalarTrackingFunctional(Functional):
def __init__(self, integrand: ufl.Form, tracking_goal: Union[(float, int, ctypes.c_float, ctypes.c_double)], weight: Union[(float, int)]=1.0) -> None:
super().__init__()
self.integrand = integrand
self.tracking_goal = tracking_goal
if (not ... |
def _cfg(url=''):
return {'url': url, 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': (7, 7), 'crop_pct': 0.875, 'interpolation': 'bicubic', 'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD, 'first_conv': 'stem.0.conv', 'classifier': 'head.fc'} |
_grad()
def calculate_lpips_intervals(group_of_images, intervals):
device = torch.device(('cuda' if torch.cuda.is_available() else 'cpu'))
lpips = LPIPS().eval().to(device)
lpips_values = [[] for _ in range(len(intervals))]
inr_idx = {i: j for (j, i) in enumerate(intervals)}
num_rand_outputs = len(g... |
def run_se(a0, alpha, prior_rho, prior_mean):
model = glm_state_evolution(alpha=alpha, prior_type='gauss_bernoulli', output_type='abs', prior_rho=prior_rho, prior_mean=prior_mean)
a_init = [('x', 'bwd', a0)]
initializer = CustomInit(a_init=a_init)
records = run_state_evolution(x_ids=['x', 'z'], model=mo... |
def get_args():
parser = argparse.ArgumentParser()
ffn_train.add_ffn_train_args(parser)
nn_utils.add_hyperopt_args(parser)
return parser.parse_args() |
class LitDataset(Dataset):
def __init__(self, dataset, use_lab=True):
self.dataset = dataset
self.use_lab = use_lab
self.dlcj_transform = transforms.Compose([transforms.RandomApply([transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.2, hue=0.2)], p=0.8), transforms.RandomGrays... |
def run_thread(iteration_dir, design_file, opt):
opt_dir = os.path.join(iteration_dir, opt)
(opt_file, delay, area) = run_optimization(opt_dir, opt, design_file, library_file)
log(((((('Optimization: ' + opt) + ' -> delay: ') + str(delay)) + ', area: ') + str(area)))
return (opt, opt_file, delay, area) |
class CriterionCrossEntropy(nn.Module):
def __init__(self, ignore_index=255):
super(CriterionCrossEntropy, self).__init__()
self.ignore_index = ignore_index
self.criterion = torch.nn.CrossEntropyLoss(ignore_index=ignore_index)
def forward(self, preds, target):
(h, w) = (target.si... |
def finish(config: DictConfig, model: pl.LightningModule, datamodule: pl.LightningDataModule, trainer: pl.Trainer, callbacks: List[pl.Callback], logger: List[pl.loggers.LightningLoggerBase]) -> None:
for lg in logger:
if isinstance(lg, WandbLogger):
wandb.finish() |
def _find_compiler_bindir():
patterns = ['C:/Program Files (x86)/Microsoft Visual Studio/*/Professional/VC/Tools/MSVC/*/bin/Hostx64/x64', 'C:/Program Files (x86)/Microsoft Visual Studio/*/BuildTools/VC/Tools/MSVC/*/bin/Hostx64/x64', 'C:/Program Files (x86)/Microsoft Visual Studio/*/Community/VC/Tools/MSVC/*/bin/Hos... |
def anti_wrapping_function(x):
return torch.abs((x - ((torch.round((x / (2 * np.pi))) * 2) * np.pi))) |
def extract_frames(filename: str, save_dir: str, transforms: transforms.Compose=None) -> None:
basename = os.path.basename(filename)
if (not os.path.exists(filename)):
raise FileNotFoundError(('%s does not exist!' % filename))
print(('Decomposing %s.' % filename))
capture = cv2.VideoCapture(file... |
def pytest_configure(config):
config.addinivalue_line('markers', 'gpu: run opencl-based tests on the gpu')
_limit_tf_gpu_memory() |
def filter_class(dataset, classes):
(data, labels) = (dataset.data, dataset.targets)
if (type(labels) == list):
labels = torch.tensor(labels)
data_filter = []
labels_filter = []
for _class in classes:
idx = (labels == _class)
data_filter.append(data[idx])
labels_filte... |
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
cfg = replace_cfg_vals(cfg)
update_data_root(cfg)
if (args.cfg_options is not None):
cfg.merge_from_dict(args.cfg_options)
if args.auto_scale_lr:
if (('auto_scale_lr' in cfg) and ('enable' in cfg.auto_scale_lr) an... |
def _get_next_run_id_local(run_dir_root: str) -> int:
dir_names = [d for d in os.listdir(run_dir_root) if os.path.isdir(os.path.join(run_dir_root, d))]
r = re.compile('^\\d+')
run_id = 0
for dir_name in dir_names:
m = r.match(dir_name)
if (m is not None):
i = int(m.group())
... |
def grid_points_in_poly(shape, verts, binarize=True):
output = _grid_points_in_poly(shape, verts)
if binarize:
output = output.astype(bool)
return output |
def write_cpp_head(f, chip, file_name):
cpp_head = f'''// ====- {chip.lower()}RefDef.cpp - {chip.upper()} register definition
//
// Copyright (C) 2022 Sophgo Technologies Inc. All rights reserved.
//
// TPU-MLIR is licensed under the 2-Clause BSD License except for the
// third-party components.
//
//
//
// auto... |
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--input_json', type=str, default='data/coco.json', help='path to the json file containing additional info and vocab')
parser.add_argument('--input_fc_dir', type=str, default='data/cocotalk_fc', help='path to the directory containing th... |
def _seg_20():
return [(8093, 'M', u''), (8094, 'M', u''), (8095, 'M', u''), (8096, 'M', u''), (8097, 'M', u''), (8098, 'M', u''), (8099, 'M', u''), (8100, 'M', u''), (8101, 'M', u''), (8102, 'M', u''), (8103, 'M', u''), (8104, 'M', u''), (8105, 'M', u''), (8106, 'M', u''), (8107, 'M', u''), (8108, 'M', u''), (8109... |
def subsample_dataset(dataset, idxs):
mask = np.zeros(len(dataset)).astype('bool')
mask[idxs] = True
dataset.data = dataset.data[mask]
dataset.uq_idxs = dataset.uq_idxs[idxs]
return dataset |
class storage():
instance = None
client = None
def __init__(self):
self.client = BlobServiceClient.from_connection_string(os.getenv('STORAGE_CONNECTION_STRING'))
def unique_name(name):
(name, extension) = os.path.splitext('.')
return '{name}.{random}.{extension}'.format(name=name... |
def test_extract_nodes_dups():
modela = ModelA()
modelb = ModelB()
modela.ref_field = modelb
modela.ref_field2 = modelb
model_list = []
schema._extract_nodes(modela, model_list)
assert (len(model_list) == 2)
assert (modela in model_list)
assert (modelb in model_list) |
class TrainingStats(object):
def __init__(self, misc_args, log_period=20, tensorboard_logger=None):
self.misc_args = misc_args
self.LOG_PERIOD = log_period
self.tblogger = tensorboard_logger
self.tb_ignored_keys = ['iter', 'eta']
self.iter_timer = Timer()
self.WIN_SZ ... |
def _forward_from_src(src: str):
gbls: Dict[(str, Any)] = {'torch': torch}
exec_with_source(src, gbls)
return gbls['forward'] |
def verify_plan(source_models, pred_models, plan):
if (not all(((m in source_models) for m in pred_models))):
print('Not all pred_models are in source_models.')
return False
for (i, pl) in enumerate(plan):
if (pl[0][0] == 'RST'):
pl_models = set(pl[0][2])
elif (i == 0... |
def convert_doc_to_sciie_format(input_dict):
processed_sentences = []
for doc_id in input_dict:
content = input_dict[doc_id]
content = clean_raw_input.clean_dict(content)
for (sent_id, sentence) in content.items():
sent_dict = {'clusters': [], 'doc_key': ((doc_id + '_') + str... |
def block_reduction_a(inputs, scope=None, reuse=None):
with slim.arg_scope([slim.conv2d, slim.avg_pool2d, slim.max_pool2d], stride=1, padding='SAME'):
with tf.variable_scope(scope, 'BlockReductionA', [inputs], reuse=reuse):
with tf.variable_scope('Branch_0'):
branch_0 = slim.conv... |
def incomplete_orthogonal_array(k, n, holes, resolvable=False, existence=False):
from sage.combinat.designs.database import QDM
for h in holes:
if (h < 0):
raise ValueError('Holes must have size >=0, but {} was in the list').format(h)
holes = [h for h in holes if (h > 0)]
if (not hol... |
class AccuracyRobustnessBenchmark():
def __init__(self, dataset, burnin=10):
self.dataset = dataset
self.burnin = burnin
def eval(self, eval_trackers=None):
if (eval_trackers is None):
eval_trackers = self.dataset.tracker_names
if isinstance(eval_trackers, str):
... |
_utils.test()
def test_single_compare():
def foo(a: ti.template(), b: ti.template(), c: ti.template()):
for i in ti.static(range(3)):
c[(i * 6)] = (a[i] == b[i])
c[((i * 6) + 1)] = (a[i] != b[i])
c[((i * 6) + 2)] = (a[i] < b[i])
c[((i * 6) + 3)] = (a[i] <= b[i... |
def load_trained_lora_model(model_name_or_path: str, model_lora_path: str, model_cls: Optional[Type]=None, modalities: Optional[List[Modality]]=None, load_bits: int=16, device_map: str='auto'):
load_kwargs = {'device_map': device_map}
if (load_bits == 8):
load_kwargs['load_in_8bit'] = True
elif (loa... |
class PretrainDataset(data.Dataset):
PRETRAIN_DATA_LIST = ['COCO', 'ECSSD', 'MSRA10K', 'PASCAL-S', 'PASCALVOC2012']
sample_ratio = 1
def __init__(self, root, output_size, clip_n=3, max_obj_n=11, crop=False):
self.root = root
self.clip_n = clip_n
self.output_size = output_size
... |
class EvaluationUtilsTest(tf.test.TestCase):
def testEvaluate(self):
output = 'nmt/testdata/deen_output'
ref_bpe = 'nmt/testdata/deen_ref_bpe'
ref_spm = 'nmt/testdata/deen_ref_spm'
expected_bleu_score = 22.
expected_rouge_score = 50.
bpe_bleu_score = evaluation_utils.... |
def get_default_qconfig(backend='fbgemm'):
if (backend == 'fbgemm'):
qconfig = QConfig(activation=HistogramObserver.with_args(reduce_range=True), weight=default_per_channel_weight_observer)
elif (backend == 'qnnpack'):
qconfig = QConfig(activation=HistogramObserver.with_args(reduce_range=False),... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--data_path', default='dataset', help='path to datasets')
parser.add_argument('--margin', default=0.2, type=float, help='Rank loss margin.')
parser.add_argument('--num_epochs', default=2, type=int, help='Number of training epochs.')
... |
def Discriminator32(n_gpu, nc, ndf):
model = _netD32(n_gpu, nc, ndf)
model.apply(weights_init)
return model |
def find_cxx_compiler():
global CXX, CXX_COMPILERS
if (CXX is not None):
if test_cxx_compiler(CXX):
return CXX
for cxx in CXX_COMPILERS:
if test_cxx_compiler(cxx):
CXX = cxx
return CXX
raise MKException('C++ compiler was not found. Try to set the envir... |
def get_fid(fakes, model, npz, device, batch_size=1, use_tqdm=True):
(m1, s1) = (npz['mu'], npz['sigma'])
fakes = torch.cat(fakes, dim=0)
fakes = util.tensor2im(fakes).astype(float)
(m2, s2) = _compute_statistics_of_ims(fakes, model, batch_size, 2048, device, use_tqdm=use_tqdm)
return float(calculat... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [314])
def test_batch_det_forward_backward(seed, ctx, func_name):
from nbla_test_utils import function_tester
rng = np.random.RandomState(seed)
inputs = [np.clip(rng.randn(2, 3, 3).astype(np.float32), (- 0.9), 0.9)]
function_tester(rng, F.batch_d... |
('/predict', methods=['POST'])
def predict():
st = [str(x) for x in request.form.values()]
prediction = recommend(st[0])
pr = ((((((('1) ' + prediction[0][0]) + ' // ') + '2) ') + prediction[0][1]) + ' // ') + '3) ') + prediction[0][2])
return render_template('index.html', recommended='Recommended Title... |
class ResultFilter(base.Logger):
def __init__(self, to: base.Logger, game_name: str):
self._to = to
game_name = re.sub('(?<!^)(?=[A-Z])', '_', game_name).lower()
if (game_name in BASELINES):
random_score = BASELINES[game_name]['random']
dqn_score = BASELINES[game_name... |
def test_precomputed_nearest_neighbors_filtering():
(X, y) = make_blobs(n_samples=200, random_state=0, centers=[[1, 1], [(- 1), (- 1)]], cluster_std=0.01)
n_neighbors = 2
results = []
for additional_neighbors in [0, 10]:
nn = NearestNeighbors(n_neighbors=(n_neighbors + additional_neighbors)).fit... |
def test():
N = dp.symbol('N')
N.set(20)
input = dp.ndarray([N], dp.int32)
output = dp.ndarray([N], dp.int32)
input[:] = dp.int32(5)
output[:] = dp.int32(0)
mysdfg = SDFG('mysdfg')
state = mysdfg.add_state()
A_ = state.add_array('A', [N], dp.int32)
B_ = state.add_array('B', [N], ... |
def bmes_decode(char_label_list: List[Tuple[(str, str)]]) -> Tuple[(str, List[Tag])]:
idx = 0
length = len(char_label_list)
tags = []
while (idx < length):
(term, label) = char_label_list[idx]
current_label = label[0]
if (((idx + 1) == length) and (current_label == 'B')):
... |
((not have_sympy), 'SymPy not installed')
def test_conjugate():
x = Symbol('x')
e1 = sympy.conjugate(sympy.Symbol('x'))
e2 = conjugate(x)
assert (sympify(e1) == e2)
assert (e2._sympy_() == e1) |
class TestBirchAlgo():
def setup(self):
pass
def test_fit_none_input(self, empty_feature):
params = BirchParams()
detector = BirchAlgo(params)
assert isinstance(params, BirchParams), 'params must be BirchParams'
assert isinstance(detector, BirchAlgo), 'detector must be Bi... |
def wrap_generate_func(original_generate):
def _convert_generator(self, loop, args, kwargs):
async_gen = self.generate_async(*args, **kwargs)
try:
while 1:
(yield loop.run_until_complete(async_gen.__anext__()))
except StopAsyncIteration:
pass
def g... |
class ParallelRangeNode(ParallelStatNode):
child_attrs = ['body', 'target', 'else_clause', 'args', 'num_threads', 'chunksize']
body = target = else_clause = args = None
start = stop = step = None
is_prange = True
nogil = None
schedule = None
valid_keyword_arguments = ['schedule', 'nogil', 'n... |
class CategoricalJointVarField(CategoricalJointField):
def __init__(self, *args, **kwargs):
super().__init__(*args, field_type='varm', **kwargs) |
def eval1(mask_path, gt_path, m):
files = os.listdir(gt_path)
maes = 0
precesions = 0
recalls = 0
fmeasures = 0
for file in files:
mask1 = ((mask_path + '/') + file)
gt1 = ((gt_path + '/') + file)
mask1 = Image.open(mask1)
mask1 = mask1.resize((320, 320))
... |
_module()
class Darknet(nn.Module):
arch_settings = {53: ((1, 2, 8, 8, 4), ((32, 64), (64, 128), (128, 256), (256, 512), (512, 1024)))}
def __init__(self, depth=53, out_indices=(3, 4, 5), frozen_stages=(- 1), conv_cfg=None, norm_cfg=dict(type='BN', requires_grad=True), act_cfg=dict(type='LeakyReLU', negative_sl... |
class FlaxElectraModel(metaclass=DummyObject):
_backends = ['flax']
def __init__(self, *args, **kwargs):
requires_backends(self, ['flax']) |
def get_all_eval_values(llm_name):
agent_types = available_agent_names
for a_type in agent_types:
get_eval_values(llm_name, a_type) |
def get_audiosegment_from_nparray(nparr, frame_rate=48000):
audio_segment = AudioSegment(nparr.tobytes(), frame_rate=frame_rate, sample_width=nparr.dtype.itemsize, channels=nparr.shape[1])
return audio_segment |
def bbox_payload_parser(accessor, x1='bbox_x1', y1='bbox_y1', x2='bbox_x2', y2='bbox_y2'):
return dict_payload_parser(accessor, {'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2}) |
def test_reassembly_reference_failures():
bad_addition_tokenization = [['Joe', 'Smith', 'lives', 'in', 'Southern', 'California', '.']]
bad_addition_mwts = [[False for _ in range(len(bad_addition_tokenization[0]))]]
bad_addition_expansions = [[None for _ in range(len(bad_addition_tokenization[0]))]]
bad_... |
def register_Ns3WifiMode_methods(root_module, cls):
cls.add_binary_comparison_operator('==')
cls.add_output_stream_operator()
cls.add_constructor([param('ns3::WifiMode const &', 'arg0')])
cls.add_constructor([])
cls.add_constructor([param('std::string', 'name')])
cls.add_method('GetCodeRate', 'n... |
def check_train_sentences(raw_data, direction, all_test_data, mess_up_train={}):
(src, tgt) = direction.split('-')
tgt_path = f'{raw_data}/train.{direction}.{tgt}'
src_path = f'{raw_data}/train.{direction}.{src}'
print(f'check training data in {raw_data}/train.{direction}')
size = 0
if ((not os.... |
def mask_loss(x, labels, masks):
cnt_nonzero = tf.to_float(tf.count_nonzero(masks))
loss = (tf.reduce_sum(tf.multiply(tf.math.pow((x - labels), 2), masks)) / cnt_nonzero)
return loss |
def get_coppeliasim_root():
if ('COPPELIASIM_ROOT' not in os.environ):
raise RuntimeError('Please set env COPPELIASIM_ROOT')
return os.environ['COPPELIASIM_ROOT'] |
def add(g, self, other, alpha=None):
if (sym_help._is_value(self) and sym_help._is_tensor_list(self)):
return sym_help._onnx_opset_unsupported_detailed('Add', 9, 11, 'Add between list of tensors not supported')
if (alpha and (sym_help._scalar(sym_help._maybe_get_scalar(alpha)) != 1)):
return _un... |
def test_not_app_with_asgi(schema):
case = Case(schema['/users']['GET'])
case.operation.app = None
with pytest.raises(RuntimeError, match='ASGI application instance is required. Please, set `app` argument in the schema constructor or pass it to `call_asgi`'):
case.call_asgi() |
class sSFU_reg(atomic_reg):
OP_NAME = 'sSFU'
_fields_ = [('cmd_short', ctypes.c_uint64, 1), ('cmd_id', ctypes.c_uint64, 20), ('cmd_id_dep', ctypes.c_uint64, 20), ('tsk_typ', ctypes.c_uint64, 4), ('tsk_eu_typ', ctypes.c_uint64, 5), ('rsvd0', ctypes.c_uint64, 5), ('cmd_id_en', ctypes.c_uint64, 4), ('pwr_step', ct... |
def only_binary():
return Option('--only-binary', dest='format_control', action='callback', callback=_handle_only_binary, type='str', default=FormatControl(set(), set()), help='Do not use source packages. Can be supplied multiple times, and each time adds to the existing value. Accepts either :all: to disable all s... |
class AP1SNmat(SpectralMatrix):
def assemble(self, method):
(test, trial) = (self.testfunction, self.trialfunction)
assert isinstance(test[0], P1)
assert isinstance(trial[0], SN)
k = np.arange((test[0].N - 2))
d = {0: (- ((k / (k + 2)) ** 2)), 2: 1}
if (not test[0].is... |
def init_cfg_for_merge(cfg, new_cfg):
keys = [*cfg.keys(), *new_cfg.keys()]
for k in keys:
if (k == BASE_KEY):
continue
cfg.setdefault(k, new_cfg.get(k))
if isinstance(new_cfg.get(k), CfgNode):
init_cfg_for_merge(cfg.get(k), new_cfg.get(k)) |
def jsd_grad(go, o, pq_list):
(p, q) = pq_list
m = ((p + q) / 2.0)
return [((np.log((((p * (1 - m)) / (1 - p)) / m)) / 2.0) * go), None] |
class DistTrainer():
def __init__(self, train_data, model, optimizer=None, loss=None, callbacks_all=None, callbacks_master=None, batch_size_per_gpu=8, n_epochs=1, num_workers=1, drop_last=False, dev_data=None, metrics=None, metric_key=None, update_every=1, print_every=10, validate_every=(- 1), save_path=None, devic... |
_arg_scope
def stack_blocks_dense(net, blocks, output_stride=None, outputs_collections=None):
current_stride = 1
rate = 1
for block in blocks:
with tf.variable_scope(block.scope, 'block', [net]) as sc:
for (i, unit) in enumerate(block.args):
if ((output_stride is not None... |
def __generate_resolv_file(args, conf_path):
with open('{}/{}'.format(conf_path, RESOLV_FILENAME), 'w') as resolvfile:
resolvfile.write('nameserver 127.0.0.1\n') |
def merge(list_a, list_b, pr=False):
result = OrderedDict()
for (n, c) in list_a:
result[n] = c
for (n, c) in list_b:
if (n in result):
result[n] = (result[n] + c)
else:
result[n] = c
return sorted(result.items(), key=(lambda x: x[1]), reverse=True) |
def build_pnasnet_large(images, num_classes, is_training=True, final_endpoint=None, config=None):
hparams = (copy.deepcopy(config) if config else large_imagenet_config())
nasnet._update_hparams(hparams, is_training)
if (tf.test.is_gpu_available() and (hparams.data_format == 'NHWC')):
tf.logging.info... |
def random_entropy(traj, show_progress=True):
if (constants.UID not in traj.columns):
return pd.DataFrame([_random_entropy_individual(traj)], columns=[sys._getframe().f_code.co_name])
if show_progress:
df = traj.groupby(constants.UID).progress_apply((lambda x: _random_entropy_individual(x)))
... |
class Benchmark():
def run(self, systems=None, timeout=60, trials=1, sort=False, optional=False):
if sort:
systems.sort()
print(('\n\n\n' + str(self)))
print((' %-12s%-12s%-12s%-12s%-12s%15s' % ('System', 'min', 'avg', 'max', 'trials', 'cpu or wall')))
if (systems is Non... |
class DummyExampleForPicklingTest():
start = 10
stop = 100
_from_method
def f(self):
from sage.arith.srange import xsrange
return xsrange(self.start, self.stop) |
def findMisplacedChildren(allnodes):
misplaced_children = []
for node in allnodes:
node.nodelist = orderNodeList(node.nodelist)
eduCovered = sorted(list(set([m.eduspan[0] for m in node.nodelist])))
eduCovered.extend(list(set([m.eduspan[1] for m in node.nodelist])))
eduCovered = s... |
def test_eq_statements_5(default_test_case):
default_test_case._statements = []
other = dtc.DefaultTestCase(ModuleTestCluster(0))
other._statements = []
assert default_test_case.__eq__(other) |
class TestOptions(BaseOptions):
def __init__(self):
super().__init__()
self.isTrain = False
def initialize(self, parser):
super().initialize(parser)
parser.add_argument('--result_dir', type=str, default='results')
return parser |
class SameModule(nn.Module):
def __init__(self, **kwargs):
super().__init__()
self.query = QueryModule(**kwargs)
self.attend = AttentionModule(**kwargs)
self.attnNot = NotModule()
def forward(self, attn, feat, query):
value_query = self.query(attn, feat, query)
ou... |
def forward(self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor]=None, position_ids: Optional[torch.Tensor]=None, past_key_value: Optional[Tuple[torch.Tensor]]=None, output_attentions: bool=False, use_cache: bool=False) -> Tuple[(torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]])]... |
class TriangleDataset(torch.utils.data.Dataset):
def __init__(self, num_examples=60000):
self.num_examples = num_examples
def __len__(self):
return self.num_examples
def __getitem__(self, i):
n = random.randint(0, 1)
if (n == 0):
image = make_equilateral_triangle(... |
def test_denoise():
from topaz.commands import denoise
parser = denoise.add_arguments()
args = parser.parse_args(['--patch-size', '1024', '-o', 'data/EMPIAR-10025/denoised/', 'data/EMPIAR-10025/rawdata/micrographs/*.mrc']) |
_config
def task_mlm_itm():
exp_name = 'mlm_itm'
datasets = ['cc3m']
loss_names = _loss_names({'itm': 1, 'mlm': 1})
batch_size = 1024
max_epoch = 10
max_image_len = (- 1) |
def generate_split(image_path, output_path, seed=42):
if ((image_path is None) or (not os.path.isdir(image_path))):
print('Invalid input image folder!')
return
if ((output_path is None) or (not os.path.isdir(output_path))):
print('Invalid output image folder!')
return
random.... |
class AccuracyMonitor(object):
def __init__(self, sess, early_stop_steps):
self._early_stop_steps = early_stop_steps
self._sess = sess
self.best = (0, 0, 0)
self.params_at_best = None
def mark_accuracy(self, validate_accuracy, test_accuracy, i):
curr_accuracy = (float(val... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [313])
.parametrize('including_pad', [True, False])
.parametrize('ignore_border', [True, False])
.parametrize('channel_last', [False, True])
.parametrize('inshape, kernel, stride, pad', [((4, 6), (2, 2), (2, 1), (1, 0)), ((2, 4, 6), (2, 2), (2, 1), (1, 0)), ((2,... |
class SumMeter(UnivariateStatistic):
def __init__(self):
self.sum = 0.0
self.num_items = 0
def update(self, num):
self.sum += num
self.num_items += 1
return self
def remove(self, num):
self.sum -= num
self.num_items -= 1
return self
def get... |
def _load_data(_nrows=None, debug=False):
train_x = pd.read_csv(config.TRAIN_X, header=None, sep=' ', nrows=_nrows, dtype=np.float)
train_y = pd.read_csv(config.TRAIN_Y, header=None, sep=' ', nrows=_nrows, dtype=np.int32)
train_x = train_x.values
train_y = train_y.values.reshape([(- 1)])
print('data... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.