code stringlengths 101 5.91M |
|---|
def to_device(obj: object, device: str) -> None:
for (key, val) in vars(obj).items():
if isinstance(val, torch.Tensor):
setattr(obj, key, val.to(device=device, non_blocking=True)) |
class FakeLandscape(flexs.Landscape):
def _fitness_function(self, sequences):
return rng.random(size=len(sequences)) |
def save_model(path, model, epoch, optimizer=None):
model_dict = {'epoch': epoch, 'model_state': model.state_dict()}
if (optimizer is not None):
model_dict['optimizer_state'] = optimizer.state_dict()
torch.save(model_dict, path) |
def processInputStreamData(obj):
global myStatus
if ('attributes' in obj):
attributes = obj['attributes']
if ('command' in attributes):
print(myStatus)
if (attributes['command']['value'] == 'close'):
if (myStatus == 'open'):
myStatus = ... |
def load_dataset():
global train_data, dev_data, test_data, trfreq
trace('load train')
for line in open(args.train_file):
(h, r, t) = parse_line(line)
train_data.append((h, r, t))
trfreq[r] += 1
train_data = list(train_data)
for r in trfreq:
trfreq[r] = (args.train_si... |
def torchPSNR(tar_img, prd_img):
imdff = (torch.clamp(prd_img, 0, 1) - torch.clamp(tar_img, 0, 1))
rmse = (imdff ** 2).mean().sqrt()
ps = (20 * torch.log10((1 / rmse)))
return ps |
def detect_initials(text):
pattern = '[A-Z]\\. ?[A-Z]\\.'
match = re.findall(pattern, text)
return [m for m in match] |
class NSEM_3D_AdjointTests(unittest.TestCase):
def test_JvecAdjoint_zxx(self):
self.assertTrue(JvecAdjointTest(nsem.utils.test_utils.halfSpace(0.01), 'xx', 0.1))
def test_JvecAdjoint_zxy(self):
self.assertTrue(JvecAdjointTest(nsem.utils.test_utils.halfSpace(0.01), 'xy', 0.1))
def test_JvecAd... |
def CmtyEvolutionJson(Json, sizesContV, cContV, edges):
return _snap.CmtyEvolutionJson(Json, sizesContV, cContV, edges) |
def execute(prob: Chunk, min_distance: float=15.0, threshold_rel: float=0.3):
if (prob is None):
print('get None probability map!')
return None
assert (threshold_rel > 0.0)
assert (threshold_rel < 1.0)
if np.issubdtype(prob.dtype, np.uint8):
prob = prob.astype(np.float32)
... |
def _get_num_outputs_entry(name: str, opts: Dict[(str, Any)]) -> Tuple[(int, int)]:
from returnn.tensor import Tensor
data = Tensor(name, **opts)
return ((data.dim or (data.shape[(- 1)] if data.shape else 0)), len(data.shape)) |
class Integrator():
def __init__(self, logger: TensorboardLogger, distributed: bool=True):
self.values = {}
self.counts = {}
self.hooks = []
self.logger = logger
self.distributed = distributed
self.local_rank = torch.distributed.get_rank()
self.world_size = to... |
def fricas_console():
from sage.repl.rich_output.display_manager import get_display_manager
if (not get_display_manager().is_in_terminal()):
raise RuntimeError('Can use the console only in the terminal. Try %%fricas magics instead.')
os.system('fricas -nox') |
def register_types_ns3_Hash(module):
root_module = module.get_root()
module.add_class('Implementation', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter<ns3::Hash::Implementation> >'])
typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t cons... |
class TestHuggingFaceTokenizer():
TEST_PROMPT: str = 'The Center for Research on Foundation Models (CRFM) is an interdisciplinary initiative born out of the Stanford Institute for Human-Centered Artificial Intelligence (HAI) that aims to make fundamental advances in the study, development, and deployment of foundat... |
def generate_shell(model_name: str, shape_list: List[List[int]], workspace_root: str, suf: str='pt'):
shape_str = ','.join(shape_list_to_str(shape_list))
sh = sh_template.format(model_name=model_name, shape_str=f'[{shape_str}]', suf=suf)
with open(os.path.join(workspace_root, f'convert.sh'), 'w') as w:
... |
.timeout(120)
.parametrize('model_name', list_models(exclude_filters=(EXCLUDE_FILTERS + ['dla*'])))
.parametrize('batch_size', [2])
def test_model_backward(model_name, batch_size):
model = create_model(model_name, pretrained=False, num_classes=42)
num_params = sum([x.numel() for x in model.parameters()])
mo... |
def get_prog():
try:
prog = os.path.basename(sys.argv[0])
if (prog in ('__main__.py', '-c')):
return ('%s -m pip' % sys.executable)
else:
return prog
except (AttributeError, TypeError, IndexError):
pass
return 'pip' |
def drn_a_50(pretrained=False, **kwargs):
model = DRN_A(Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
return model |
class PKLDFDatasetForGen(Dataset):
def __init__(self, data_file: typing.Union[(str, Path)], in_memory: bool=False, split: str='train', train_ratio: float=1, train_data_file: str='250K_ddG_split/train_ddG.pkl', data_subset='full'):
data_file = Path(data_file)
if (not data_file.exists()):
... |
def get_parser(**parser_kwargs):
def str2bool(v):
if isinstance(v, bool):
return v
if (v.lower() in ('yes', 'true', 't', 'y', '1')):
return True
elif (v.lower() in ('no', 'false', 'f', 'n', '0')):
return False
else:
raise argparse.Argum... |
def load_model_from_config(config, sd):
model = instantiate_from_config(config)
model.load_state_dict(sd, strict=False)
model.cuda()
model.eval()
return model |
def build_storm(model, base_learning_rate, parameters=None, max_gradient_norm=None, allow_lr_injection=False, **kwargs):
storm_optimizer = StormOptimizer(lr=base_learning_rate, **kwargs)
return _build(model, storm_optimizer, max_gradient_norm=max_gradient_norm, allow_lr_injection=allow_lr_injection) |
def calculate_video_results(output_buffer, video_id, test_results, class_names):
video_outputs = torch.stack(output_buffer)
average_scores = torch.mean(video_outputs, dim=0)
(sorted_scores, locs) = torch.topk(average_scores, k=10)
video_results = []
for i in range(sorted_scores.size(0)):
vid... |
class DCVAE():
def __init__(self, input_shape=(45, 45, 2), act='sigmoid', KernelDim=(2, 2, 3, 3), latent_dim=200, opt=RMSprop(), isTerminal=False, filepath=None, multi_GPU=0, hidden_dim=1024, filters=(2, 64, 64, 64), strides=(1, 2, 1, 1), dropout=0, epochs_drop=20):
self.epochs_drop = epochs_drop
se... |
def _get_ade_instances_meta():
thing_ids = [k['id'] for k in ADE_CATEGORIES]
assert (len(thing_ids) == 100), len(thing_ids)
thing_dataset_id_to_contiguous_id = {k: i for (i, k) in enumerate(thing_ids)}
thing_classes = [k['name'] for k in ADE_CATEGORIES]
ret = {'thing_dataset_id_to_contiguous_id': th... |
class Pickup_Soup(BaseScriptPeriod):
def __init__(self, random_dish=True, random_soup=True):
super().__init__(period_name='Pickup_Soup')
self.random_dish = random_dish
self.random_soup = random_soup
self.__stage = 1
self.__current_period = Pickup_Object(obj='dish', terrain_ty... |
def compute_sst2_metrics(result_dict, labels, predictions):
all_true = []
all_pred = []
all_correct = 0
all_total = 0
for (true, pred) in zip(labels, predictions):
l = true.split('<|sentiment|>')[(- 1)].split('<|endofsentiment|>')[0].strip()
p = pred.split('<|sentiment|>')[(- 1)].spl... |
class Bottleneck(_Bottleneck):
expansion = 4
def __init__(self, inplanes, planes, rfp_inplanes=None, sac=None, **kwargs):
super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
assert ((sac is None) or isinstance(sac, dict))
self.sac = sac
self.with_sac = (sac is not None)
... |
def test_changestats_comparison():
print('testing changestats comparison...')
assert is_same_changestat(changeContagion, changeContagion)
assert (not is_same_changestat(changeContagion, changeLogContagion))
assert is_same_changestat(partial(changeoOc, 'age'), partial(changeoOc, 'age'))
assert (not i... |
def fidelity(teacher, student, X):
y_target = teacher(X)
y_pred = student.predict(X)
return accuracy(y_target, y_pred) |
def update_config(config, args):
_update_config_from_file(config, args.cfg)
config.defrost()
if args.opts:
config.merge_from_list(args.opts)
if args.batch_size:
config.DATA.BATCH_SIZE = args.batch_size
if args.data_path:
config.DATA.DATA_PATH = args.data_path
if args.zip:... |
def _eval(ind):
res = illumination_rastrigin_normalised(ind, nb_features=2)
(fitness, features) = res
fitness[0] = (0.0 if (fitness[0] < 0.9) else fitness[0])
return (fitness, features) |
class StateManager():
def __init__(self, entity_manager: EntityManager, task_config: TaskConfig, entity_function_path=None):
self.task_config = task_config
self.entity_manager = entity_manager
self.addtional_ef = None
if entity_function_path:
spec = importlib.util.spec_fr... |
def get_learning_rate(optim, name=None):
if (name is None):
return optim.param_groups[0]['lr'] |
def test_suppress_warnings_forwarding():
def warn_other_module():
def warn(arr):
warnings.warn('Some warning', stacklevel=2)
return arr
np.apply_along_axis(warn, 0, [0])
with suppress_warnings() as sup:
sup.record()
with suppress_warnings('always'):
... |
def load_subtensor(ndata, seeds, labels, input_nodes, device):
_load = (lambda k: th.IntTensor(np.array(ndata[k][input_nodes])))
input_text = {}
for k in ndata.keys():
if (k != 'labels'):
input_text[k] = _load(k).to(device)
return (input_text, labels[seeds].to(device)) |
_function_dispatch(_all_dispatcher)
def all(a, axis=None, out=None, keepdims=np._NoValue):
return _wrapreduction(a, np.logical_and, 'all', axis, None, out, keepdims=keepdims) |
def query_virtuoso(q):
endpoint = virtuoso_address
store = sparqlstore.SPARQLUpdateStore(endpoint)
gs = rdflib.ConjunctiveGraph(store)
gs.open((endpoint, endpoint))
gs1 = gs.get_context(rdflib.URIRef(virtuoso_graph_uri))
res = gs1.query(q)
return res |
def arg_parse():
parser = argparse.ArgumentParser(description='MMSB arguments.')
parser.add_argument('--dataset', dest='dataset', help='Input dataset.')
parser.add_argument('--K', dest='K', type=int, help='Number of blocks.')
parser.add_argument('--samples-per-G', dest='samples', type=int, help='Number ... |
def replace_ImageToTensor(pipelines):
pipelines = copy.deepcopy(pipelines)
for (i, pipeline) in enumerate(pipelines):
if (pipeline['type'] == 'MultiScaleFlipAug'):
assert ('transforms' in pipeline)
pipeline['transforms'] = replace_ImageToTensor(pipeline['transforms'])
eli... |
def test_record_fields_int32():
t = RecordType([NumpyType('int32')], ['one'])
assert (str(ak.types.from_datashape(str(t), highlevel=False)) == str(t)) |
(Output('clustering-summary', 'children'), [Input('cluster-attribute-table', 'data')])
def clustering_summary(data):
if (len(data) == 0):
return html.Div()
result_table = log_clustering.result_table
total_loglines = result_table.shape[0]
total_num_cluster = len(result_table['cluster_id'].unique(... |
def add_visualizer_callback(callbacks: list[Callback], config: (DictConfig | ListConfig)) -> None:
assert isinstance(config, (DictConfig, Namespace))
if isinstance(config, DictConfig):
if ((('log_images_to' in config.project.keys()) and (len(config.project.log_images_to) > 0)) or (('log_images_to' in co... |
class Helper(HelperBase):
def __init__(self):
self.name = 'kerashelper'
super().__init__()
def increment_average(self, model, model_next, num_examples, total_examples):
w = (num_examples / total_examples)
weights = []
for i in range(len(model)):
weights.append... |
def test_observers_clear(short_test_case):
tracer = ExecutionTracer()
tracer.current_thread_identifier = threading.current_thread().ident
executor = TestCaseExecutor(tracer)
observer = MagicMock()
executor.add_observer(observer)
assert (executor._observers == [observer])
executor.clear_obser... |
def _load_checkpoint(args, model):
if (args.pretrained_model == 'swin-b-1k'):
path = os.path.join(ROOT_DIR, '../checkpoints/swin_base_patch4_window7_224.pth')
elif (args.pretrained_model == 'swin-b-22k'):
path = os.path.join(ROOT_DIR, '../checkpoints/swin_base_patch4_window7_224_22k.pth')
el... |
def _transform_month(result_str: str, month_token: str, month: int) -> str:
result = deepcopy(result_str)
if (month_token != ''):
if (month == (- 1)):
if (len(month_token) == 3):
result = result.replace(month_token, '---')
elif (len(month_token) == 5):
... |
def get_probabilities(lps, references, mapping):
min_prob = np.exp(np.min(list(lps.values())))
remaining_prob = max(0, (1 - sum([np.exp(v) for v in lps.values()])))
(dist, misses) = ([], [])
for ref in references:
prefix = mapping[ref]
values = [lps[key] for key in [f' {prefix}', prefix]... |
def glibc_version_string():
return (glibc_version_string_confstr() or glibc_version_string_ctypes()) |
def test_columnar_convert_selected_columns_missing():
converter = ColumnarConverter(name='some_name', default_type='foo', type_column=None, column_defaults={}, selected_columns={'before': 'after', 'same': 'same'}, transform_columns={})
with pytest.raises(ValueError, match="some_name\\['x'\\]: expected 'before',... |
def test_patchset_get_patch_by_values(patchset):
assert patchset[(2100, 800)]
assert patchset[(2100, 800)]
assert patchset[[2100, 800]] |
def get_keras_tpc() -> tp.TargetPlatformCapabilities:
imx500_pot_tpc_tp_model = get_tp_model()
return generate_keras_tpc(name='imx500_pot_tpc_keras_tpc', tp_model=imx500_pot_tpc_tp_model) |
def relu_flops_counter_hook(module, input, output):
active_elements_count = output.numel()
module.__flops__ += int(active_elements_count) |
class Container():
def __init__(self, to_render: Dict[(str, Any)], visual_type: str, cfg: Config) -> None:
self.context = Context(**to_render)
setattr(self.context, 'rnd', random.randint(0, 9999))
if (visual_type in GRID_VISUAL_TYPES):
self.template_base = ENV_LOADER.get_template... |
def test__rollback_changes_end(default_test_case):
default_test_case.add_statement(stmt.IntPrimitiveStatement(default_test_case, 5))
default_test_case.add_statement(stmt.IntPrimitiveStatement(default_test_case, 10))
default_test_case.add_statement(stmt.IntPrimitiveStatement(default_test_case, 15))
clone... |
class AmazonReviewPolarity(XiangZhangDataset):
dirname = 'amazon_review_polarity_csv'
columns = ['rating', 'subject', 'body'] |
def get_dataset(eval_dataset, data_path, split, audio_embs):
if (eval_dataset == 'mtat'):
dataset = MTAT_Dataset(data_path, split, audio_embs)
elif (eval_dataset == 'gtzan'):
dataset = GTZAN_Dataset(data_path, split, audio_embs)
elif (eval_dataset == 'fma'):
dataset = FMA_Dataset(dat... |
class ExFileObject(object):
blocksize = 1024
def __init__(self, tarfile, tarinfo):
self.fileobj = _FileInFile(tarfile.fileobj, tarinfo.offset_data, tarinfo.size, tarinfo.sparse)
self.name = tarinfo.name
self.mode = 'r'
self.closed = False
self.size = tarinfo.size
... |
def resnet101_StoDepth_lineardecay(pretrained=False, prob_0_L=[1, 0.5], multFlag=True, **kwargs):
model = ResNet_StoDepth_lineardecay(StoDepth_Bottleneck, prob_0_L, multFlag, [3, 4, 23, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
return model |
class _GenericTest(object):
def _test_equal(self, a, b):
self._assert_func(a, b)
def _test_not_equal(self, a, b):
with assert_raises(AssertionError):
self._assert_func(a, b)
def test_array_rank1_eq(self):
a = np.array([1, 2])
b = np.array([1, 2])
self._tes... |
def ConvertSubGraph_PDirNet_PDirNet(InGraph, NIdV, RenumberNodes=False):
return _snap.ConvertSubGraph_PDirNet_PDirNet(InGraph, NIdV, RenumberNodes) |
def ranking_eval(qrels, run, output_dir, measurements, output_file='eval_bm25_aggregate_overlap.txt'):
evaluator = pytrec_eval.RelevanceEvaluator(qrels, measurements)
results = evaluator.evaluate(run)
def print_line(measure, scope, value):
print('{:25s}{:8s}{:.4f}'.format(measure, scope, value))
... |
_MASK_OUTPUTS.register('mask_deconv_output')
class Mask_deconv_output(nn.Module):
def __init__(self, dim_in):
super(Mask_deconv_output, self).__init__()
num_classes = cfg.MODEL.NUM_CLASSES
self.mask_deconv = nn.ConvTranspose2d(dim_in, dim_in, 2, 2, 0)
self.mask_fcn_logits = nn.Conv2d... |
class OmniNet(nn.Module):
def __init__(self, config=None, gpu_id=(- 1), dropout=None):
super(OmniNet, self).__init__()
if (config is None):
(cc, pc, d) = self.__defaultconf__()
else:
(cc, pc, d) = config
if (dropout is not None):
cc['dropout'] = dr... |
class BaseModel(ABC):
def __init__(self, transition_scheme, unary_limit, reverse_sentence, *args, **kwargs):
super().__init__(*args, **kwargs)
self._transition_scheme = transition_scheme
self._unary_limit = unary_limit
self._reverse_sentence = reverse_sentence
def initial_word_qu... |
def AnyBut(s):
ranges = chars_to_ranges(s)
ranges.insert(0, (- maxint))
ranges.append(maxint)
result = CodeRanges(ranges)
result.str = ('AnyBut(%s)' % repr(s))
return result |
def _linear(raw, input, weight, bias=None):
x = raw(input, weight, bias)
layer_name = log.add_layer(name='fc')
top_blobs = log.add_blobs([x], name='fc_blob')
layer = caffe_net.Layer_param(name=layer_name, type='InnerProduct', bottom=[log.blobs(input)], top=top_blobs)
layer.fc_param(x.size()[1], has_... |
def get_size(file_dir):
try:
file_name = glob.glob(os.path.join(file_dir, '*'))[0]
return os.stat(file_name).st_size
except:
logging.exception(f'error getting file from: {file_dir}')
return 0 |
def make_dataset(dir, class_to_idx):
images = []
dir = os.path.expanduser(dir)
for target in sorted(os.listdir(dir)):
d = os.path.join(dir, target)
if (not os.path.isdir(d)):
continue
for (root, _, fnames) in sorted(os.walk(d)):
for fname in sorted(fnames):
... |
def binomial_coefficients(n):
n = py_scalar_to_element(n)
d = {(0, n): 1, (n, 0): 1}
a = 1
for k in range(1, ((n // 2) + 1)):
a = ((a * ((n - k) + 1)) // k)
d[(k, (n - k))] = d[((n - k), k)] = a
return d |
def _isnamedtupleinstance(x):
t = type(x)
b = t.__bases__
if ((len(b) != 1) or (b[0] != tuple)):
return False
f = getattr(t, '_fields', None)
if (not isinstance(f, tuple)):
return False
return all((isinstance(n, str) for n in f)) |
class VideoQACollator(object):
def __init__(self, tokenizer, max_length=20, task_type='action', n_options=5):
self.tokenizer = tokenizer
self.max_length = max_length
self.task_type = task_type
self.n_options = n_options
def collate_batch(self, batch):
v_collate = default_... |
.parametrize('ctx, func_name', ctxs)
.parametrize('seed', [313])
.parametrize('num_inputs', [2, 3, 5])
def test_add_n_double_backward(num_inputs, seed, ctx, func_name):
from nbla_test_utils import backward_function_tester
rng = np.random.RandomState(seed)
shape0 = [2, 3, 4]
inputs = []
for i in rang... |
class Issue15WarmUpSupportTest(ReBenchTestCase):
def setUp(self):
super(Issue15WarmUpSupportTest, self).setUp()
self._set_path(__file__)
def test_run_id_indicates_warm_up_iterations_required(self):
cnf = Configurator(load_config((self._path + '/issue_15.conf')), DataStore(self.ui), self.... |
def compute_statistics(text_dir, target_dir, output_file=None):
files = utils.get_files_from_folder(text_dir)
files_data = []
files_indexes = []
for (i, doc_name) in enumerate(files):
text = utils.preprocess_text(files[doc_name])
json_file = ((target_dir + doc_name) + '.json')
if... |
def add_datetime(func):
def wrapper(*args, **kwargs):
datetime_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print(grey('[{}] '.format(datetime_str), bold=True), end='')
return func(*args, **kwargs)
return wrapper |
('utils.config_util.__get_default')
def test_overrides_default_values(get_default_mock):
get_default_mock.side_effect = (lambda key, default: (['Xmx6144M', 'd64'] if (key == 'java-options') else default))
parser = _get_command_line_parser(['valid-detector'], [], [])
result = parser.parse_args(['run', 'ex1',... |
def cummean(x: np.array) -> np.array:
if (sum(np.isnan(x)) == len(x)):
return np.ones(len(x))
else:
sum_vals = np.nancumsum(x.astype(float))
count_vals = np.cumsum((~ np.isnan(x)))
return np.divide(sum_vals, count_vals, out=np.zeros_like(sum_vals), where=(count_vals != 0)) |
def make_td3_agent(base_config=spinning_up_td3_config, args=Namespace(env='InvertedPendulum-v2', tb='', prefix='td3', parent_folder='/tmp/mrl', layers=(256, 256), num_envs=None), agent_name_attrs=['env', 'seed', 'tb'], **kwargs):
config = make_ddpg_agent(base_config, args, agent_name_attrs, **kwargs)
del config... |
class SRWLOptA(SRWLOpt):
def __init__(self, _shape='r', _ap_or_ob='a', _Dx=0, _Dy=0, _x=0, _y=0):
self.shape = _shape
self.ap_or_ob = _ap_or_ob
self.Dx = _Dx
self.Dy = _Dy
self.x = _x
self.y = _y |
def get_predictions_single(model_def, weights):
model_def.load_state_dict(torch.load(weights))
model = tta.SegmentationTTAWrapper(model_def, tta.aliases.d4_transform(), merge_mode='mean')
model.to(device)
if (torch.cuda.device_count() > 1):
model = nn.DataParallel(model)
final_predictions = ... |
class CustomDatasetDataLoader():
def __init__(self, opt):
self.opt = opt
dataset_class = find_dataset_using_name(opt.dataset_mode)
self.dataset = dataset_class(opt)
print(('dataset [%s] was created' % type(self.dataset).__name__))
self.dataloader = torch.utils.data.DataLoader... |
def install_lib_sig_segfault():
try:
os.environ.setdefault('SEGFAULT_SIGNALS', 'all')
import ctypes
import ctypes.util
libfn = ctypes.util.find_library('SegFault')
assert libfn, 'libSegFault not found'
ctypes.CDLL(libfn)
print('Installed libSegFault.so.')
... |
class CComplexType(CNumericType):
is_complex = 1
to_py_function = '__pyx_PyComplex_FromComplex'
has_attributes = 1
scope = None
def __init__(self, real_type):
while (real_type.is_typedef and (not real_type.typedef_is_external)):
real_type = real_type.typedef_base_type
sel... |
class MinWeight(BaseEliminationOrder):
def cost(self, node):
return np.prod([self.bayesian_model.get_cardinality(neig_node) for neig_node in self.moralized_model.neighbors(node)]) |
class HardwareConfig():
n_cpu: int = MISSING
n_gpu: int = MISSING
n_envs_per_worker: int = 2 |
class BertAdam(Optimizer):
def __init__(self, params, lr=required, warmup=(- 1), t_total=(- 1), schedule='warmup_linear', b1=0.9, b2=0.999, e=1e-06, weight_decay=0.01, max_grad_norm=1.0, **kwargs):
if ((lr is not required) and (lr < 0.0)):
raise ValueError('Invalid learning rate: {} - should be ... |
_params
def test_quad_vec_simple_inf(quadrature):
def f(x):
return (1 / (1 + (np.float64(x) ** 2)))
for epsabs in [0.1, 0.001, 1e-06]:
if ((quadrature == 'trapezoid') and (epsabs < 0.0001)):
continue
kwargs = dict(norm='max', epsabs=epsabs, quadrature=quadrature)
(res... |
def test_calc_on_policy_policy_value_estimate():
ground_truth_policy_value = OpenBanditDataset.calc_on_policy_policy_value_estimate(behavior_policy='random', campaign='all')
assert isinstance(ground_truth_policy_value, float) |
def find_parameters(module):
assert isinstance(module, nn.Module)
if getattr(module, '_is_replica', False):
def find_tensor_attributes(module):
tuples = [(k, v) for (k, v) in module.__dict__.items() if (torch.is_tensor(v) and v.requires_grad)]
return tuples
gen = module._... |
class Add2(PythonFunction):
def __init__(self, ctx=None):
super(Add2, self).__init__(ctx)
def name(self):
return 'PythonAdd2'
def min_outputs(self):
return 1
def grad_depends_output_data(self, i, o):
return False
def grad_depends_input_data(self, i, j):
return... |
def _zinc(model, num_samples, egc_num_bases, egc_num_heads, aggrs, hidden):
zinc_data(data_location())
if (model == 'egc'):
config = ZincEgcConfig(num_samples=num_samples, softmax=False, sigmoid=False, hardtanh=False, num_bases=egc_num_bases, num_heads=egc_num_heads, aggrs=aggrs, hidden=hidden)
elif... |
def data_file(*relative_path):
dfolder = data_folder()
return os.path.join(dfolder, *relative_path) |
def _add_boundmethod_attribute(name: str, obj: Any, attributes: Dict[(str, Any)], ndarrays: Dict[(str, ndarray)], objects: Dict[(str, object)]) -> Tuple[(Dict, Dict, Dict)]:
attributes[name] = obj()
return (attributes, ndarrays, objects) |
.parametrize('name', sorted(ADAPTERS_MANAGER.adapters))
def test_adapter_class_has_interface(name):
assert isinstance(ADAPTERS_MANAGER.adapters[name], ContainerAdapterProtocol) |
_test()
def test_kernels_inside_component_0():
def kernels_inside_component_0(x: dace.float32[8], y: dace.float32[8], v: dace.float32[8], w: dace.float32[8], z: dace.float32[8]):
tmp = ((x + y) + v)
return (tmp + (w + z))
x = np.random.rand(8).astype(np.float32)
y = np.random.rand(8).astype(... |
class OpenPoseHead(nn.Module):
def __init__(self, num_classes=19, in_channels=128):
super(OpenPoseHead, self).__init__()
mid_channels = ((in_channels + num_classes) + (2 * num_classes))
self.model1_1 = nn.Sequential(nn.Conv2d(in_channels, in_channels, kernel_size=(3, 3), stride=(1, 1), paddi... |
class OffsetPaddleSetABreakoutWorld(RandomOffsetPaddleBreakoutWorld):
warnings.warn('This env. parameter was dropped and should no longer be used.', DeprecationWarning)
offset_range_start = 25
offset_range_end = 75 |
def calculate_vggface2_rgb_mean_std(dir, batch_size):
dataset = datasets.ImageFolder(dir, transforms.ToTensor())
dataloader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=False)
(channels_sum, channels_squared_sum, num_batches) = (0, 0, 0)
for (data, _) in tqdm(dataloader):
channel... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.