code stringlengths 101 5.91M |
|---|
class HomogenizationWorkerMultiMPI(HomogenizationWorkerMulti):
def __call__(self, problem, options, post_process_hook, req_info, coef_info, micro_states, store_micro_idxs, chunks_per_worker, time_tag=''):
multiproc = multi.multiproc_mpi
dependencies = multiproc.get_dict('dependecies', clear=True)
... |
class TableauTuples(UniqueRepresentation, Parent):
Element = TableauTuple
level_one_parent_class = Tableaux_all
options = Tableaux.options
def __classcall_private__(cls, level=None, size=None):
if (not ((level is None) or (level in PositiveIntegers()))):
raise ValueError('the level m... |
def skipIfRocm(fn):
(fn)
def wrapper(*args, **kwargs):
if TEST_WITH_ROCM:
raise unittest.SkipTest("test doesn't currently work on the ROCm stack")
else:
fn(*args, **kwargs)
return wrapper |
def pprint(dump, hl=None):
for (idx, line) in enumerate(dump.split('\n')):
bts = line.split('\t')
print('{2}\t{0}\t{1}'.format(bts[0], (bts[1] if (len(bts) > 1) else ''), ('*' if ((hl is not None) and (int(hl) == idx)) else ''))) |
.fpga
def test(input_to_constant=False, extensive=False):
print(f' Testing Convolution (extensive: {extensive}) ')
queue = Queue()
p = Process(target=evaluate, args=(1, 6, 5, 1, (100, 1, 28, 28), input_to_constant, False, queue))
p.start()
p.join()
assert (queue.get() < 1e-06)
if extensive:
... |
def bleu_1(gold: str, pred: str) -> float:
return sentence_bleu([word_tokenize(gold)], word_tokenize(pred), weights=(1, 0, 0, 0)) |
def _separator(char, lengths):
return [(char * separator_length) for separator_length in lengths] |
def record_tabular_misc_stat(key, values, placement='back'):
if (placement == 'front'):
prefix = ''
suffix = key
else:
prefix = key
suffix = ''
if (len(values) > 0):
record_tabular(((prefix + 'Average') + suffix), np.average(values))
record_tabular(((prefix + ... |
def load_depth(path):
r = png.Reader(filename=path)
im = np.vstack(itertools.imap(np.uint16, r.asDirect()[2])).astype(np.float32)
return im |
def get_ancestors(start_ops, end_ops=[], include_control_inputs=False):
ancestor_ops = set()
queue = []
queue.extend(start_ops)
while (len(queue) > 0):
curr_op = queue.pop()
if (curr_op in ancestor_ops):
continue
ancestor_ops.add(curr_op)
if (curr_op in end_op... |
class Room():
def __init__(self, top, size, entryDoorPos, exitDoorPos):
self.top = top
self.size = size
self.entryDoorPos = entryDoorPos
self.exitDoorPos = exitDoorPos |
class Vertex():
def __init__(self, x, bounds=None, func=None, func_args=(), g_cons=None, g_cons_args=(), nn=None, index=None):
self.x = x
self.order = sum(x)
x_a = np.array(x, dtype=float)
if (bounds is not None):
for (i, (lb, ub)) in enumerate(bounds):
x_... |
def adaptive_avg_pool2d(input, output_size):
output_size = _list_with_default(output_size, input.size())
return torch._C._nn.adaptive_avg_pool2d(input, output_size) |
class KitchenMicrowaveKettleLightTopLeftBurnerV0(KitchenBase):
TASK_ELEMENTS = ['microwave', 'kettle', 'light switch', 'top left burner']
REMOVE_TASKS_WHEN_COMPLETE = True |
def evaluate(args, agents, ob_rms, env_name, seed, num_processes, eval_log_dir, device, n_agent, out_file):
e_env = AgarEnv(args, eval=True)
eval_episode_rewards = []
obs = e_env.reset()
for i in range(n_agent):
obs[('t' + str(i))] = torch.Tensor(obs[('t' + str(i))]).to(device)
eval_recurren... |
def generate_spec(scenario, model, tokenizer, num_prompt_tokens, num_output_tokens, random):
random_str: str = ''
if (random is not None):
random_str = f',random={random}'
return f'"{scenario}:model={model},tokenizer={tokenizer},num_prompt_tokens={num_prompt_tokens},num_output_tokens={num_output_tok... |
class DemoTransformationTest(unittest.TestCase):
def setUp(self) -> None:
sitter_lib_path = 'sitter-libs'
libs = [os.path.join(sitter_lib_path, d) for d in os.listdir(sitter_lib_path)]
tree_sitter.Language.build_library('parser/languages.so', libs)
def test_parsing(self):
code = ... |
def register_Ns3FdNetDeviceFdReader_methods(root_module, cls):
cls.add_constructor([param('ns3::FdNetDeviceFdReader const &', 'arg0')])
cls.add_constructor([])
cls.add_method('SetBufferSize', 'void', [param('uint32_t', 'bufferSize')])
cls.add_method('DoRead', 'ns3::FdReader::Data', [], visibility='priva... |
def rsync(src, dst):
rsync_cmd = f'rsync -a {src} {dst}'
print(rsync_cmd)
run_command(rsync_cmd) |
def filter_long_ex(dataset, use_span_clip, allowed_spanlen, notanfeid):
if (not use_span_clip):
sys.stderr.write((('\nfiltering out training examples with spans longer than ' + str(allowed_spanlen)) + '...\n'))
else:
sys.stderr.write((('\nclipping spans longer than ' + str(allowed_spanlen)) + '.... |
def draw_circle(d, r, loc, color='white'):
(y, x) = (loc[0], loc[1])
d.ellipse(((x - r), (y - r), (x + r), (y + r)), fill=tuple(color)) |
def default_ids(n_layers):
ids = [f't_{l}' for l in range(n_layers)]
ids[0] = 'x'
if (n_layers > 1):
ids[(- 1)] = 'y'
return ids |
class AverageMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
if isinstance(val, torch.Tensor):
val = val.item()
self.val = (val / n)
... |
class Linear(torch.nn.Module):
_version = 3
_FLOAT_MODULE = nn.Linear
def __init__(self, in_features, out_features, bias_=True, dtype=torch.qint8):
super(Linear, self).__init__()
self.in_features = in_features
self.out_features = out_features
bias = None
if bias_:
... |
def create_lmdb_for_gopro():
folder_path = './datasets/GoPro/train/blur_crops'
lmdb_path = './datasets/GoPro/train/blur_crops.lmdb'
(img_path_list, keys) = prepare_keys(folder_path, 'png')
make_lmdb_from_imgs(folder_path, lmdb_path, img_path_list, keys)
folder_path = './datasets/GoPro/train/sharp_cr... |
def get_compiled_model(model, steps_per_execution):
model.compile(optimizer=tf.keras.optimizers.RMSprop(), loss=JointsMSE(), metrics=[PercentageOfCorrectKeypoints()], steps_per_execution=steps_per_execution)
return model |
def get_sql_inference_query(model, table_name, round_digits=3, round_features=5, output_name='PROB', alias='WOE_TAB', bypass_encoded=True, template=None, nan_pattern_numbers="({0} IS NULL OR {0} = 'NaN')", nan_pattern_category="({0} IS NULL OR LOWER(CAST({0} AS VARCHAR(50))) = 'nan')", preprocessing=None, mark_values=N... |
class AnnotatedNestedModel(torch.nn.Module):
def __init__(self, qengine):
super().__init__()
self.sub1 = LinearReluModel()
self.sub2 = TwoLayerLinearModel()
self.fc3 = QuantWrapper(torch.nn.Linear(5, 5).to(dtype=torch.float))
self.fc3.qconfig = default_qconfig
self.su... |
def encode_sequence(x, alphabet):
x = x.encode('utf-8').upper()
x = alphabet.encode(x)
return x |
_config
def task_mlm_itm_mpp():
exp_name = 'mlm_itm_mpp'
datasets = ['coco', 'vg', 'sbu', 'gcc']
loss_names = _loss_names({'itm': 1, 'mlm': 1, 'mpp': 1})
batch_size = 4096
max_epoch = 10
max_image_len = (- 1) |
def adjust_learning_rate(optimizer, args):
if (args.cur_iter < args.warmup_iters):
frac = (args.cur_iter / args.warmup_iters)
step = (args.lr - args.warmup_lr)
args.running_lr = (args.warmup_lr + (step * frac))
else:
frac = ((float(args.cur_iter) - args.warmup_iters) / (args.max_... |
def to_sparse_tensor(M, value=False):
M = sp.coo_matrix(M)
if value:
return tf.SparseTensorValue(np.vstack((M.row, M.col)).T, M.data, M.shape)
else:
return tf.SparseTensor(np.vstack((M.row, M.col)).T, M.data, M.shape) |
class CFiniteSequences_generic(Parent, UniqueRepresentation):
Element = CFiniteSequence
def __init__(self, polynomial_ring, category):
base_ring = polynomial_ring.base_ring()
self._polynomial_ring = polynomial_ring
self._fraction_field = FractionField(self._polynomial_ring)
if (c... |
class Config():
root = '.'
meka = 'meka'
skmultilearn = 'skmultilearn'
tests = 'tests'
utils = 'utils' |
def clean_dir(dir_path):
file_list = glob.glob((dir_path + '/*.*'))
if (len(file_list) > 0):
for file_ in file_list:
os.remove(file_) |
def register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteHarqPhy__gt___methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteHarqPhy, ns3::empty, ns3::DefaultDeleter< ns3::LteHarqPhy > > const &', 'o')])
return |
class MaxClipGradScaler(GradScaler):
def __init__(self, init_scale, max_scale: float, growth_interval=100):
super().__init__(init_scale=init_scale, growth_interval=growth_interval)
self.max_scale = max_scale
def scale_clip(self):
if (self.get_scale() == self.max_scale):
self.... |
class CNNModelWithMaxPooling(Model):
def __init__(self, filters, strides, name=None, padding='SAME', pool_strides=(2, 2), pool_shapes=(2, 2), hidden_nonlinearity=tf.nn.relu, hidden_w_init=tf.initializers.glorot_uniform(seed=deterministic.get_tf_seed_stream()), hidden_b_init=tf.zeros_initializer()):
super().... |
class Parser(BaseParser):
def __call__(self, vocabs, moving_params=None):
top_recur = super(Parser, self).__call__(vocabs, moving_params=moving_params)
int_tokens_to_keep = tf.to_int32(self.tokens_to_keep)
with tf.variable_scope('MLP'):
(dep_mlp, head_mlp) = self.MLP(top_recur, (... |
class ANDescr(SageObject):
def is_simple(self):
return False
def neg(self, n):
return ANUnaryExpr(n, '-')
def invert(self, n):
return ANUnaryExpr(n, '~')
def abs(self, n):
return ANUnaryExpr(n, 'abs')
def real(self, n):
if self.is_complex():
return... |
class AnnotatedConvModel(torch.nn.Module):
def __init__(self, qengine):
super().__init__()
self.qconfig = torch.quantization.get_default_qconfig(qengine)
self.conv = torch.nn.Conv2d(3, 5, 3, bias=False).to(dtype=torch.float)
self.quant = QuantStub()
self.dequant = DeQuantStub... |
class DataTrainingArguments():
data_dir: str = field(metadata={'help': 'The input data dir. Should contain the .tsv files (or other data files) for the task.'})
task: Optional[str] = field(default='summarization', metadata={'help': 'Task name, summarization (or summarization_{dataset} for pegasus) or translatio... |
def download(url, filename, cookies=None):
with open(filename, 'wb') as f:
response = requests.get(url, stream=True, cookies=cookies)
total = response.headers.get('content-length')
if (total is None):
f.write(response.content)
else:
downloaded = 0
... |
class LocationMatcher(RegexMatchEach):
def __init__(self, *children, **kwargs):
kwargs['attrib'] = 'ner_tags'
kwargs['rgx'] = 'LOCATION|LOC'
super(LocationMatcher, self).__init__(*children, **kwargs) |
def main():
midi_path = '/home/joann8512/NAS_189/home/PEmoDataset/midis/Q1__8v0MFBZoco_0.mid'
key_data = '../src/key_mode_tempo.csv'
path_outdir = '../test/events'
os.makedirs(path_outdir, exist_ok=True)
fn = midi_path.split('/')[(- 1)]
key = get_key(key_data, os.path.splitext(fn)[0])
midi_o... |
def scope_aware_topological_sort(G: SDFGState, sources: Optional[Sequence[Node]]=None, condition: Optional[Callable[([Node, Node], bool)]]=None, reverse: bool=False, visited: Optional[Set[Node]]=None):
if reverse:
source_nodes = 'sink_nodes'
predecessors = G.successors
neighbors = G.predeces... |
class FlattenLayer(Layer):
def get_output_shape_for(self, input_shape):
return (input_shape[0], int(np.prod(input_shape[1:])))
def get_output_for(self, input, **kwargs):
return input.flatten(2) |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--run_group', type=str, default='Debug')
parser.add_argument('--memo', type=str, default=None)
parser.add_argument('--algo_name', type=str, default=None)
parser.add_argument('--env', type=str, default='maze', choices=['maze', 'half_... |
def validate_lei(df: Union[(str, pd.Series, dd.Series, pd.DataFrame, dd.DataFrame)], column: str='') -> Union[(bool, pd.Series, pd.DataFrame)]:
if isinstance(df, (pd.Series, dd.Series)):
return df.apply(lei.is_valid)
elif isinstance(df, (pd.DataFrame, dd.DataFrame)):
if (column != ''):
... |
def get_unknown_model_metadata(helm_model_name: str) -> ModelMetadata:
return ModelMetadata(name=helm_model_name, creator_organization_name='Unknown', display_name=helm_model_name, description=helm_model_name, access='open', release_date=date.today(), tags=[TEXT_MODEL_TAG, FULL_FUNCTIONALITY_TEXT_MODEL_TAG]) |
def update_learning_rate(scheduler, optimizer):
scheduler.step()
lr = optimizer.param_groups[0]['lr']
print(('learning rate = %.7f' % lr)) |
def collect_env_info():
has_gpu = torch.cuda.is_available()
torch_version = torch.__version__
from torch.utils.cpp_extension import CUDA_HOME
has_rocm = False
if (tuple(map(int, torch_version.split('.')[:2])) >= (1, 5)):
from torch.utils.cpp_extension import ROCM_HOME
if ((getattr(to... |
_model
def ecaresnetlight(pretrained=False, **kwargs):
model_args = dict(block=Bottleneck, layers=[1, 1, 11, 3], stem_width=32, avg_down=True, block_args=dict(attn_layer='eca'), **kwargs)
return _create_resnet('ecaresnetlight', pretrained, **model_args) |
def main():
(hparams_file, run_opts, overrides) = sb.parse_arguments(sys.argv[1:])
with open(hparams_file) as fin:
hparams = load_hyperpyyaml(fin, overrides)
sb.utils.distributed.ddp_init_group(run_opts)
sb.create_experiment_directory(experiment_directory=hparams['output_folder'], hyperparams_to... |
.parametrize('passthrough', [None, 'passthrough'])
def test_set_pipeline_step_passthrough(passthrough):
X = np.array([[1]])
y = np.array([1])
mult2 = Mult(mult=2)
mult3 = Mult(mult=3)
mult5 = Mult(mult=5)
def make():
return Pipeline([('m2', mult2), ('m3', mult3), ('last', mult5)])
pi... |
class TestHamming():
def test_basic(self):
assert_allclose(windows.hamming(6, False), [0.08, 0.31, 0.77, 1.0, 0.77, 0.31])
assert_allclose(windows.hamming(7, sym=False), [0.08, 0., 0., 0., 0., 0., 0.])
assert_allclose(windows.hamming(6), [0.08, 0., 0., 0., 0., 0.08])
assert_allclose(... |
def affect_conv_init(real_weight, imag_weight, kernel_size, init_func, criterion):
in_channels = real_weight.size(1)
out_channels = real_weight.size(0)
(a, b) = init_func(in_channels, out_channels, kernel_size=kernel_size, criterion=criterion)
(a, b) = (torch.from_numpy(a), torch.from_numpy(b))
real... |
class CMP_reg(atomic_reg):
OP_NAME = 'CMP'
_fields_ = [('cmd_short', ctypes.c_uint64, 1), ('cmd_id', ctypes.c_uint64, 20), ('cmd_id_dep', ctypes.c_uint64, 20), ('tsk_typ', ctypes.c_uint64, 4), ('tsk_eu_typ', ctypes.c_uint64, 5), ('eu_half_en', ctypes.c_uint64, 1), ('tsk_opd_num', ctypes.c_uint64, 2), ('pad_mode... |
def draw_net(caffe_net, rankdir, ext='png'):
return get_pydot_graph(caffe_net, rankdir).create(format=ext) |
def validate(args):
model = create_model(args.model, pretrained=True)
print(f'Created {args.model} model. Validating...')
eval_step = objax.Jit((lambda images, labels: eval_forward(model, images, labels)), model.vars())
image_size = model.default_cfg['input_size'][(- 1)]
(test_ds, num_batches) = ima... |
.spark
def test_tf_idf(weighting_log, tf_idf_model):
train_dataset = create_dataset(weighting_log)
tf_idf_model.fit(train_dataset)
idf = tf_idf_model._get_idf(train_dataset.interactions).toPandas()
assert np.allclose(idf[(idf['user_idx'] == 1)]['idf'], np.log1p((2 / 1)))
assert np.allclose(idf[(idf[... |
def _constant_speed_and_yaw_rate(kinematics_data: KinematicsData, sec_from_now: float, sampled_at: int) -> np.ndarray:
(x, y, vx, vy, _, _, speed, yaw_rate, _, yaw) = kinematics_data
preds = []
time_step = (1.0 / sampled_at)
distance_step = (time_step * speed)
yaw_step = (time_step * yaw_rate)
f... |
class BartphoTokenizerTest(TokenizerTesterMixin, unittest.TestCase):
tokenizer_class = BartphoTokenizer
test_rust_tokenizer = False
test_sentencepiece = True
def setUp(self):
super().setUp()
vocab = ['This', 'is', 'a', 't', 'est']
vocab_tokens = dict(zip(vocab, range(len(vocab)))... |
def main():
args = parser.parse_args()
args.pretrained = True
if args.checkpoint:
args.pretrained = False
print('==> Creating PyTorch {} model'.format(args.model))
model = geffnet.create_model(args.model, num_classes=args.num_classes, in_chans=3, pretrained=args.pretrained, checkpoint_path=a... |
class TestNNLinker(unittest.TestCase):
def test_link_prediction(self):
for input_matrix in [test_graph(), test_digraph(), test_bigraph()]:
n_neighbors = 5
threshold = 0.2
algo = NNLinker(n_neighbors=n_neighbors, threshold=threshold)
links = algo.fit_predict(in... |
.parametrize('variable_batch_size', [False, True])
.parametrize('batch_size', [1, 4])
.parametrize('shape', [(10, 32, (- 1)), ((- 1), 32, 8)])
def test_nnp_graph_reshape(tmpdir, variable_batch_size, batch_size, shape):
x = nn.Variable([10, 2, 10, 10])
h = PF.convolution(x, 4, kernel=(3, 3), stride=(1, 1))
y... |
def register_methods(root_module):
register_Ns3Address_methods(root_module, root_module['ns3::Address'])
register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstru... |
def splat(vs, dim):
if (vs.function_space().ufl_element().num_sub_elements() == dim):
v = vs[0]
if (dim == 2):
s = vs[1]
else:
s = as_vector([vs[i] for i in range(1, dim)])
else:
(v, s) = split(vs)
return (v, s) |
_group.command(name='train')
('corpus_file', type=click.Path(exists=True))
('out_file', type=click.Path())
('--mode', type=click.Choice(['sg', 'cbow']), default='sg')
('--dim-size', default=300)
('--window', default=10)
('--min-count', default=3)
('--negative', default=5)
('--epoch', default=5)
('--pool-size', default=... |
def tadgan_pipline(tadgan_hyperparameters):
pipeline_path = 'tadgan'
pipline = analysis._load_pipeline(pipeline_path, tadgan_hyperparameters)
return pipline |
def annotate_and_time(client, text, properties={}):
start = time.time()
ann = client.annotate(text, properties=properties, output_format='text')
end = time.time()
return {'annotation': ann, 'start_time': start, 'end_time': end} |
_REGISTRY.register()
class ImageNetV2(DatasetBase):
dataset_dir = 'imagenetv2'
def __init__(self, cfg):
root = os.path.abspath(os.path.expanduser(cfg.DATASET.ROOT))
self.dataset_dir = os.path.join(root, self.dataset_dir)
image_dir = 'imagenetv2-matched-frequency-format-val'
self.... |
def test_attack_directions(model, testset, adversarialset, points=51, ord=float('inf'), cuda=False):
assert (model.training is False)
assert (len(testset) > 0)
assert isinstance(testset, torch.utils.data.DataLoader)
assert isinstance(testset.sampler, torch.utils.data.SequentialSampler)
assert (len(a... |
def GreedyDecoder(output, labels, label_lengths, blank_label=28, collapse_repeated=True):
arg_maxes = torch.argmax(output, dim=2)
decodes = []
targets = []
for (i, args) in enumerate(arg_maxes):
decode = []
targets.append(text_transform.int_to_text(labels[i][:label_lengths[i]].tolist()))... |
class ModelArguments():
model_name_or_path: str = field(default='facebook/wav2vec2-base', metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name... |
def inference(data_dir: str, is_query: bool, encoder: Encoder, prefix: str, max_length: int, output_dir: str=None, batch_size: int=1024, enable_rewrite: bool=True, dataparallel: bool=True, return_vecs: bool=False, save_to_memmap: bool=True):
dataset = DatasetForEncoding(data_dir=data_dir, prefix=prefix, max_length=... |
class ResNet(nn.Module):
def __init__(self, block, layers, mode, num_classes):
super(ResNet, self).__init__()
valid_modes = {'encode', 'classify', 'both'}
if (mode not in valid_modes):
raise Exception(('mode should be one of ' + str(valid_modes)))
self.mode = mode
... |
def test_closure_over_workspace_build(simplemodels_model_data):
(model, data) = simplemodels_model_data
one = pyhf.infer.hypotest(1.0, (data + model.config.auxdata), model)
workspace = pyhf.Workspace.build(model, data)
assert json.dumps(workspace)
newmodel = workspace.model()
newdata = workspace... |
def convert_pytorch_checkpoint_to_tf(model: BertModel, ckpt_dir: str, model_name: str):
tensors_to_transpose = ('dense.weight', 'attention.self.query', 'attention.self.key', 'attention.self.value')
var_map = (('layer.', 'layer_'), ('word_embeddings.weight', 'word_embeddings'), ('position_embeddings.weight', 'po... |
def requires_datasets(obj):
name = (obj.__name__ if hasattr(obj, '__name__') else obj.__class__.__name__)
if (not is_datasets_available()):
raise ImportError(DATASETS_IMPORT_ERROR.format(name)) |
('/chat', methods=['POST'])
def chat():
logger.info('Entered /chat')
request_args = req_parser.parse_args()
logger.info('Input arguments received: %s', str(request_args))
user_utterance = request_args['new_user_utterance']
dialog_id = request_args['dialog_id']
turn_id = request_args['turn_id']
... |
def tensor_to_shm(array, data_type='float32', lock=False):
array1d = array.view(array.numel())
if (data_type == 'float32'):
c_type = ctypes.c_float
elif (data_type == 'int64'):
c_type = ctypes.c_long
result = mp.Array(c_type, array.numel(), lock=lock)
shm_as_tensor(result)[:] = array... |
def to_dag(node):
dag = nx.DiGraph()
dag.add_node(node)
for _ in range(node.n_next):
dag.add_edge(node, LeafPlaceHolder())
for _ in range(node.n_prev):
dag.add_edge(RootPlaceHolder(), node)
return dag |
def test_varlen_string():
t = ListType(NumpyType('uint8', {'__array__': 'char'}), {'__array__': 'string'})
assert (str(parser.parse(str(t))) == str(t)) |
def setup_args(current_time):
parser = eval_setupargs()
parser.set_defaults(task='tasks.emocause', datapath=os.path.join(__PATH__, 'data'), context_length=(- 1), metrics='default', batchsize=8, display_examples=True, display_add_fields='emotion', datatype='test')
return parser |
class QueryOnTrilineGradFeature(PythonFunction):
def __init__(self, ctx, min_, max_, boundary_check=False, G=None):
super(QueryOnTrilineGradFeature, self).__init__(ctx)
self._min = min_
self._max = max_
self._boundary_check = boundary_check
self._G = G
def name(self):
... |
class _FunctionCorrelation(torch.autograd.Function):
def forward(self, one, two, intStride):
rbot0 = one.new_zeros([one.shape[0], (one.shape[2] + (6 * intStride)), (one.shape[3] + (6 * intStride)), one.shape[1]])
rbot1 = one.new_zeros([one.shape[0], (one.shape[2] + (6 * intStride)), (one.shape[3] + ... |
class ReductionRT(ExecutableOperation):
KernelTemplate = '\nextern "C"\n__global__ void\n${operation_name}(${operation_name}${operation_suffix}::Params params) {\n\n // Dynamic shared memory base pointer\n extern __shared__ int SharedStorageBase[];\n\n // Declare pointer to dynamic shared memory.\n ${operation_... |
class FuncEntry():
def __init__(self, entry, ctx):
self.entry = entry
self.ctx = ctx
Z3_func_entry_inc_ref(self.ctx.ref(), self.entry)
def __deepcopy__(self, memo={}):
return FuncEntry(self.entry, self.ctx)
def __del__(self):
if (self.ctx.ref() is not None):
... |
def histogram(name: str, data: (TensorType | Callable[([], TensorType)]), **kwargs: Any) -> bool:
if include_summary(name):
try:
return tf.summary.histogram(name, evaluate_data(data), **kwargs)
except Exception as e:
tf.print(f'''Failed to write tensorboard histogram summary ... |
def test_ASGDA_optimizer_decrese():
from XCurve.AUROC.optimizer import ASGDA
from XCurve.AUROC.losses.PartialAUROC import UnbiasedPAUCLoss
hyper_param = {'mini-batch': 1024, 'alpha': 1.0, 'beta': 0.3, 'weight_decay': 1e-05, 'init_lr': 0.001}
args = edict({'model_type': 'resnet18', 'num_classes': 2, 'pre... |
def _format(val: Any, output_format: str='standard', errors: str='coarse') -> Any:
val = str(val)
result: Any = []
if (val in NULL_VALUES):
return [np.nan]
if (not validate_eu_banknote(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
err... |
class MMDistributedDataParallel(nn.Module):
def __init__(self, module, dim=0, broadcast_buffers=True, bucket_cap_mb=25):
super(MMDistributedDataParallel, self).__init__()
self.module = module
self.dim = dim
self.broadcast_buffers = broadcast_buffers
self.broadcast_bucket_size... |
class A005843(SloaneSequence):
def __init__(self):
SloaneSequence.__init__(self, offset=0)
def _repr_(self):
return 'The even numbers: a(n) = 2n.'
def _eval(self, n):
return ZZ((2 * n)) |
def test_lof_values(global_dtype):
X_train = np.asarray([[1, 1], [1, 2], [2, 1]], dtype=global_dtype)
clf1 = neighbors.LocalOutlierFactor(n_neighbors=2, contamination=0.1, novelty=True).fit(X_train)
clf2 = neighbors.LocalOutlierFactor(n_neighbors=2, novelty=True).fit(X_train)
s_0 = ((2.0 * sqrt(2.0)) / ... |
_model
def ecaresnet50d(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
default_cfg = default_cfgs['ecaresnet50d']
model = ResNet(Bottleneck, [3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True, num_classes=num_classes, in_chans=in_chans, block_args=dict(attn_layer='eca'), **kwargs)
mode... |
def load_data(fname='../data/CC-MAIN-2018-34-bios.pkl'):
with open(fname, 'rb') as f:
return pickle.load(f) |
def test_numba_arraybuilder():
numba = pytest.importorskip('numba')
builder = ak.ArrayBuilder(attrs=SOME_ATTRS)
assert (builder.attrs is SOME_ATTRS)
def func(array):
return array
assert (func(builder).attrs is SOME_ATTRS) |
class DatasetWithTimeContext(StereoHdfDataset):
def __init__(self, hdfFile, tau=1, **kwargs):
if (tau <= 0):
raise ValueError('context parameter tau should be greater than zero')
self._tau = tau
super(DatasetWithTimeContext, self).__init__(hdfFile, **kwargs)
def _collect_sing... |
class BoundarySpace_wtk_g0(BoundarySpace):
def __init__(self, level, weight, sign, F):
level = int(level)
sign = int(sign)
weight = int(weight)
if (sign not in [(- 1), 0, 1]):
raise ArithmeticError('sign must be an int in [-1,0,1]')
if (level <= 0):
ra... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.