code stringlengths 101 5.91M |
|---|
def test_arraytype_record_1():
text = str(ak.Array([{'x': 1, 'y': 1.1}, {'x': 2, 'y': 2.2}, {'x': 3, 'y': 3.3}], with_name='Thingy').type)
parsedtype = ak.types.from_datashape(text, highlevel=True)
assert isinstance(parsedtype, ak.types.ArrayType)
assert (str(parsedtype) == text) |
class Learner(BaseLearner):
def __init__(self, args):
super().__init__(args)
self._network = SimpleVitNet(args, True)
self.args = args
def after_task(self):
self._known_classes = self._total_classes
def replace_fc(self, trainloader, model, args):
model = model.eval()
... |
class Beta(Dirichlet):
def __init__(self, tau1, tau0):
tau1 = np.atleast_1d(tau1)
tau0 = np.atleast_1d(tau0)
gamma = np.concatenate((tau1[(..., None)], tau0[(..., None)]), axis=(- 1))
super(Beta, self).__init__(gamma)
def log_probability(self, p):
x = np.concatenate((p[(.... |
def train_defender():
model = get_model(args.model_tgt, args.dataset, args.pretrained)
model = model.to(args.device)
(train_loader, test_loader) = get_dataset(args.dataset, args.batch_size, augment=True)
savedir = '{}/{}/{}/'.format(args.logdir, args.dataset, args.model_tgt)
if (not os.path.exists(s... |
def test_reshape(backend):
tb = pyhf.tensorlib
assert (tb.tolist(tb.reshape(tb.ones((1, 2, 3)), ((- 1),))) == [1, 1, 1, 1, 1, 1]) |
def post_act_block(in_channels, out_channels, kernel_size, indice_key=None, stride=1, padding=0, conv_type='subm', norm_fn=None):
if (conv_type == 'subm'):
conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, bias=False, indice_key=indice_key)
elif (conv_type == 'spconv'):
conv = spc... |
class ImageProcessingMixin(metaclass=DummyObject):
_backends = ['vision']
def __init__(self, *args, **kwargs):
requires_backends(self, ['vision']) |
class VolumeSimilarity(ConfusionMatrixMetric):
def __init__(self, metric: str='VOLSMTY'):
super().__init__(metric)
def calculate(self):
tp = self.confusion_matrix.tp
fp = self.confusion_matrix.fp
fn = self.confusion_matrix.fn
if (((tp + fn) + fp) == 0):
warnin... |
def flowread(flow_path, quantize=False, concat_axis=0, *args, **kwargs):
if quantize:
assert (concat_axis in [0, 1])
cat_flow = cv2.imread(flow_path, cv2.IMREAD_UNCHANGED)
if (cat_flow.ndim != 2):
raise IOError(f'{flow_path} is not a valid quantized flow file, its dimension is {c... |
class _NoneConstraint(_Constraint):
def is_satisfied_by(self, val):
return (val is None)
def __str__(self):
return 'None' |
def audiohandler(extension, data):
if (extension not in ['flac', 'mp3', 'sox', 'wav', 'm4a', 'ogg', 'wma']):
return None
try:
import torchaudio
except ImportError as e:
raise ModuleNotFoundError('Package `torchaudio` is required to be installed for default audio file loader.Please us... |
def customized_ccompiler(plat=None, compiler=None):
c = ccompiler.new_compiler(plat=plat, compiler=compiler)
c.customize('')
return c |
def subscribeContext(subscribeCtxEle, BrokerURL):
headers = {'Accept': 'application/ld+json', 'Content-Type': 'application/json', 'Link': '< rel=" type="application/ld+json"'}
response = requests.post((BrokerURL + '/ngsi-ld/v1/subscriptions/'), data=json.dumps(subscribeCtxEle), headers=headers)
if (response... |
def add_edge_pref(graph, k=3):
info = defaultdict(list)
deg = dict(graph.degree)
edges_tried = set()
for _ in range(k):
u = min(deg, key=deg.get)
u_d = (deg[u] + 1)
deg.pop(u)
v = min(deg, key=deg.get)
deg[v] += 1
deg[u] = u_d
if (((u, v) not in ed... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--train_data_file', default=None, type=str, required=True, help='The input training data file (a text file).')
parser.add_argument('--output_dir', default=None, type=str, required=True, help='The output directory where the model predictions... |
def mean_squared_error(image0, image1):
check_shape_equality(image0, image1)
(image0, image1) = _as_floats(image0, image1)
return np.mean(((image0 - image1) ** 2), dtype=np.float64) |
def main():
error_sentences = ['', '', '', ' _ ,', ',', ',', '', '', '', '']
m_kenlm = Corrector()
m_macbert = MacBertCorrector()
for line in error_sentences:
r = m_kenlm.correct(line)
print('kenlm: {}'.format(r))
r = m_macbert.correct(line)
print('macbert: {}'.format(r))... |
def to_bool(s, fallback=None):
if (not s):
return fallback
s = s.lower()
if (s in ['1', 'true', 'yes', 'y']):
return True
if (s in ['0', 'false', 'no', 'n']):
return False
return fallback |
def main(args):
if args.seed:
random.seed(args.seed)
for line in sys.stdin:
constraints = []
def add_constraint(constraint):
constraints.append(constraint)
source = line.rstrip()
if ('\t' in line):
(source, target) = line.split('\t')
if... |
class InceptionModule(nn.Module):
def __init__(self, in_channels, out_channels: Tuple[(int, int, int, int, int, int)], name: str) -> None:
super().__init__()
self.b0 = Unit3D(in_channels=in_channels, output_channels=out_channels[0], kernel_shape=(1, 1, 1), padding=0, name=(name + '/Branch_0/Conv3d_0... |
class LinearTempDecay():
def __init__(self, t_max: int, rel_start_decay: float=0.2, start_b: int=20, end_b: int=2):
self.t_max = t_max
self.start_decay = (rel_start_decay * t_max)
self.start_b = start_b
self.end_b = end_b
def __call__(self, t: int) -> float:
is_before_sta... |
class SampleDataLoader(ClassDataLoader):
def __init__(self, data, batch_size):
dataset = self.shuffle_dataset(data)
self.dataset = dataset
self.batch_size = batch_size
self.num_iters = math.ceil((len(self.dataset) / self.batch_size))
def shuffle_dataset(self, data):
data ... |
def get_pqsource(prob_label):
prob2tuples = {'sg5': (density.IsotropicNormal(np.zeros(5), 1), data.DSIsotropicNormal(np.zeros(5), 1)), 'gmd5': (density.IsotropicNormal(np.zeros(5), 1), data.DSIsotropicNormal(np.hstack((0.2, np.zeros(4))), 1)), 'gmd1': (density.IsotropicNormal(np.zeros(1), 1), data.DSIsotropicNormal... |
def GaussianIntegers(names='I', latex_name='i'):
from sage.rings.complex_double import CDF
from sage.rings.number_field.number_field import NumberField
f = ZZ['x']([1, 0, 1])
nf = NumberField(f, names, embedding=CDF(0, 1), latex_name=latex_name)
return nf.ring_of_integers() |
def color_segmap(sample_seg, color_map):
sample_seg = torch.argmax(sample_seg, dim=1)
sample_mask = torch.zeros((sample_seg.shape[0], sample_seg.shape[1], sample_seg.shape[2], 3), dtype=torch.float)
for key in color_map:
sample_mask[(sample_seg == key)] = torch.tensor(color_map[key], dtype=torch.flo... |
class DMA_reverse_reg(atomic_reg):
OP_NAME = 'DMA_reverse'
_fields_ = [('intr_en', ctypes.c_uint64, 1), ('stride_enable', ctypes.c_uint64, 1), ('nchw_copy', ctypes.c_uint64, 1), ('cmd_short', ctypes.c_uint64, 1), ('reversed', ctypes.c_uint64, 1), ('reserved', ctypes.c_uint64, 4), ('reserved', ctypes.c_uint64, 2... |
class GlobalGenerator(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d, padding_type='reflect', conv_kind='default', activation=nn.ReLU(True), up_norm_layer=nn.BatchNorm2d, affine=None, up_activation=nn.ReLU(True), dilated_blocks_n=0, dilated_blocks... |
_model()
class EigenValue(SimOutput):
type = goos.ModelNameType('output.eigen_value')
bloch_vector = goos.types.FloatType() |
class TensorGroup(EasyDict):
def __init__(self, **kwargs):
keys = list(kwargs.keys())
values = list(kwargs.values())
assert (len(keys) == len(values))
assert all((isinstance(key, str) for key in keys)), f'Wrong types for keys: {keys}'
assert all(((isinstance(t, torch.Tensor) ... |
def BK_pieces(max_letter):
forbidden_border_labels = [('%s(%s)' % (i, j)) for i in range(1, (max_letter + 1)) for j in range(1, i)]
pieces = PuzzlePieces(forbidden_border_labels)
for i in range(1, (max_letter + 1)):
piece = DeltaPiece(('%s' % i), ('%s' % i), ('%s' % i))
pieces.add_piece(piec... |
(params=DDPG_PARAMS)
def ddpg_critic_param(request):
param = request.param
return (CriticDRR(state_repr_dim=param['state_repr_dim'], action_emb_dim=param['action_emb_dim'], hidden_dim=param['hidden_dim'], heads_num=param['heads_num'], heads_q=param['heads_q']), param) |
class MakeParsingFrontend():
def __init__(self, parser_type, lexer_type):
self.parser_type = parser_type
self.lexer_type = lexer_type
def __call__(self, lexer_conf, parser_conf, options):
assert isinstance(lexer_conf, LexerConf)
assert isinstance(parser_conf, ParserConf)
... |
def test_adaptive_padding():
for padding in ('same', 'corner'):
kernel_size = 16
stride = 16
dilation = 1
input = torch.rand(1, 1, 15, 17)
pool = AdaptivePadding(kernel_size=kernel_size, stride=stride, dilation=dilation, padding=padding)
out = pool(input)
asse... |
def validate_email(x: Union[(str, pd.Series)]) -> Union[(bool, pd.Series)]:
if isinstance(x, pd.Series):
return x.apply(_check_email, clean=False)
return _check_email(x, False) |
class GCNConv(MessagePassing):
def __init__(self, emb_dim):
super(GCNConv, self).__init__(aggr='add')
self.linear = torch.nn.Linear(emb_dim, emb_dim)
self.root_emb = torch.nn.Embedding(1, emb_dim)
self.edge_encoder = torch.nn.Linear(2, emb_dim)
def forward(self, x, edge_index, ed... |
class PcieMemoryArray():
def __getitem__(self, v):
pass
def __setitem__(self, k, v):
pass |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--input_json_file', type=str, required=True, help='A json file that contains the input samples.')
parser.add_argument('--shared_knowledge_file', type=str, default=None, help='A file that contains all the background knowledge for all s... |
def construct_decoders(loc: str, t: str, hidden_dim: int, nb_dims: int, name: str):
linear = functools.partial(hk.Linear, name=f'{name}_dec_linear')
if (loc == _Location.NODE):
if (t in [_Type.SCALAR, _Type.MASK, _Type.MASK_ONE]):
decoders = (linear(1),)
elif (t == _Type.CATEGORICAL)... |
class Trainer(object):
def __init__(self, args, task, model, criterion, dummy_batch):
if (not torch.cuda.is_available()):
raise NotImplementedError('Training on CPU is not supported')
self.args = args
self.task = task
self.criterion = criterion.cuda()
if args.fp16... |
class DyRepMemory(torch.nn.Module):
def __init__(self, num_nodes: int, raw_msg_dim: int, memory_dim: int, time_dim: int, message_module: Callable, aggregator_module: Callable, memory_updater_type: str, use_src_emb_in_msg: bool=False, use_dst_emb_in_msg: bool=False):
super().__init__()
self.num_nodes... |
def real_image3d():
img = imread(os.path.join(_root_dir(), 'data', 'img3d.tif'))
mask = imread(os.path.join(_root_dir(), 'data', 'mask3d.tif'))
return (img, mask) |
class ChamferDistanceL1(torch.nn.Module):
def __init__(self, ignore_zeros=False):
super().__init__()
self.ignore_zeros = ignore_zeros
def forward(self, xyz1, xyz2):
batch_size = xyz1.size(0)
if ((batch_size == 1) and self.ignore_zeros):
non_zeros1 = torch.sum(xyz1, di... |
class OptimizerGroupWrapper():
def __init__(self, optimizers, max_optimization_epochs=1, minibatch_size=None):
self._optimizers = optimizers
self._max_optimization_epochs = max_optimization_epochs
self._minibatch_size = minibatch_size
def get_minibatch(self, data, max_optimization_epochs... |
class GlobalFeatureExtractor(nn.Module):
def __init__(self, in_channels=64, block_channels=(64, 96, 128), out_channels=128, expand_ratio=6, num_blocks=(3, 3, 3), strides=(2, 2, 1), pool_scales=(1, 2, 3, 6), conv_cfg=None, norm_cfg=dict(type='BN'), act_cfg=dict(type='ReLU'), align_corners=False):
super(Globa... |
class cv_colors(Enum):
RED = (0, 0, 255)
GREEN = (0, 255, 0)
BLUE = (255, 0, 0)
PURPLE = (247, 44, 200)
ORANGE = (44, 162, 247)
MINT = (239, 255, 66)
YELLOW = (2, 255, 250) |
class Associahedron_class_base():
def __new__(typ, parent=None, Vrep=None, Hrep=None, cartan_type=None, **kwds):
if (cartan_type or ((parent is None) and (Vrep is None) and (Hrep is None))):
return super().__new__(typ, parent, Vrep, Hrep, **kwds)
else:
mro = typ.mro()
... |
class ConvSecondMomentNet(torch.nn.Module):
def __init__(self):
super(ConvSecondMomentNet, self).__init__()
self.conv1 = torch.nn.Conv2d(1, 1, kernel_size=1, stride=1)
self.conv1 = conv_weight_change(self.conv1)
self.bn = torch.nn.BatchNorm2d(1)
self.bn = bn_weight_change(sel... |
class CgpInfoConvSet(object):
def __init__(self, rows=30, cols=40, level_back=40, min_active_num=8, max_active_num=50):
self.input_num = 1
self.func_type = ['ConvBlock32_3', 'ConvBlock32_5', 'ConvBlock64_3', 'ConvBlock64_5', 'ConvBlock128_3', 'ConvBlock128_5', 'pool_max', 'pool_ave', 'concat', 'sum'... |
class JNDDataset(BaseDataset):
def initialize(self, dataroot, load_size=64):
self.root = dataroot
self.load_size = load_size
self.dir_p0 = os.path.join(self.root, 'p0')
self.p0_paths = make_dataset(self.dir_p0)
self.p0_paths = sorted(self.p0_paths)
self.dir_p1 = os.pa... |
def test_mean_agg_zero_neighbours():
agg = MeanAggregator(4, bias=False, act=(lambda x: x), kernel_initializer='ones')
inp1 = keras.Input(shape=(1, 2))
inp2 = keras.Input(shape=(1, 0, 2))
out = agg([inp1, inp2])
model = keras.Model(inputs=[inp1, inp2], outputs=out)
x1 = np.array([[[1, 1]]])
... |
class BasicBlock1d(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, kernel_size=[3, 3], downsample=None):
super().__init__()
if isinstance(kernel_size, int):
kernel_size = [kernel_size, kernel_size]
self.conv1 = conv(inplanes, planes, stride=stride, ke... |
def im_detect_bbox_aug(model, images, device):
boxlists_ts = []
for _ in range(len(images)):
boxlists_ts.append([])
def add_preds_t(boxlists_t):
for (i, boxlist_t) in enumerate(boxlists_t):
if (len(boxlists_ts[i]) == 0):
boxlists_ts[i].append(boxlist_t)
... |
def validate_rst_syntax(text, name, dots=True):
if (text is None):
if dots:
output_dot('E')
return (False, f'ERROR: {name}: no documentation')
ok_unknown_items = set(['mod', 'currentmodule', 'autosummary', 'data', 'legacy', 'obj', 'versionadded', 'versionchanged', 'module', 'class', ... |
class LSTMTrain(object):
def __init__(self, model, iteration, learning_rate, paths_between_pairs, positive_label, all_variables, all_user, all_movie):
super(LSTMTrain, self).__init__()
self.model = model
self.iteration = iteration
self.learning_rate = learning_rate
self.paths... |
def add_csc_loss(model, cpg_blob='cpg', cls_prob_blob='cls_prob', rois_pred_blob='rois_pred', rois_blob='rois', loss_weight=1.0, csc_layer='CSC', prefix='', **kwargs):
csc_func = getattr(model.net, csc_layer)
csc_args = {}
csc_args['tau'] = cfg.WSL.CPG_TAU
csc_args['max_iter'] = cfg.WSL.CSC_MAX_ITER
... |
def launch_ps(task, config):
ps_info = config.resource_info['ps'][task]
_prepare_ps(ps_info)
cmd = _get_launch_ps_cmd(task, config)
env = _get_ps_env(ps_info, config)
if (config.redirect_path is not None):
(stdout, stderr) = _create_log_files(config.redirect_path, 'ps', task)
logfile... |
_experiment
def multi_env_ppo(ctxt=None, seed=1):
set_seed(seed)
with LocalTFRunner(ctxt) as runner:
env1 = GarageEnv(normalize(gym.make('Adventure-ram-v4')))
env2 = GarageEnv(normalize(gym.make('Alien-ram-v4')))
env = MultiEnvWrapper([env1, env2])
policy = CategoricalMLPPolicy(e... |
def maybe_zero_3(param, ignore_status=False, name=None):
from deepspeed import zero
from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
if hasattr(param, 'ds_id'):
if (param.ds_status == ZeroParamStatus.NOT_AVAILABLE):
if (not ignore_status):
logging.w... |
def get_score(submission_folder='../env'):
submission_path = os.path.join(submission_folder, 'submission.csv')
solution = pd.read_csv(os.path.join(os.path.dirname(__file__), 'answer.csv'))[DIMENSIONS].to_numpy()
submission = pd.read_csv(submission_path)[DIMENSIONS].to_numpy()
metrics = compute_metrics_f... |
class LocalQueue():
ops = 0
stored = 0
uid = 0
empty = 0
def __init__(self, name='unnamed'):
self.items = []
self.name = name
self.uid = LocalQueue.uid
LocalQueue.uid += 1
def put(self, item, block=True):
LocalQueue.ops += 1
LocalQueue.stored += 1
... |
def train_step():
model.train()
model.zero_grad()
(data, label, op) = rules(args.batch_size, args.seq_len, args.gt_rules, 2, args.search_version, args.data_seed)
data = torch.Tensor(data).to(device)
label = torch.Tensor(label).to(device)
op = torch.Tensor(op).to(device)
(out, score) = model(... |
def _recurse_unknown_any(layout: ak.contents.EmptyArray, type_: ak.types.Type) -> ak.contents.Content:
type_form = ak.forms.from_type(type_)
return type_form.length_zero_array(highlevel=False).copy(parameters=type_._parameters) |
def cantor_reduction(a, b, f, h, genus):
assert (a.degree() < ((2 * genus) + 1))
assert (b.degree() < a.degree())
k = ((f - (h * b)) - (b ** 2))
if ((2 * a.degree()) == k.degree()):
g1 = a.degree()
x = a.parent().gen()
r = (((x ** 2) + (h[g1] * x)) - f[(2 * g1)]).roots()[0][0]
... |
class MaxPool3dSamePadding(nn.MaxPool3d):
def compute_pad(self, dim, s):
if ((s % self.stride[dim]) == 0):
return max((self.kernel_size[dim] - self.stride[dim]), 0)
else:
return max((self.kernel_size[dim] - (s % self.stride[dim])), 0)
def forward(self, x):
(batch,... |
class IntRange(IntParamType):
name = 'integer range'
def __init__(self, min=None, max=None, clamp=False):
self.min = min
self.max = max
self.clamp = clamp
def convert(self, value, param, ctx):
rv = IntParamType.convert(self, value, param, ctx)
if self.clamp:
... |
def odometry_residual(pose_a: sf.Pose2, pose_b: sf.Pose2, dist: sf.Scalar, epsilon: sf.Scalar) -> sf.V1:
return sf.V1(((pose_b.t - pose_a.t).norm(epsilon=epsilon) - dist)) |
_SEG_HEADS_REGISTRY.register()
class TransformerEncoderPixelDecoder(BasePixelDecoder):
def __init__(self, input_shape: Dict[(str, ShapeSpec)], *, transformer_dropout: float, transformer_nheads: int, transformer_dim_feedforward: int, transformer_enc_layers: int, transformer_pre_norm: bool, conv_dim: int, mask_dim: i... |
def loss_example(pred, true):
if (cfg.model.loss_fun == 'smoothl1'):
l1_loss = nn.SmoothL1Loss()
loss = l1_loss(pred, true)
return (loss, pred) |
.core
.parametrize('feature_source', ['user_id', 'item_id', ['item_id', 'user_id']])
.usefixtures('full_pandas_dataset')
def test_get_encoder(full_pandas_dataset, feature_source):
encoder = DatasetLabelEncoder()
user_item_features = ['user_id', 'item_id']
dataset_for_fit = Dataset(feature_schema=get_feature... |
def is_shuffle(stage: str) -> bool:
is_sh = {'train': True, 'val': False, 'test': False}
return is_sh[stage] |
class Timex3Tagger(Tagger):
def __init__(self, normalizer=None, stopwords=None):
default_sw = {'may'}
self.stopwords = (default_sw if (not stopwords) else stopwords)
self.normalizer = normalizer
self.tag_name = 'TIMEX3'
self._init()
def _matches(self, matchers, doc, ngram... |
class BinanceGetRealTimePrice(VirtualFunctionTool):
name = 'BinanceGetRealTimePrice'
summary = 'Retrieve real-time price information for a specified cryptocurrency pair.'
parameters: List[ArgParameter] = [{'name': 'pair', 'type': 'string', 'description': "The cryptocurrency pair to retrieve real-time price ... |
def write_outputs(image_paths, ocr_responses, output_folder, json_out):
if (not os.path.exists(output_folder)):
os.makedirs(output_folder)
for (img, ocr) in zip(image_paths, ocr_responses):
(filename, _) = os.path.splitext(img.split('/')[(- 1)])
if json_out:
with open(''.join... |
def to_standard(p, key=None):
ev_dict = evaluation_dict(p)
ordered_alphabet = sorted(ev_dict, key=key)
offset = 0
for k in ordered_alphabet:
temp = ev_dict[k]
ev_dict[k] = offset
offset += temp
result = []
for l in p:
ev_dict[l] += 1
result.append(ev_dict[... |
def register_Ns3SnrTag_methods(root_module, cls):
cls.add_constructor([param('ns3::SnrTag const &', 'arg0')])
cls.add_constructor([])
cls.add_method('Deserialize', 'void', [param('ns3::TagBuffer', 'i')], is_virtual=True)
cls.add_method('Get', 'double', [], is_const=True)
cls.add_method('GetInstanceT... |
_once
def sympy_init():
from sympy import Add
if (Add._sage_ == _sympysage_add):
return
from sympy import Mul, Pow, Symbol, Subs
from sympy.core.function import Function, AppliedUndef, Derivative
from sympy.core.numbers import Float, Integer, Rational, Infinity, NegativeInfinity, ComplexInfi... |
def gcno_files_exist(cargs):
found_code_coverage_support = False
for (root, dirs, files) in os.walk(cargs.code_dir):
for filename in files:
if (filename[(- 5):] == '.gcno'):
found_code_coverage_support = True
if (not found_code_coverage_support):
print(("[*] Could... |
def read_serialized_data_from_files(paths: List[str]) -> List:
results = []
for (i, path) in enumerate(paths):
with open(path, 'rb') as reader:
logger.info('Reading file %s', path)
data = pickle.load(reader)
results.extend(data)
logger.info('Aggregated dat... |
class TestLoader(unittest.TestCase):
def setUp(self):
self.data_home = (tempfile.gettempdir() + '/data')
def test_netset(self):
clear_data_home(self.data_home)
try:
graph = load_netset('stub', self.data_home)
except:
warnings.warn('Could not reach the NetS... |
def sentence_preprocess(phrase):
replacements = {'12': 'half', '': '-', 'TM': '', '': 'cent', 'c': 'c', 'u': 'u', 'e': 'e', '': ' degree', 'e': 'e', '...': ''}
phrase = phrase.encode('utf-8')
phrase = phrase.lstrip(' ').rstrip(' ')
for (k, v) in replacements.items():
phrase = phrase.replace(k, v... |
def __relay_host_torrc_defaults(relay):
includes = [TORRC_RELAY_FILENAME, __relay_to_torrc_default_include(relay)]
rate = max(BW_RATE_MIN, relay['bandwidth_rate'])
burst = max(BW_RATE_MIN, relay['bandwidth_burst'])
return {'includes': includes, 'bandwidth_rate': rate, 'bandwidth_burst': burst} |
def list_datasets():
return [EMOPIADataset, EssenFolkSongDatabase, HaydnOp20Dataset, HymnalDataset, HymnalTuneDataset, JSBChoralesDataset, LakhMIDIAlignedDataset, LakhMIDIDataset, LakhMIDIMatchedDataset, MAESTRODatasetV1, MAESTRODatasetV2, MAESTRODatasetV3, Music21Dataset, MusicNetDataset, NESMusicDatabase, Notting... |
def get_profile(user_id):
user = UserOper.get_user_by_uid(user_id)
if user:
storage.info('user {id} has already crawled'.format(id=user_id))
SeedidsOper.set_seed_crawled(user_id, 1)
is_crawled = 1
else:
user = get_url_from_web(user_id)
if (user is not None):
... |
class SchwartzHearstLabelingFunction(LabelingFunction):
def __init__(self, name: str, dictionary: Set[str], label: int, stopwords: Set[str]=None):
super().__init__(name, label)
self._index = {}
self.dictionary = dictionary
self.stopwords = (set() if (not stopwords) else stopwords)
... |
def read_best_info(path):
with open(path, 'r') as bi_file:
next(bi_file)
headers = next(bi_file).split(',')
values = next(bi_file).split(',')
best_metric_info = {}
best_metric_info['metrics'] = {}
best_metric_info['metrics'][''] = float(values[headers.index('')])
best_metric_... |
def starts_with(s, prefix, ignore_case=False):
if is_str(prefix):
prefix = [prefix]
prefix = list(prefix)
if ignore_case:
for (idx, pre) in enumerate(prefix):
prefix[idx] = to_lowercase(pre)
s = to_lowercase(s)
prefix = tuple(prefix)
return s.startswith(prefix) |
def _check_graph(sgv, graph):
if (not isinstance(sgv, SubGraphView)):
raise TypeError('Expected a SubGraphView, got: {}'.format(type(graph)))
if ((graph is None) or (not sgv.graph)):
return sgv
if (not isinstance(graph, tf_ops.Graph)):
raise TypeError('Expected a tf.Graph, got: {}'.f... |
def main(config_path: str):
config_dict = read_json(config_path)
num_cross_val = config_dict['num_cross_val']
SEEDS = config_dict['seeds']
to_dump = {'config': config_dict}
to_dump['stats'] = {}
for SEED in tqdm(SEEDS):
torch.manual_seed(SEED)
torch.backends.cudnn.deterministic =... |
def get_ancestral_step(sigma_from, sigma_to, eta=1.0):
if (not eta):
return (sigma_to, 0.0)
sigma_up = min(sigma_to, (eta * ((((sigma_to ** 2) * ((sigma_from ** 2) - (sigma_to ** 2))) / (sigma_from ** 2)) ** 0.5)))
sigma_down = (((sigma_to ** 2) - (sigma_up ** 2)) ** 0.5)
return (sigma_down, sig... |
def test_unknown_length_regularization():
layout = ak.to_layout([1, 2, 3, 4, 5, 6]).to_typetracer(forget_length=False)
assert (layout[unknown_length:].length == unknown_length)
assert (layout[:unknown_length].length == unknown_length)
assert (layout[::unknown_length].length == unknown_length) |
class TestNetworks(unittest.TestCase):
(itertools.product(helpers.DEBUG_DATASETS))
def test_featurizer(self, dataset_name):
batch_size = 8
hparams = hparams_registry.default_hparams('ERM', dataset_name)
dataset = datasets.get_dataset_class(dataset_name)('', [], hparams)
input_ = ... |
def _gamma(theta, mu):
concentration = theta
rate = (theta / mu)
gamma_d = Gamma(concentration=concentration, rate=rate)
return gamma_d |
def reverse_dict_value_list(dict_of_list):
return {v: k for (k, vals) in dict_of_list.items() for v in vals} |
def main():
args = parse_args()
data = load_data(args.data_path)
output_dir = Path(args.output_dir)
output_dir.mkdir(exist_ok=True, parents=True)
download(data, output_dir) |
_paths
def parse_args(args=None, namespace=None):
parser = argparse.ArgumentParser(description='Extract frames from videos.')
parser.add_argument('-i', '--in_dir', type=pathlib.Path, help='input directory')
parser.add_argument('-o', '--out_dir', type=pathlib.Path, help='output directory')
parser.add_arg... |
def get_precision_recall(G, G_gt):
(p, r, f1, t) = (0.0, 0.0, 0.0, 0.0)
for i in G:
(pi, ri, f1i) = _get_precision_recall_single(G[i], G_gt[i])
p += pi
r += ri
f1 += f1i
t += 1.0
precision = (p / t)
recall = (r / t)
f1 = (f1 / t)
return (precision, recall,... |
def log_env_info():
logging.info('Collecting environment information...')
env_info = torch.utils.collect_env.get_pretty_env_info()
logging.info(f'{env_info}') |
def inorder(node):
tags = (str(node.dep_) + ' ')
if node.lefts:
for n in node.lefts:
tags += inorder(n)
if node.rights:
for n in node.rights:
tags += inorder(n)
return tags |
def search_benchmark(pattern: str):
regexp = re.compile(pattern)
for (name, route) in BENCHMARKS.items():
if regexp.search(name):
(yield (name, route)) |
class TestFlowIncludeExclude(FLSpec):
include_exclude_error_list = []
def start(self):
print((f'{bcolors.OKBLUE}Testing FederatedFlow - Starting Test for Include and Exclude ' + f'Attributes {bcolors.ENDC}'))
self.collaborators = self.runtime.collaborators
self.exclude_agg_to_agg = 10
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.