code stringlengths 101 5.91M |
|---|
def remove_extra_space_around_variable(t):
var_names = extract_variable_names(t)
result = str(t)
for v in var_names:
result = result.replace((('" ' + v) + ' "'), v)
return result |
.parametrize('n_unique_action, len_list, dim_context, reward_type, reward_structure, decay_function, click_model, eta, random_state, err, description', invalid_input_of_init)
def test_synthetic_slate_init_using_invalid_inputs(n_unique_action, len_list, dim_context, reward_type, reward_structure, decay_function, click_m... |
class DecodingBlocks(nn.Module):
def __init__(self, num_in, num_out, bilinear=False):
super(DecodingBlocks, self).__init__()
if bilinear:
self.up = nn.Sequential(nn.Upsample(scale_factor=2, mode='nearest'), nn.BatchNorm3d(num_in), nn.ReLU(inplace=True))
else:
self.up ... |
class TestLevels(unittest.TestCase):
TEST_NET = '\nlayer {\n name: "data"\n type: "DummyData"\n top: "data"\n dummy_data_param { shape { dim: 1 dim: 1 dim: 10 dim: 10 } }\n}\nlayer {\n name: "NoLevel"\n type: "InnerProduct"\n bottom: "data"\n top: "NoLevel"\n inner_product_param { num_output: 1 }\n}\nlayer... |
def crop_video(sub_set, video, crop_path, instanc_size):
video_crop_base_path = join(crop_path, sub_set, video)
if (not isdir(video_crop_base_path)):
makedirs(video_crop_base_path)
sub_set_base_path = join(ann_base_path, sub_set)
xmls = sorted(glob.glob(join(sub_set_base_path, video, '*.xml')))
... |
def _prepare_worker(worker, driver_path, args, partitions, search):
create_mpi_script(driver_path, args, worker['hostname'], worker['gpus'], partitions, search) |
def register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::LteRrcSap::HandoverPreparationInfo const &', 'arg0')])
cls.add_instance_attribute('asConfig', 'ns3::LteRrcSap::AsConfig', is_const=False)
return |
class Problem(IterableDataset):
name = NotImplemented
dependencies = {}
symbols = ['<PAD>', '<GO>', '<STOP>', '=']
def __init__(self, paradigm, vocab, config):
super().__init__()
assert (paradigm is not None)
self.paradigm = paradigm
self.vocab = vocab
self.config... |
def _materialize_mask_slice(mask, i, j, QPos, KPos, block_size):
return materialize_mask(mask, QPos, KPos, q_slice=hax.ds.block(i, block_size), k_slice=hax.ds.block(j, block_size)) |
.parametrize('content_type, expected', ((True, SCHEMA_LOADING_ERROR), (None, SCHEMA_LOADING_ERROR), ('application/json', SCHEMA_SYNTAX_ERROR), ('application/x-yaml', SCHEMA_SYNTAX_ERROR)))
def test_invalid_content_type( content_type, expected: str):
content = '\n<html>\n<style>\n html {\n margin: 0;\n backgr... |
.parametrize('dtype', [np.float32, np.float64])
def test_preserve_output(dtype):
image = np.arange(9, dtype=dtype).reshape((3, 3))
output = np.zeros_like(image, dtype=dtype)
gaussian_image = gaussian(image, sigma=1, output=output, preserve_range=True)
assert (gaussian_image is output) |
def test_nokeepdims_mask1():
mask = ak.index.Index8(np.array([False, False, False, True, False, False, True, True, False, False, False, False, False, True, False, False, False, False, False, True, True, True, True, True, True, False, False, False, False, False]))
content = ak.contents.ByteMaskedArray(mask, ak.c... |
def test_stl_pass_by_pointer(msg):
with pytest.raises(TypeError) as excinfo:
m.stl_pass_by_pointer()
assert (msg(excinfo.value) == '\n stl_pass_by_pointer(): incompatible function arguments. The following argument types are supported:\n 1. (v: List[int] = None) -> List[int]\n\n ... |
def steepest_descent(Av, b, x0, num_iterations, debug=False):
Ax = Av(x0)
r = [(b[i] - Ax[i]) for i in range(len(x0))]
for i in range(num_iterations):
rTr = np.sum([np.sum((r[k] * r[k])) for k in range(len(x0))])
Ar = Av(r)
alpha = (rTr / np.sum([np.sum((r[k] * Ar[k])) for k in range... |
def subsample_classes(dataset, include_classes=range(160)):
include_classes_cars = (np.array(include_classes) + 1)
cls_idxs = [x for (x, t) in enumerate(dataset.target) if (t in include_classes_cars)]
target_xform_dict = {}
for (i, k) in enumerate(include_classes):
target_xform_dict[k] = i
d... |
def test_dump_and_load():
plan = generate_wdm_2d()
serialized_plan = optplan.dumps(plan)
deserialized_plan = optplan.loads(serialized_plan) |
_utils.test()
def test_return_struct_field():
tp = ti.types.struct(a=ti.i32)
f = tp.field(shape=1)
def bar() -> tp:
return f[0]
def foo() -> tp:
return bar()
assert (foo().a == 0) |
def register_Ns3LteEnbCphySapUser_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::LteEnbCphySapUser const &', 'arg0')])
return |
class Accuracy(nn.Module):
def __init__(self, topk=(1,), thresh=None):
super().__init__()
self.topk = topk
self.thresh = thresh
def forward(self, pred, target):
return accuracy(pred, target, self.topk, self.thresh) |
class CamVid(Dataset):
CLASSES = ['Sky', 'Building', 'Pole', 'Road', 'Pavement', 'Tree', 'SignSymbol', 'Fence', 'Car', 'Pedestrian', 'Bicyclist']
CLASSES_ALL = ['Wall', 'Animal', 'Archway', 'Bicyclist', 'Bridge', 'Building', 'Car', 'CarLuggage', 'Child', 'Pole', 'Fence', 'LaneDrive', 'LaneNonDrive', 'MiscText',... |
def networkx_to_sparsegraph(nx_graph: Union[('nx.Graph', 'nx.DiGraph')], label_name: str=None, sparse_node_attrs: bool=True, sparse_edge_attrs: bool=True) -> 'SparseGraph':
import networkx as nx
int_names = True
for node in nx_graph.nodes:
int_names &= isinstance(node, int)
if int_names:
... |
def is_lyndon(w):
i = 0
for let in w[1:]:
if (w[i] < let):
i = 0
elif (w[i] == let):
i += 1
else:
return False
return (i == 0) |
_level_function()
def with_field(array, what, where=None, *, highlevel=True, behavior=None, attrs=None):
(yield (array, what))
return _impl(array, what, where, highlevel, behavior, attrs) |
class CharacterTextSlotEncoder(_BaseTextEncoder):
def __init__(self, vocab_list, slots):
self._vocab_list = (['<pad>', '<eos>', '<unk>'] + vocab_list)
self._vocab2idx = {v: idx for (idx, v) in enumerate(self._vocab_list)}
self.slots = slots
self.slot2id = {self.slots[i]: (i + len(sel... |
def make_sail_logger(exp_name: str, label: str, save_data: bool=True, save_dir: str='./logs', use_tb: bool=False, tb_dir: Optional[str]=None, use_wb: bool=False, config: Optional[dict]=None, time_delta: float=1.0, asynchronous: bool=False, print_fn: Optional[Callable[([str], None)]]=None, serialize_fn: Optional[Callabl... |
def pix2coord(x, y, cdim, imgdim, origin='upper'):
cx = (((x / imgdim[0]) * (cdim[1] - cdim[0])) + cdim[0])
if (origin == 'lower'):
cy = (((y / imgdim[1]) * (cdim[3] - cdim[2])) + cdim[2])
else:
cy = (cdim[3] - ((y / imgdim[1]) * (cdim[3] - cdim[2])))
return (cx, cy) |
def index_fill(g, self, dim, index, value):
dim_value = sym_help._parse_arg(dim, 'i')
if (sym_help._operator_export_type == torch.onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK):
return g.op('ATen', self, index, value, dim_i=dim_value, operator_s='index_fill')
(expanded_index_shape, expanded_index) = s... |
class set_detect_anomaly(object):
def __init__(self, mode: bool) -> None:
self.prev = torch.is_anomaly_enabled()
torch.set_anomaly_enabled(mode)
def __enter__(self) -> None:
pass
def __exit__(self, *args: Any) -> None:
torch.set_anomaly_enabled(self.prev) |
class LayerSlowFast(SlowFast):
args = {'slowfast_config': 'Kinetics/c2/SLOWFAST_8x8_R50', 'num_layers': 5}
output_dims = [88, 352, 704, 1408, 2304]
def __init__(self, args):
super().__init__(args)
self.num_layers = args.num_layers
def _forward(self, x):
model = self.model
... |
def save_checkpoint(state, is_best, filename='w_gt_checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, 'w_gt_model_best.pth.tar') |
class FieldAwareFactorizationMachineModel(keras.Model):
def __init__(self, num_users, num_items, embed_mf_size, lambda_weights, learning_rate=0.01, name='FFM', **kwargs):
super().__init__(name=name, **kwargs)
tf.random.set_seed(42)
self.num_users = num_users
self.num_items = num_item... |
def test_get_actions():
policy = FixedPolicy(None, np.array([1, 2, 3]))
assert (policy.get_actions(np.array([0]).reshape(1, 1))[0] == 1)
assert (policy.get_action(np.array([0]))[0] == 2)
assert (policy.get_action(np.array([0]))[0] == 3)
with pytest.raises(IndexError):
policy.get_action(np.nd... |
def EmptyArray_pad(self, length, axis=0):
if (axis < 0):
raise NotImplementedError
else:
indxarray = []
for i in range(length):
indxarray.append((- 1))
return IndexedOptionArray(indxarray, self) |
class BasicScatter(EmObjective):
def __init__(self, sim, grid, FF_cond, E_background=None):
super().__init__(sim)
self.grid = grid
self.pf = 2
self.E_background = E_background
self._compute_objective(FF_cond)
def _compute_objective(self, FF_cond):
(self.points, se... |
class WingLoss(_Loss):
def __init__(self, width=5, curvature=0.5, reduction='mean'):
super(WingLoss, self).__init__(reduction=reduction)
self.width = width
self.curvature = curvature
def forward(self, prediction, target):
return F.wing_loss(prediction, target, self.width, self.cu... |
class UploadCodeAsArtifact(Callback):
def __init__(self, code_dir: str, use_git: bool=True):
self.code_dir = code_dir
self.use_git = use_git
_zero_only
def on_train_start(self, trainer, pl_module):
logger = get_wandb_logger(trainer=trainer)
experiment = logger.experiment
... |
class CaptureStd():
def __init__(self, out=True, err=True):
if out:
self.out_buf = StringIO()
self.out = 'error: CaptureStd context is unfinished yet, called too early'
else:
self.out_buf = None
self.out = 'not capturing stdout'
if err:
... |
def get_label_to_indices_map_2() -> Dict[(str, List[int])]:
contradiction_indices = []
entailment_indices = []
neutral_indices = []
train_inputs_collections = torch.load(constants.MNLI_TRAIN_INPUT_COLLECTIONS_PATH)
for (index, train_inputs) in enumerate(train_inputs_collections):
if (train_i... |
class MetricSpacesCategory(RegressiveCovariantConstructionCategory):
_functor_category = 'Metric'
def default_super_categories(cls, category):
return Category.join([category.Topological(), super().default_super_categories(category)])
def _repr_object_names(self):
return 'metric {}'.format(se... |
def register_Ns3UanMacAloha_methods(root_module, cls):
cls.add_constructor([param('ns3::UanMacAloha const &', 'arg0')])
cls.add_constructor([])
cls.add_method('AssignStreams', 'int64_t', [param('int64_t', 'stream')], is_virtual=True)
cls.add_method('AttachPhy', 'void', [param('ns3::Ptr< ns3::UanPhy >', ... |
def eval_nested(pred, label):
label_total = 0
pred_total = 0
cnt = 0
if (pred is not None):
pred_total += 1
if (label is not None):
label_total += 1
if ((pred is not None) and (label is not None)):
partial_scores = Evaluator.eval_partial_match(pred, label)
cnt += ... |
def save_json_config(config: str, path: str):
with open(path, 'w') as f:
json.dump(config, f) |
def convert_model_to_int32(model_path: str, out_path: str):
print('ONNX INT64 --> INT32 Converter')
print(('Loading Model: ' + model_path))
model = onnx.load_model(model_path)
ch.check_model(model)
opset_version = model.opset_import[0].version
graph = model.graph
init = graph.initializer
... |
class TestCategoricalGRUPolicy(TfGraphTestCase):
def test_invalid_env(self):
env = GarageEnv(DummyBoxEnv())
with pytest.raises(ValueError):
CategoricalGRUPolicy(env_spec=env.spec)
.parametrize('obs_dim, action_dim, hidden_dim', [((1,), 1, 4), ((2,), 2, 4), ((1, 1), 1, 4), ((2, 2), 2,... |
class TestBlackmanHarris(object):
def test_basic(self):
assert_allclose(windows.blackmanharris(6, False), [6e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645])
assert_allclose(windows.blackmanharris(7, sym=False), [6e-05, 0., 0., 0., 0., 0., 0.])
assert_allclose(windows.blackmanharris(6), [6... |
def get_command_registry(agent_test_config):
command_registry = CommandRegistry()
enabled_command_categories = [x for x in COMMAND_CATEGORIES if (x not in agent_test_config.disabled_command_categories)]
for command_category in enabled_command_categories:
command_registry.import_commands(command_cate... |
class LeanBranchCond():
name: str
cond_var: str
exprs: Optional[Tuple[(str, str)]]
is_eq: bool
assert_rw: List[str] |
def CFiniteSequences(base_ring, names=None, category=None):
if isinstance(base_ring, PolynomialRing_general):
polynomial_ring = base_ring
base_ring = polynomial_ring.base_ring()
if (names is None):
names = ['x']
elif (len(names) > 1):
raise NotImplementedError('Multidimension... |
def iter_seq(doc_it):
docs = tuple(doc_it)
return (text(docs[0]) if (len(docs) == 1) else _Seq(docs)) |
class Test_get_crops(unittest.TestCase):
def test(self):
(row_crop, col_crop) = utils.get_crops(40, 10, 25, 25, 0.1, 800)
self.assertEqual(row_crop, slice(0, 500))
self.assertEqual(col_crop, slice(150, 650)) |
def normalize_input(a):
if (isinstance(a, tuple) and (len(a) == 2) and isinstance(a[0], tuple) and isinstance(a[1], dict)):
return a
elif isinstance(a, tuple):
return (a, {})
elif isinstance(a, dict):
return (tuple(), a)
else:
return ((a,), {}) |
class SSHWorker(Worker):
def __init__(self, name, job_queue, result_queue, host, options):
Worker.__init__(self, name, job_queue, result_queue, options)
self.host = host
self.cwd = os.getcwd()
def run_one(self, c, g):
cmdline = 'ssh -x -t -t {0} "cd {1}; {2}"'.format(self.host, s... |
class YoungRepresentations_Seminormal(SymmetricGroupRepresentations_class):
_default_ring = QQ
Element = YoungRepresentation_Seminormal
def _repr_(self):
return ('Seminormal representations of the symmetric group of order %s! over %s' % (self._n, self._ring)) |
_connect.numpy.implements('full_like')
def _nep_18_impl(a, fill_value, dtype=None, order=UNSUPPORTED, subok=UNSUPPORTED, shape=UNSUPPORTED):
return full_like(a, fill_value=fill_value, dtype=dtype) |
class FileNotFoundOnZenodo(ZenodoException):
def __init__(self, file_name):
super().__init__(f'File {file_name} not found on Zenodo.', level=None) |
def make_trainer(cfg, network):
network = _wrapper_factory(cfg, network)
return Trainer(network) |
def update_recursive(dict1, dict2):
for (k, v) in dict2.items():
if (k not in dict1):
dict1[k] = dict()
if isinstance(v, dict):
update_recursive(dict1[k], v)
else:
dict1[k] = v |
def _unpack_list(list_value):
list_node = list_value.node()
assert (list_node.kind() == 'prim::ListConstruct')
return list(list_node.inputs()) |
def kaiming_uniform(tensor, fan, a):
bound = math.sqrt((6 / ((1 + (a ** 2)) * fan)))
if (tensor is not None):
tensor.data.uniform_((- bound), bound) |
def get_class_labels(info):
if ('label' not in info.features):
return {}
class_label = info.features['label']
class_to_idx = {n: class_label.str2int(n) for n in class_label.names}
return class_to_idx |
def fixed_classes_uniform_labelings_scores(score_func, n_samples, n_clusters_range, n_classes, n_runs=5):
scores = np.zeros((len(n_clusters_range), n_runs))
labels_a = random_labels(n_samples=n_samples, n_classes=n_classes)
for (i, n_clusters) in enumerate(n_clusters_range):
for j in range(n_runs):
... |
class ConvertCommand(BaseTransformersCLICommand):
def register_subcommand(parser: ArgumentParser):
train_parser = parser.add_parser('convert', help='CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.')
train_parser.add_argument('--model_type', type=st... |
class ParamDictCVMOdelHandler(CommonModelHandler):
def __init__(self, dict_params, model_class, *args, **kw):
super().__init__(*args, **kw)
self.dict_params = dict_params
self.model_class = model_class
def _get_normal_model_instance(self, *args, **kw):
return self.model_class(**s... |
class ModelParallelTransformerDecoderLayer(TransformerDecoderLayer):
def build_fc1(self, input_dim, output_dim):
return ColumnParallelLinear(input_dim, output_dim, gather_output=False)
def build_fc2(self, input_dim, output_dim):
return RowParallelLinear(input_dim, output_dim, input_is_parallel=T... |
def convert_namespace_to_omegaconf(args: Namespace) -> DictConfig:
(overrides, deletes) = override_module_args(args)
config_path = os.path.join('..', 'config')
GlobalHydra.instance().clear()
with initialize(config_path=config_path):
try:
composed_cfg = compose('config', overrides=ove... |
class betabinom_gen(rv_discrete):
def _rvs(self, n, a, b):
p = self._random_state.beta(a, b, self._size)
return self._random_state.binomial(n, p, self._size)
def _get_support(self, n, a, b):
return (0, n)
def _argcheck(self, n, a, b):
return (((n >= 0) & (a > 0)) & (b > 0))
... |
def create_wrapper(inp, out, top, vmap, worker):
tmp = os.path.join(worker.output, 'tmp.v')
yosys_command = (((('read_verilog ' + inp) + '; synth -flatten; opt; opt_clean; write_verilog ') + tmp) + ';\n')
subprocess.call([worker.path['yosys'], '-p', yosys_command], stdout=subprocess.DEVNULL, stderr=subproc... |
def test_coefficient_tracker_keeps_track_of_shifted_coefficient_based_on_configured_interval_between_batches():
effective_dim_context = 4
effective_dim_action_context = 3
with mock.patch('obp.simulator.coefficient_drifter.sample_random_uniform_coefficients', MockCoefSample().fake_sample):
drifter = ... |
def test_string_primitive_statement_delta_all(default_test_case):
value = 'te'
statement = stmt.StringPrimitiveStatement(default_test_case, value)
with mock.patch('pynguin.utils.randomness.next_char') as char_mock:
char_mock.side_effect = ['a', 'b']
with mock.patch('pynguin.utils.randomness.... |
class InactiveLearningNodeMean(LearningNodeMean, InactiveLeaf):
def __init__(self, initial_stats=None):
super().__init__(initial_stats) |
.parametrize('device', ['cpu', 'cuda'])
.parametrize('M', [0, 1, 7, 8])
def test_compatibility(device, M, L=32, B=2):
lsp2lpc = diffsptk.LineSpectralPairsToLinearPredictiveCoefficients(M, log_gain=True)
U.check_compatibility(device, lsp2lpc, [], f'nrand -l {(B * L)} | lpc -l {L} -m {M} | lpc2lsp -m {M} -k 1', f... |
def accum_opt_update(params, grads, opt_state, opt, freeze_processor):
grads = jax.tree_util.tree_map((lambda *x: (sum(x) / (sum([jnp.any(k) for k in x]) + 1e-12))), *grads)
(updates, opt_state) = opt.update(grads, opt_state)
if freeze_processor:
params_subset = _filter_out_processor(params)
... |
def get_unique_stat_by_name(stats: Iterable[Stat], name: str) -> Optional[Stat]:
matching_stats: List[Stat] = get_all_stats_by_name(stats, name)
if (len(matching_stats) == 0):
return None
return singleton(matching_stats) |
def point_of_order(E, n):
def ffext(poly):
rng = poly.parent()
fld = rng.base_ring()
if (fld in FiniteFields()):
return poly.splitting_field(rng.variable_name())
return fld.extension(poly, rng.variable_name())
n = ZZ(n)
if (n == 1):
return E(0)
(l, m) ... |
class TransfoXLModelLanguageGenerationTest(unittest.TestCase):
special_tokens = prepare_generation_special_tokens()
def test_lm_generate_transfo_xl_wt103(self):
model = TransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
input_ids = torch.Tensor([[33, 1297, 2, 1, 1009, 4, 1109, 11739, 4762,... |
class Pattern(Serialize):
raw = None
type = None
def __init__(self, value, flags=(), raw=None):
self.value = value
self.flags = frozenset(flags)
self.raw = raw
def __repr__(self):
return repr(self.to_regexp())
def __hash__(self):
return hash((type(self), self.... |
class TFLayoutLMMainLayer(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def tf_idf_claim(line):
if ('predicted_pages' in line):
sorted_p = list(sorted(line['predicted_pages'], reverse=True, key=(lambda elem: elem[1])))
pages = [p[0] for p in sorted_p[:args.max_page]]
p_lines = []
for page in pages:
lines = db.get_doc_lines(page)
l... |
def ResNet101Body(net, from_layer, use_pool5=True, use_dilation_conv5=False, **bn_param):
conv_prefix = ''
conv_postfix = ''
bn_prefix = 'bn_'
bn_postfix = ''
scale_prefix = 'scale_'
scale_postfix = ''
ConvBNLayer(net, from_layer, 'conv1', use_bn=True, use_relu=True, num_output=64, kernel_si... |
def register_Ns3BooleanChecker_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')])
return |
class CacheEntry(object):
def __init__(self, link, persistent):
self.link = link
self.persistent = persistent |
class RobertaPreLayerNormConfig(PretrainedConfig):
model_type = 'roberta-prelayernorm'
def __init__(self, vocab_size=30522, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act='gelu', hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_position_embeddings... |
def create_problem(filename):
from sfepy.discrete import Problem
problem = Problem.from_conf_file(filename, init_equations=False, init_solvers=False)
return problem |
def kde_viz_panel(hist: List[Tuple[(np.ndarray, np.ndarray)]], kde: np.ndarray, col: str, plot_width: int, plot_height: int, cfg: Config) -> Panel:
fig = kde_viz_figure(hist, kde, col, plot_width, plot_height, cfg)
return Panel(child=row(fig), title='KDE Plot') |
class BinanceCancelOrder(VirtualFunctionTool):
name = 'BinanceCancelOrder'
summary = 'Cancel an existing order.'
parameters: List[ArgParameter] = [{'name': 'order_id', 'type': 'string', 'description': 'The unique identifier of the order to cancel.', 'required': True}]
returns: List[ArgReturn] = [{'name'... |
def clean_all_dir(directory):
for subdir in os.listdir(directory):
keyword_path = os.path.join(directory, subdir)
clean_dir(keyword_path) |
class ConvLayer(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, bn_norm, stride=1, padding=0, groups=1, IN=False):
super(ConvLayer, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, bias=False, groups=groups)
... |
def is_tf_available():
candidates = ('tensorflow', 'tensorflow-cpu', 'tensorflow-gpu', 'tf-nightly', 'tf-nightly-cpu', 'tf-nightly-gpu', 'intel-tensorflow', 'intel-tensorflow-avx512', 'tensorflow-rocm', 'tensorflow-macos')
_tf_version = None
for pkg in candidates:
try:
_tf_version = impo... |
def get_session(config=None):
sess = tf.get_default_session()
if (sess is None):
sess = make_session(config=config, make_default=True)
return sess |
def encode(s, strict=False, uts46=False, std3_rules=False, transitional=False):
if isinstance(s, (bytes, bytearray)):
s = s.decode('ascii')
if uts46:
s = uts46_remap(s, std3_rules, transitional)
trailing_dot = False
result = []
if strict:
labels = s.split('.')
else:
... |
class ReadInput(object):
def __init__(self, entries):
self.entries = entries
self.input_file = entries
self.options = {}
number_of_structures = 0
number_of_obstacles = 0
number_of_articulated = 0
comment_symbols = ['#']
with open(self.input_file, 'r') ... |
class SimpleIsotypesWrapper(SpeciesWrapper):
def __init__(self, species, labels, structure_class):
SpeciesWrapper.__init__(self, species, labels, '_simple_isotypes_selector', 'isotype_generating_series', 'Simple isomorphism types', structure_class) |
class StarCrystal(UniqueRepresentation, Parent):
def __init__(self, Binf):
self._Binf = Binf
self._cartan_type = Binf.cartan_type()
Parent.__init__(self, category=HighestWeightCrystals().Infinite())
self.module_generators = (self(self._Binf.module_generators[0]),)
t0 = Binf.h... |
def to_symbol(i):
if (i == 0):
return ''
if (i == 11):
return '+'
if (i == 12):
return '*'
return str((i - 1)) |
class OfflineMetrics():
_metrics_call_requirement_map: Dict[(str, List[str])] = {'HitRate': ['ground_truth'], 'MAP': ['ground_truth'], 'NDCG': ['ground_truth'], 'RocAuc': ['ground_truth'], 'Coverage': ['train'], 'Novelty': ['train'], 'Surprisal': ['train'], 'MRR': ['ground_truth'], 'Precision': ['ground_truth'], 'R... |
class Regressor(abc.ABC):
def __init__(self, input_shape, output_dim, name):
self._input_shape = input_shape
self._output_dim = output_dim
self._name = name
self._variable_scope = None
self._cached_params = None
self._cached_param_shapes = None
def fit(self, xs, y... |
def extract_resnet(name):
configs = ('18', '34', '50', '101', '152')
resnet = models.resnet50
for config in configs:
if (config in name):
resnet = getattr(models, 'resnet{}'.format(config))
break
resnet = resnet(pretrained=True)
resnet.avgpool = nn.AdaptiveAvgPool2d(1... |
def main():
print('Prepare data')
transform = transforms.Compose([transforms.ToTensor()])
(train_data, [valid_sk_data, valid_im_data], [test_sk_data, test_im_data], dict_class) = load_data(args, transform)
train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.p... |
def get_device(device: str='cuda'):
if (torch.cuda.is_available() and (device == 'cuda')):
mydevice = torch.device(device)
else:
mydevice = torch.device('cpu')
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
return mydevice |
def load_state(fname, sess=None):
from baselines import logger
logger.warn('load_state method is deprecated, please use load_variables instead')
sess = (sess or get_session())
saver = tf.train.Saver()
saver.restore(tf.get_default_session(), fname) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.