code stringlengths 101 5.91M |
|---|
def run(flags):
flags.device = None
flags.fixed_seed = None
if torch.cuda.is_available():
print('Using CUDA.')
flags.device = torch.device('cuda')
else:
print('Not using CUDA.')
flags.device = torch.device('cpu')
keys = ['episode_return', 'episode_step', 'episode_win'... |
class Tracker():
module: nn.Module
traced: List[nn.Module] = field(default_factory=list)
handles: list = field(default_factory=list)
def _forward_hook(self, m, inputs: Tensor, outputs: Tensor):
has_not_submodules = ((len(list(m.modules())) == 1) or isinstance(m, nn.Conv2d) or isinstance(m, nn.Ba... |
def test_nonlinearity_init(pretrain_file):
model = build_model(pretrain_file, '--nonlinearity', 'relu')
run_forward_checks(model)
model = build_model(pretrain_file, '--nonlinearity', 'tanh')
run_forward_checks(model)
model = build_model(pretrain_file, '--nonlinearity', 'silu')
run_forward_checks... |
_converter_regitstry('sSGL')
def sSGL_converter(context: 'BM1688Context', reg: sSGL_reg):
(n, c, h, w) = (reg[f'res0_{d}'] for d in 'nchw')
opd0 = dict(address=reg.opd0_addr, dtype=DType(reg.opt_res0_prec), layout=Layout.stride)
res0 = dict(address=reg.res0_addr, dtype=DType(reg.opt_res0_prec), shape=(n, c,... |
def videohandler(extension, data):
if (extension not in 'mp4 ogv mjpeg avi mov h264 mpg webm wmv'.split()):
return None
try:
import torchvision.io
except ImportError as e:
raise ModuleNotFoundError('Package `torchvision` is required to be installed for default video file loader.Pleas... |
def writefile(body, fname):
out = open(fname, 'w')
for line in body:
out.write('{}\n'.format(line))
out.close() |
def test_interpolators_public_api():
assert (dir(pyhf.interpolators) == ['code0', 'code1', 'code2', 'code4', 'code4p']) |
def transformer(inputs, seq_lengths, head_size, num_heads, attn_dropout, ff_dropout, prepost_dropout, relu_hidden_size, special_attention, special_values):
with tf.name_scope('transformer_layer'):
mask = attention_bias_ignore_padding(seq_lengths)
with tf.variable_scope('self_attention'):
... |
_end_docstrings(PIPELINE_INIT_ARGS)
class ImageToTextPipeline(Pipeline):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
requires_backends(self, 'vision')
self.check_model_type((TF_MODEL_FOR_VISION_2_SEQ_MAPPING if (self.framework == 'tf') else MODEL_FOR_VISION_2_SEQ_M... |
class BoxERFNet(nn.Sequential):
def __init__(self, n_classes=19, max_input_h=512, max_input_w=1024):
(h, w) = (max_input_h, max_input_w)
super().__init__(Downsampler(3, 16, 0.0), Downsampler(16, 64, 0.03), NonBottleneck1D(64, 0.03), BottleneckBoxConv(64, 4, (h // 4), (w // 4), 0.03), Downsampler(64,... |
def process_file(in_tsv, out_json):
with open(in_tsv, 'r', encoding='utf8') as tsv:
lines = tsv.readlines()
res_list = []
for line in lines:
(one_text, one_label) = parse_one_instance(line)
if (one_text is None):
continue
one_dict = {'text': one_text, 'paraphrase'... |
def print_performance(jasonfile, model_name='model_1', figsize=(5, 5)):
records = json.load(open(jasonfile, 'r'))
print(('\n' + model_name))
print(' train_best_loss: {}'.format(records['train_best_loss']))
print(' valid_best_loss: {}'.format(records['valid_best_loss']))
print(' ... |
class Partition6(nn.Module):
LAYER_SCOPES = ['T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[18]', 'T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[19]', 'T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[20]']
TENSORS = []
def __init__(self, ... |
.parametrize('input_dim, output_dim, hidden_sizes', plain_settings)
def test_std_share_network_output_values(input_dim, output_dim, hidden_sizes):
module = GaussianMLPTwoHeadedModule(input_dim=input_dim, output_dim=output_dim, hidden_sizes=hidden_sizes, hidden_nonlinearity=None, std_parameterization='exp', hidden_w... |
def to_google_drive_download_url(view_url: str) -> str:
splits = view_url.split('/')
assert (splits[(- 1)] == 'view')
file_id = splits[(- 2)]
return f' |
class BaseDataset(object):
def get_imagedata_info(self, data):
(pids, cams) = ([], [])
for (_, pid, camid) in data:
pids += [pid]
cams += [camid]
pids = set(pids)
cams = set(cams)
num_pids = len(pids)
num_cams = len(cams)
num_imgs = len... |
class MOABBBrain(sb.Brain):
def init_model(self, model):
for mod in model.modules():
if hasattr(mod, 'weight'):
if (not ('Norm' in mod.__class__.__name__)):
init.xavier_uniform_(mod.weight, gain=1)
else:
init.constant_(mod.w... |
class WindTemplate(object):
def __init__(self):
def update(self, t, position):
return np.array([0, 0, 0]) |
class DAU(nn.Module):
def __init__(self, n_feat, kernel_size=3, reduction=8, bias=False, bn=False, act=nn.PReLU(), res_scale=1):
super(DAU, self).__init__()
modules_body = [conv(n_feat, n_feat, kernel_size, bias=bias), act, conv(n_feat, n_feat, kernel_size, bias=bias)]
self.body = nn.Sequent... |
class PointNetDenseCls(nn.Module):
def __init__(self, k=2):
super(PointNetDenseCls, self).__init__()
self.k = k
self.feat = PointNetfeat(global_feat=False)
self.conv1 = torch.nn.Conv1d(1088, 512, 1)
self.conv2 = torch.nn.Conv1d(512, 256, 1)
self.conv3 = torch.nn.Conv1... |
class mTEDx(Dataset):
SPLITS = ['train', 'valid', 'test']
LANGPAIRS = ['es-es', 'fr-fr', 'pt-pt', 'it-it', 'ru-ru', 'el-el', 'ar-ar', 'de-de', 'es-en', 'es-fr', 'es-pt', 'es-it', 'fr-en', 'fr-es', 'fr-pt', 'pt-en', 'pt-es', 'it-en', 'it-es', 'ru-en', 'el-en']
def __init__(self, root: str, lang: str, split: ... |
class Conv2d(torch.nn.Conv2d):
def __init__(self, *args, **kwargs):
norm = kwargs.pop('norm', None)
activation = kwargs.pop('activation', None)
super().__init__(*args, **kwargs)
self.norm = norm
self.activation = activation
def forward(self, x):
if ((x.numel() == ... |
class SymbolicLogic():
def statement(self, s):
global vars, vars_order
(toks, vars, vars_order) = (['OPAREN'], {}, [])
tokenize(s, toks)
statement = [toks, vars, vars_order]
try:
eval(toks)
except (KeyError, RuntimeError):
print('Malformed Stat... |
class Proposer():
def __init__(self, model_name, template_path):
self.proposer_name = model_name
self.prompt_template = open(template_path).read().strip()
def preprocess_texts(self, x2score):
return [self.normalize(x) for x in sort_by_score(x2score)]
def create_prompt(self, A_block, ... |
.cpublas
.pure
def test_bert(sdfg_name, gpu):
batch_size = 2
seq_len = 512
hidden_size = 768
class BertTokenSoftmaxClf(nn.Module):
def __init__(self):
super(BertTokenSoftmaxClf, self).__init__()
self.bert = BertLayer(BertConfig(hidden_act='relu')).eval()
self.... |
class SparseGTMetrics(object):
def __init__(self):
self._rank_list = []
def observe(self, predicted_scores: torch.Tensor, target_ranks: torch.Tensor):
predicted_scores = predicted_scores.detach()
predicted_ranks = scores_to_ranks(predicted_scores)
(batch_size, num_rounds, num_opt... |
def fully_conneted(x, units, use_bias=True, sn=False, name='fully_0', is_training=None):
x = tf.compat.v1.layers.flatten(x)
shape = x.get_shape().as_list()
channels = shape[(- 1)]
if sn:
w = tf.compat.v1.get_variable(f'{name}_kernel', [channels, units], tf.float32, initializer=tf.compat.v1.keras... |
def test_from_jax_tolist():
jax_array_1d = jax.numpy.array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
ak_jax_array_1d = ak.from_jax(jax_array_1d)
assert (ak.to_list(ak_jax_array_1d.layout) == [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) |
def Repeat(t, max=, ctx=None):
t = _to_tactic(t, ctx)
return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx) |
def test_ufunc_add_where1():
A = np.random.randint(1, 10, size=(1,), dtype=np.int32)
B = np.random.randint(1, 10, size=(1,), dtype=np.int32)
W = np.random.randint(2, size=(1,), dtype=np.bool_)
C = ufunc_add_where1(A, B, W)
if W[0]:
assert np.array_equal((A + B), C)
else:
assert (... |
class WebServer(Server):
__port: int
__index: str
def __init__(self):
super().__init__()
self.__port = 80
self.__index = '<h1>{nodeName} at {asn}</h1>'
def setPort(self, port: int) -> WebServer:
self.__port = port
return self
def setIndexContent(self, content:... |
def load_library(libname):
import sys
if sys.platform.startswith('win'):
from ctypes.util import find_library
lib_fname = find_library(libname)
if (lib_fname is None):
lib_fname = find_library(('lib' + libname))
else:
lib_fname = (('lib' + libname) + '.so')
li... |
class Sandpile(DiGraph):
def version():
print('Sage Sandpiles Version 2.4')
def help(verbose=True):
_sandpile_help(Sandpile, dedent(' For detailed help with any method FOO listed below,\n enter "Sandpile.FOO?" or enter "S.FOO?" for any Sandpile S.'), verbose=verbose)
de... |
def check_list_path_option(options):
if (options.path and (options.user or options.local)):
raise CommandError("Cannot combine '--path' with '--user' or '--local'") |
def sorted_stage_to_device_map(n_partitions, stages_on_same_gpu):
pipeline_representation_stage_to_device_map = list()
for stage_id in range(n_partitions):
seen_devices = set()
if (stage_id in stages_on_same_gpu):
device_id = min(stages_on_same_gpu[stage_id])
else:
... |
def setup_module():
Image = pytest.importorskip('PIL.Image')
global SCIKIT_LEARN_DATA, SCIKIT_LEARN_EMPTY_DATA, LFW_HOME
SCIKIT_LEARN_DATA = tempfile.mkdtemp(prefix='scikit_learn_lfw_test_')
LFW_HOME = os.path.join(SCIKIT_LEARN_DATA, 'lfw_home')
SCIKIT_LEARN_EMPTY_DATA = tempfile.mkdtemp(prefix='sci... |
def main(args):
(model, device, confidence_estimators, estimator_filenames, ned_model) = init(args)
server = Server(args, model, device, confidence_estimators, estimator_filenames, ned_model)
server.run() |
def MSD_processor(msd_path):
meta_path = os.path.join(msd_path, 'track_metadata.db')
lastfm_path = os.path.join(msd_path, 'lastfm_annotation')
allmusic_path = os.path.join(msd_path, 'allmusic_annotation')
msd500_path = os.path.join(msd_path, 'msd500_annotation')
cals_path = os.path.join(msd_path, 'c... |
def _make_dense_dataset(float_dtype):
if (float_dtype == np.float32):
return ArrayDataset32(X32, y32, sample_weight32, seed=42)
return ArrayDataset64(X64, y64, sample_weight64, seed=42) |
def train_one_epoch(train_loader, model, device, criterion, optimizer, epoch, writer, cfg, update_train_step):
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.train()
for (i, (input, target)) in enumerate(train_loader):
update_train_step += 1
target = target... |
def set_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(seed)
if args.cuda:
torch.cuda.manual_seed(args.seed) |
class MELD_loader(Dataset):
def __init__(self, txt_file, dataclass):
self.dialogs = []
f = open(txt_file, 'r')
dataset = f.readlines()
f.close()
temp_speakerList = []
self.speakerNum = []
emodict = {'anger': 'anger', 'disgust': 'disgust', 'fear': 'fear', 'joy'... |
def main(cfg):
pl.seed_everything(cfg.General.seed)
cfg.load_loggers = load_loggers(cfg)
cfg.callbacks = load_callbacks(cfg)
DataInterface_dict = {'train_batch_size': cfg.Data.train_dataloader.batch_size, 'train_num_workers': cfg.Data.train_dataloader.num_workers, 'test_batch_size': cfg.Data.test_datalo... |
class FFHQValidation(FacesBase):
def __init__(self, size, keys=None):
super().__init__()
root = 'data/ffhq'
with open('data/ffhqvalidation.txt', 'r') as f:
relpaths = f.read().splitlines()
paths = [os.path.join(root, relpath) for relpath in relpaths]
self.data = I... |
def test_base_functions_values(gels):
from sfepy.base.base import ordered_iteritems
from sfepy.discrete import PolySpace
ok = True
for (key, val) in ordered_iteritems(test_bases):
gel = gels[key[:3]]
diff = (key[(- 4):] == 'grad')
order = int(key[5])
force_bubble = (key[6... |
class CylinderFlow(ShapeFlow):
radius: float = 100
height: float = 100
num_points: int = 32 |
_model
def convformer_s18(pretrained=False, **kwargs):
model = MetaFormer(depths=[3, 3, 9, 3], dims=[64, 128, 320, 512], token_mixers=SepConv, head_fn=MlpHead, **kwargs)
model.default_cfg = default_cfgs['convformer_s18']
if pretrained:
state_dict = torch.hub.load_state_dict_from_url(url=model.defaul... |
class TFMPNetForMaskedLM(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def test_stop_event_stream_immediately(event_stream):
event_stream.stop()
assert isinstance(next(event_stream), events.Finished)
assert (next(event_stream, None) is None) |
_args('v', 'v', 'v', 'i', 'i', 'i', 'v', 'i')
def embedding_bag(g, embedding_matrix, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset):
if (scale_grad_by_freq and sym_help._training_mode):
return sym_help._onnx_unsupported('embedding_bag with scale_grad_by_freq for... |
class FlattenAgents(gym.Wrapper):
def __init__(self, env):
super().__init__(env)
sa_action_space = [len(Action), *(env.msg_bits * (2,))]
if ((len(sa_action_space) == 1) and (self.n_agents == 1)):
sa_action_space = spaces.Discrete(sa_action_space[0])
else:
sa_a... |
class StandardPermutations_n_abstract(Permutations):
def __init__(self, n, category=None):
self.n = ZZ(n)
if (category is None):
category = FiniteEnumeratedSets()
Permutations.__init__(self, category=category)
_keyword(deprecation=35233, check_input='check')
def _element_... |
def evaluate(dataset, predictions):
count = 0
f1 = exact_match = total = 0
for article in dataset:
for paragraph in article['paragraphs']:
for qa in paragraph['qas']:
total += 1
if (qa['id'] not in predictions):
message = (('Unanswered ... |
class NodeSpec():
def __init__(self, op, target):
self.op = op
self.target = target
def call_function(cls, target):
return NodeSpec('call_function', target)
def call_method(cls, target):
return NodeSpec('call_method', target)
def call_module(cls, target):
return N... |
def read_data(filename):
with open(filename, 'rb') as f:
data = pickle.load(f)
return data |
def binary_crossentropy(output, target, from_logits=False):
if (not from_logits):
epsilon = _to_tensor(_EPSILON, output.dtype.base_dtype)
output = tf.clip_by_value(output, epsilon, (1 - epsilon))
output = tf.log((output / (1 - output)))
try:
return tf.nn.sigmoid_cross_entropy_wit... |
def get_salient_frequent_verb_lemmas(verb2local_freq, verb2global_freq, top_ratio=0.8, min_freq=5):
verb2salience = get_salience(verb2local_freq, verb2global_freq)
stopword_verbs = (stop_words | {'could', 'can', 'may', 'might', 'will', 'would', 'should', 'shall', 'be', "'d'", ',', '', 'take', 'use', 'make', 'ha... |
def validate(model=None, data_loader=None, args=None):
(preds, gts, cams, cams_aux) = ([], [], [], [])
model.eval()
avg_meter = AverageMeter()
with torch.no_grad():
for (_, data) in tqdm(enumerate(data_loader), total=len(data_loader), ncols=100, ascii=' >='):
(name, inputs, labels, c... |
class Dataset(data.Dataset):
def __init__(self, dataPath, loadSize, fineSize, test=False, video=False):
super(Dataset, self).__init__()
self.dataPath = dataPath
self.image_list = [x for x in os.listdir(dataPath) if is_image_file(x)]
self.image_list = sorted(self.image_list)
i... |
def commits_since_previous(*seed_commits: Commit) -> Tuple[(Dict[(str, Commit)], Optional[Commit])]:
stack = list(seed_commits)
commits = {}
previous = None
while stack:
commit = stack.pop()
if (commit.binsha in commits):
continue
matches = VERSION_REG.findall(commit.... |
def get_args():
parser = argparse.ArgumentParser(description='RL')
parser.add_argument('--env-name', default='simple_spread', help='one from {simple_spread, simple_formation, simple_line})')
parser.add_argument('--num-agents', type=int, default=3)
parser.add_argument('--masking', action='store_true', he... |
_numpy_output()
def test_reduce_global_None(A: dace.float64[(10, 5, 3)]):
return np.mean(A, axis=my_none) |
def p_positional_and_keyword_args(s, end_sy_set, templates=None):
positional_args = []
keyword_args = []
pos_idx = 0
while (s.sy not in end_sy_set):
if ((s.sy == '*') or (s.sy == '**')):
s.error('Argument expansion not allowed here.', fatal=False)
parsed_type = False
... |
def _try_get_shapes(nets):
try:
(shapes, _) = workspace.InferShapesAndTypes(nets)
return shapes
except Exception as e:
logging.warning('Failed to compute shapes: %s', e)
return {} |
def result_level(finding):
level = finding.get('level', '').strip().lower()
return (level if (level in ('none', 'note', 'warning', 'error')) else None) |
def rebuild_tensor(cls, storage, metadata):
(storage_offset, size, stride) = metadata
return torch._utils._rebuild_tensor(storage, storage_offset, size, stride) |
def load_constituency_tree(parents, words):
trees = []
root = None
size = len(parents)
for i in xrange(size):
trees.append(None)
word_idx = 0
for i in xrange(size):
if (not trees[i]):
idx = i
prev = None
prev_idx = None
word = words... |
class LocalWindowService(WindowService, ABC):
def __init__(self, service: TokenizerService):
self.service: TokenizerService = service
def encode(self, text: str, truncation: bool=False, max_length: Optional[int]=None) -> EncodeResult:
if (max_length is None):
max_length = self.max_re... |
class DownloadImage():
def __init__(self, out_path, img_url_file, proxies, header, retries, timeout):
self.header = header
self.proxies = proxies
self.out_path = out_path
self.retries = retries
self.timeout = timeout
self.img_url_file = img_url_file
self.file_... |
def register_Ns3Queue__Ns3QueueDiscItem_methods(root_module, cls):
cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
cls.add_constructor([])
cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], is_pure_virtual=True, is_virtual=True)
cls.add_method('Dequeue', ... |
def grey_closing(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0):
if ((size is not None) and (footprint is not None)):
warnings.warn('ignoring size because footprint is set', UserWarning, stacklevel=2)
tmp = grey_dilation(input, size, footprint, structu... |
def _init_impl(path, trigger_lazy=True):
with dll_lock:
_IMPORTED_DYNDEPS.add(path)
with extension_loader.DlopenGuard():
ctypes.CDLL(path)
core.RefreshRegisteredOperators(trigger_lazy) |
def house(metadata: bool=False) -> Union[(sparse.csr_matrix, Bunch)]:
row = np.array([0, 0, 1, 1, 2, 3])
col = np.array([1, 4, 2, 4, 3, 4])
adjacency = sparse.csr_matrix((np.ones(len(row), dtype=int), (row, col)), shape=(5, 5))
adjacency = (adjacency + adjacency.T).astype(bool)
if metadata:
... |
def Attention_transfer(student, teacher, beta=1000.0):
def Attention(source, target):
with tf.variable_scope('Attention'):
(B, _, _, Ds) = source.get_shape().as_list()
Dt = target.get_shape().as_list()[(- 1)]
if (Ds != Dt):
with tf.variable_scope('Map'):
... |
def count_arithmetic_ops_code(code_or_block: Union[(List[ast.AST], ast.AST, str)]) -> int:
ctr = ArithmeticCounter()
if isinstance(code_or_block, (tuple, list)):
for stmt in code_or_block:
ctr.visit(stmt)
elif isinstance(code_or_block, str):
ctr.visit(ast.parse(code_or_block))
... |
class MLPPreprocessor(MLPFunction):
def __init__(self, env_spec, layer_sizes=(128, 16), output_nonlinearity=None, name='observations_preprocessor'):
Parameterized.__init__(self)
Serializable.quick_init(self, locals())
self._name = name
self._Do = env_spec.observation_space.flat_dim
... |
class TweedieRegressor(_GeneralizedLinearRegressor):
_parameter_constraints: dict = {**_GeneralizedLinearRegressor._parameter_constraints, 'power': [Interval(Real, None, None, closed='neither')], 'link': [StrOptions({'auto', 'identity', 'log'})]}
def __init__(self, *, power=0.0, alpha=1.0, fit_intercept=True, l... |
class TestStacking2(unittest.TestCase):
def setUp(self):
self.task = generate_task(task_generator_id='stacking2')
self.env = CausalWorld(task=self.task, enable_visualization=False)
return
def tearDown(self):
self.env.close()
return
def test_determinism(self):
... |
def validate_axes_specs(positions, specs, is_c_contig, is_f_contig):
packing_specs = ('contig', 'strided', 'follow')
access_specs = ('direct', 'ptr', 'full')
has_contig = has_follow = has_strided = has_generic_contig = False
last_indirect_dimension = (- 1)
for (idx, (access, packing)) in enumerate(s... |
def _should_use_custom_op():
if (not enabled):
return False
if (LooseVersion(torch.__version__) >= LooseVersion('1.7.0')):
return True
warnings.warn(f'grid_sample_gradfix not supported on PyTorch {torch.__version__}. Falling back to torch.nn.functional.grid_sample().')
return False |
(0.2)
def collect_info(entities, *argv, **kargs):
en_name = kargs['cur_entity_name']
return resp(True, msg=('Info collected: ' + str(entities[en_name]))) |
def register_Ns3TcpOptionSack_methods(root_module, cls):
cls.add_constructor([param('ns3::TcpOptionSack const &', 'arg0')])
cls.add_constructor([])
cls.add_method('AddSackBlock', 'void', [param('std::pair< ns3::SequenceNumber< unsigned int, int >, ns3::SequenceNumber< unsigned int, int > >', 's')])
cls.... |
def prepare_transfoxl_input(args, _, tokenizer, prompt_text):
prompt_text = ((args.padding_text if args.padding_text else PADDING_TEXT) + prompt_text)
return prompt_text |
def write_release_task(filename='NOTES.txt'):
idirs = Path('release')
source = Path(get_latest_release_doc('doc/source/release'))
target = Path(filename)
if target.exists():
target.remove()
tmp_target = Path((filename + '.txt'))
os.system(f'cp {source} {tmp_target}')
with open(str(tm... |
def retrieve_tigge_data():
date1 = [(str(i) + '-01-01') for i in xrange(2016, 2017)]
date2 = [(str(i) + '-12-31') for i in xrange(2016, 2017)]
dates = date1
for j in range(0, 10):
dates[j] = ((date1[j] + '/to/') + date2[j])
data_dir = '/media/sebastian/Elements/Postproc_NN/data/forecasts/aux... |
def register_Ns3Icmpv4DestinationUnreachable_methods(root_module, cls):
cls.add_constructor([param('ns3::Icmpv4DestinationUnreachable const &', 'arg0')])
cls.add_constructor([])
cls.add_method('GetData', 'void', [param('uint8_t *', 'payload')], is_const=True)
cls.add_method('GetHeader', 'ns3::Ipv4Header... |
class MemoryEfficientSwish(nn.Module):
def forward(self, x):
return SwishImplementation.apply(x) |
def test_unconstrained0():
def fg(x):
f = (x ** 2)
g = (2 * x)
return (f, g)
res = minimize(fg, 100.0, np=np)
print(res)
assert_allclose(res.x, [0], atol=0.0001) |
def get_p_and_g_mean_norm2(it):
size = 1e-08
su_p = 0
su_g = 0
for x in it:
if (x.grad is None):
continue
size += 1.0
su_p += x.norm()
su_g += x.grad.norm()
return ((su_p / size), (su_g / size)) |
def _test_torch_onnx_inference_seq_lens_in_out(out_onnx_model: str):
print(out_onnx_model)
import onnxruntime as ort
torch.manual_seed(42)
dummy_data = torch.randn([3, 50, 9])
dummy_seq_lens = torch.tensor([27, 50, 43], dtype=torch.int32)
session = ort.InferenceSession(out_onnx_model)
output... |
class Actor(nn.Module):
def __init__(self, state_dim, action_dim, max_action, phi=0.05):
super(Actor, self).__init__()
self.l1 = nn.Linear((state_dim + action_dim), 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, action_dim)
self.max_action = max_action
se... |
def test_metricscallback_init():
def dummy_metric(model) -> float:
return 0.0
callback = MetricsCallback(dummy_metric)
assert (callback.metric_fns == {'dummy_metric': dummy_metric})
metrics = [dummy_metric]
callback = MetricsCallback(metrics)
assert (callback.metric_fns == {'dummy_metric... |
class _JumpF():
def __init__(self):
self.nfe = 0
def __call__(self, t, x):
self.nfe += 1
if (t < 0.5):
return ((- 0.5) * x)
else:
return (x ** 2) |
class RandomSplitter(Splitter):
_init_arg_names = ['test_size', 'drop_cold_users', 'drop_cold_items', 'seed', 'query_column', 'item_column']
def __init__(self, test_size: float, drop_cold_items: bool=False, drop_cold_users: bool=False, seed: Optional[int]=None, query_column: str='query_id', item_column: str='it... |
class TFBertForTokenClassification():
def __init__(self, *args, **kwargs):
requires_tf(self)
def from_pretrained(self, *args, **kwargs):
requires_tf(self) |
class CosineLRScheduleConfig(FairseqDataclass):
warmup_updates: int = field(default=0, metadata={'help': 'warmup the learning rate linearly for the first N updates'})
warmup_init_lr: float = field(default=(- 1), metadata={'help': 'initial learning rate during warmup phase; default is cfg.lr'})
lr: List[floa... |
def check_files(check_str, output_folder, recipe_id, pattern='file_exists=\\[(.*?)\\]'):
check = True
files_to_check = re.search(pattern, check_str)
files_to_check = files_to_check.group(1).split(',')
for file_to_check in files_to_check:
check_path = os.path.join(output_folder, file_to_check)
... |
def broadcast_types(src, dst):
n = abs((src.ndim - dst.ndim))
if (src.ndim < dst.ndim):
return (insert_newaxes(src, n), dst)
else:
return (src, insert_newaxes(dst, n)) |
class SpeedtestBenchmark(Benchmark):
def __init__(self, server_id=13658):
self.server_id = server_id
super().__init__(name='SpeedTest')
def run(self):
logger.debug('Launching Speedtest CLI')
docker_client = docker.from_env()
terminal_workstation = docker_client.containers... |
class KaldiDecoderConfig(FairseqDataclass):
hlg_graph_path: Optional[str] = None
output_dict: str = MISSING
kaldi_initializer_config: Optional[KaldiInitializerConfig] = None
acoustic_scale: float = 0.5
max_active: int = 10000
beam_delta: float = 0.5
hash_ratio: float = 2.0
is_lattice: bo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.