code stringlengths 101 5.91M |
|---|
def test_exact_values():
with suppress_warnings() as sup:
sup.filter(ConstantWarning)
for key in _cd.exact_values:
assert_((((_cd.exact_values[key][0] - value(key)) / value(key)) == 0)) |
class CiscoUmbrellaVerifyDomain(VirtualFunctionTool):
name = 'CiscoUmbrellaVerifyDomain'
summary = 'Verify a domain by checking if it is safe.'
parameters: List[ArgParameter] = [{'name': 'domain', 'type': 'string', 'description': 'The domain to be verified.', 'required': True}]
returns: List[ArgReturn] ... |
def test_bool():
array = ak.Array([True, False, False, True, True, True])
assert (ak.operations.argsort(array).to_list() == [1, 2, 0, 3, 4, 5])
assert (ak.operations.sort(array).to_list() == [False, False, True, True, True, True]) |
def test_keyword_while():
N.set(128)
A = np.random.rand(N.get()).astype(np.float32)
B = np.zeros((N.get(),), dtype=np.float32)
try:
keyword_while(A, B)
except Exception as e:
print(e)
return False
assert np.allclose(A, B) |
class ApproxGradientBase():
def gradient(self, x: np.ndarray) -> np.ndarray:
raise NotImplementedError()
def __call__(self, x: np.ndarray) -> np.ndarray:
return self.gradient(x) |
def get_scores(count, pred_total, label_total):
if (pred_total != label_total):
return (0, 0, 0)
elif (count == pred_total):
return (1, 1, 1)
return (0, 0, 0) |
_node(optplan.UniformInitializer)
class UniformDistribution():
def __init__(self, params: optplan.UniformInitializer, work: workspace.Workspace) -> None:
self._params = params
def __call__(self, shape: List[int]) -> np.ndarray:
return np.random.uniform(self._params.min_val, self._params.max_val,... |
class SquareBall(Ball):
asset = 'square.png'
def create_physical_entity(self):
body = self._engine.CreateDynamicBody(position=self.physical_position, fixedRotation=True)
body.CreatePolygonFixture(box=(((self.width / 2.0) / self._world.physical_scale), ((self.height / 2.0) / self._world.physical_... |
def main(argv=None):
tf.reset_default_graph()
keep_prob = tf.placeholder(tf.float32, name='keep_probabilty')
image = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_image')
Net = BuildNetVgg16.BUILD_NET_VGG16(vgg16_npy_path=model_path)
Net.build(image, NUM_CLASSES, keep_prob)
... |
class QuantizedPyTorchModel(PytorchModel):
def __init__(self, graph: common.Graph, append2output=None):
super().__init__(graph, append2output)
def _quantize_node_activations(self, node: BaseNode, input_tensors: List[torch.Tensor]) -> List[torch.Tensor]:
if node.is_activation_quantization_enabled... |
.parametrize('flatlist_as_rvec', [False, True])
def test_RegularArray_NumpyArray(flatlist_as_rvec):
v2a = ak.contents.regulararray.RegularArray(ak.contents.numpyarray.NumpyArray(np.array([0.0, 1.1, 2.2, 3.3, 4.4, 5.5])), 3)
layout = v2a
generator = ak._connect.cling.togenerator(layout.form, flatlist_as_rvec... |
class DBPedia(XiangZhangDataset):
dirname = 'dbpedia_csv'
columns = ['class_index', 'title', 'content'] |
def register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoUl const &', 'arg0')])
cls.add_instance_attribute('transmissionMode', 'uint8_t', is_const=False)
return |
class ProfileEncoder(nn.Module):
def __init__(self):
super(ProfileEncoder, self).__init__()
self.embed_dim = ENCODER_CONFIG['embed_dim']
self.bbox_embed = Embedder((2 ** BIT), 32)
self.bbox_fc = nn.Sequential(nn.Linear((32 * PROFILE_PARAM_SEQ), self.embed_dim), nn.BatchNorm1d(self.em... |
class PartitionTuples(UniqueRepresentation, Parent):
def __classcall_private__(klass, level=None, size=None, regular=None):
if ((level is not None) and ((not isinstance(level, (int, Integer))) or (level < 1))):
raise ValueError('the level must be a positive integer')
if ((size is not Non... |
class MapFission(transformation.SingleStateTransformation):
map_entry = transformation.PatternNode(nodes.EntryNode)
nested_sdfg = transformation.PatternNode(nodes.NestedSDFG)
def annotates_memlets():
return False
def expressions(cls):
return [sdutil.node_path_graph(cls.map_entry), sdutil... |
def _sympysage_fresnelc(self):
from sage.functions.error import fresnel_cos
return fresnel_cos(self.args[0]._sage_()) |
def dist_loss(points):
P = points
Pb = P.roll(1, dims=2)
D = ((P - Pb) ** 2)
return torch.sum(D, dim=[(- 2), (- 1)]).mean() |
class Blur(BaseAugmentation):
def _augment(self, img):
return img.filter(ImageFilter.BLUR) |
def train_one_epoch(model: torch.nn.Module, criterion: DistillationLoss, data_loader: Iterable, optimizer: torch.optim.Optimizer, device: torch.device, epoch: int, loss_scaler, max_norm: float=0, model_ema: Optional[ModelEma]=None, mixup_fn: Optional[Mixup]=None, set_training_mode=True):
model.train(set_training_mo... |
def video_aug(videos, video_transform, byte=False):
if byte:
videos = videos.permute(1, 0, 2, 3).byte()
else:
videos = videos.permute(1, 0, 2, 3)
global_videos_tensor = []
(global_transform, local_transform) = video_transform
for i in range(2):
global_videos_tensor.append(glo... |
def test_named_record_fields_int32_parameters():
t = RecordType([NumpyType('int32')], ['one'], {'__record__': 'Name', 'p': [123]})
assert (str(parser.parse(str(t))) == str(t)) |
def _match(qs, ks):
qts = tuple(map((lambda x: re.compile((x + '$'))), qs))
for i in range(((len(ks) - len(qs)) + 1)):
matches = [x.match(y) for (x, y) in zip(qts, ks[i:])]
if (matches and all(matches)):
return True
return False |
def get_rule_from_children(p, pos, childen):
phrase = p.text.split(' ')
for (i, c) in enumerate(childen):
start_idx = (c.start_idx - p.start_idx)
end_idx = ((start_idx + c.end_idx) - c.start_idx)
for j in range(start_idx, end_idx):
if (i == 0):
phrase[j] = 'X'... |
def format_item_feature(out_file):
print('format_item_feature', ITEMS_FILE, out_file)
item_df = pd.read_csv(ITEMS_FILE, sep='|', header=None, encoding='ISO-8859-1')
item_df = item_df.drop([1, 3, 4], axis=1)
item_df.columns = [IID, 'i_year', 'i_Other', 'i_Action', 'i_Adventure', 'i_Animation', "i_Childre... |
class ContainerIO():
def __init__(self, file, offset, length):
self.fh = file
self.pos = 0
self.offset = offset
self.length = length
self.fh.seek(offset)
def isatty(self):
return False
def seek(self, offset, mode=io.SEEK_SET):
if (mode == 1):
... |
def tfrecords_single(db):
total_path = os.path.join(DATA_DIR, 'Tfrecords_test', (str(db.base) + db.tfrecords_filename))
writer = tf.python_io.TFRecordWriter(total_path)
print(total_path)
ins_ = {}
outs_ = {}
low = int((db.base * db.base_step))
high = min(((db.base + 1) * db.base_step), db.nu... |
class ScorerTest(unittest.TestCase):
def _get_labels(self) -> Tuple[(np.ndarray, np.ndarray, np.ndarray)]:
golds = np.array([1, 0, 1, 0, 1])
preds = np.array([1, 0, 1, 1, 0])
probs = np.array([0.8, 0.6, 0.9, 0.7, 0.4])
return (golds, preds, probs)
def test_scorer(self) -> None:
... |
class TACC():
def __init__(self, lag):
self.lag = lag
self.k = 3
check_acc(self.lag, self.k)
def make_vec(self, input_data, phyche_index=None, all_property=False, extra_phyche_index=None):
(sequence_list, phyche_value) = ready_acc(input_data, self.k, phyche_index, all_property, e... |
def build_net(inputs):
net = Conv2D(32, 3, strides=2, activation='relu')(inputs)
net = Conv2D(32, 3, strides=2, activation='relu')(net)
net = Flatten()(net)
net = Dense(128, activation='relu')(net)
net = Dense(10, activation='softmax')(net)
return net |
def load_data(fr_rating):
rating_data = {}
for line in fr_rating:
lines = line.split('\t')
user = lines[0]
item = lines[1]
time = lines[3].replace('\n', '')
item_list = []
if (user in rating_data):
rating_data[user].update({item: time})
else:
... |
def _generate_triangle_mask(point, image, shape, random):
if ((shape[0] == 1) or (shape[1] == 1)):
raise ValueError('dimension must be > 1 for triangles')
available_side = (min((image[1] - point[1]), point[0], shape[1]) - shape[0])
side = ((shape[0] + random.integers(max(1, available_side))) - 1)
... |
class Algo(abc.ABC):
def train(self, batch, **kwargs):
def _train_step(self, train_state, target_params, rng, batch, **kwargs):
def model_keys(self):
def train_states(self):
def train_params(self):
return {key: self.train_states[key].params for key in self.model_keys}
def total_steps(sel... |
class Gamma0_class(GammaH_class):
def __init__(self, level):
CongruenceSubgroup.__init__(self, level)
def _repr_(self):
return ('Congruence Subgroup Gamma0(%s)' % self.level())
def __reduce__(self):
return (Gamma0_constructor, (self.level(),))
def _latex_(self):
return ('... |
class L2Loss(nn.Module):
def __init__(self, args):
super(L2Loss, self).__init__()
self.args = args
self.loss = L2()
self.loss_labels = ['L2', 'EPE']
def forward(self, output, target):
lossvalue = self.loss(output, target)
epevalue = EPE(output, target)
ret... |
def FiBiNET(linear_feature_columns, dnn_feature_columns, bilinear_type='interaction', reduction_ratio=3, dnn_hidden_units=(256, 128, 64), l2_reg_linear=1e-05, l2_reg_embedding=1e-05, l2_reg_dnn=0, seed=1024, dnn_dropout=0, dnn_activation='relu', task='binary'):
features = build_input_features((linear_feature_column... |
def top_level_type(model: optplan.optplan.ProblemGraphNode) -> str:
return model.type.split('.')[0] |
class InputFeatures(object):
def __init__(self, input_ids, attention_mask, token_type_ids, label, pairID=None):
self.input_ids = input_ids
self.attention_mask = attention_mask
self.token_type_ids = token_type_ids
self.label = label
self.pairID = pairID
def __repr__(self):... |
def mahalanobis(u, v, VI):
u = _validate_vector(u)
v = _validate_vector(v)
VI = np.atleast_2d(VI)
delta = (u - v)
m = np.dot(np.dot(delta, VI), delta)
return np.sqrt(m) |
class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
def __init__(self, *args, **kwargs):
kwargs['max_help_position'] = 30
kwargs['indent_increment'] = 1
kwargs['width'] = (get_terminal_size()[0] - 2)
optparse.IndentedHelpFormatter.__init__(self, *args, **kwargs)
def format... |
def asarray(obj, itemsize=None, unicode=None, order=None):
return array(obj, itemsize, copy=False, unicode=unicode, order=order) |
def edit_filename(filename, prefix='', suffix='', new_ext=None):
(path, filename) = os.path.split(filename)
(base, ext) = os.path.splitext(filename)
if (new_ext is None):
new_filename = (((prefix + base) + suffix) + ext)
else:
new_filename = (((prefix + base) + suffix) + new_ext)
ret... |
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_mu_nid(val)):
if (errors == 'raise'):
raise ValueError(f'Unable to parse value {val}')
error_re... |
_utils.test(arch=get_host_arch_list())
def test_unpack_mismatch_tuple():
a = ti.field(ti.f32, ())
b = ti.field(ti.f32, ())
list = [2, 3, 4]
def func():
(a[None], b[None]) = list
with pytest.raises(ti.TaichiCompilationError):
func() |
class ArgNode(ASTNode):
def __init__(self, val, data_type, fields):
super().__init__('ARG', val, data_type, fields)
def textual_form_core(self):
prompt = ('with most' if (self.val == 'ARGMAX') else 'with least')
return ' '.join([self.fields[0].textual_form(), prompt, self.fields[1].textu... |
def build_lr_scheduler(cfg, optimizer):
scheduler_args = {'optimizer': optimizer, 'warmup_factor': cfg.SOLVER.WARMUP_FACTOR, 'warmup_epochs': cfg.SOLVER.WARMUP_EPOCHS, 'warmup_method': cfg.SOLVER.WARMUP_METHOD, 'milestones': cfg.SOLVER.STEPS, 'gamma': cfg.SOLVER.GAMMA, 'max_iters': cfg.SOLVER.MAX_ITER, 'delay_iters... |
class SimpleCustomBatch(object):
def __init__(self, data):
transposed_data = list(zip(*data))
self.inp = torch.stack(transposed_data[0], 0)
self.tgt = torch.stack(transposed_data[1], 0)
def pin_memory(self):
self.inp = self.inp.pin_memory()
self.tgt = self.tgt.pin_memory(... |
class InferenceModel(Pix2PixHDModel):
def forward(self, inp):
label = inp
return self.inference(label) |
def get_peft_state_non_lora(named_params) -> Dict:
to_return = {k: t for (k, t) in named_params if (('lora_' not in k) and (t.requires_grad or ('_lmm_projector' in k)))}
to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for (k, v) in to_return.items()}
return to_return |
def compute_b_mp(sigma, q, lmbd, verbose=False):
lmbd_int = int(math.ceil(lmbd))
if (lmbd_int == 0):
return 1.0
(mu0, _, mu) = distributions_mp(sigma, q)
b_lambda_fn = (lambda z: (mu0(z) * ((mu0(z) / mu(z)) ** lmbd_int)))
b_lambda = integral_inf_mp(b_lambda_fn)
m = ((sigma ** 2) * (mp.lo... |
class TestReduceSum(object):
def test(self):
correct = np.array([(- 2), 2, 21])
with clean_session():
array = tf.constant([[1, (- 8), 5, 4, 9], [0, 2, 7, 8, 1], [2, (- 8), 6, 4, 9]], dtype=tf.float32)
mask = tf.constant([[1, 1, 1, 0, 0], [1, 1, 0, 0, 0], [1, 0, 1, 1, 1]], dty... |
def combine_partial_results(partial_results) -> List:
records = []
for partial_result in partial_results:
records.extend(partial_result)
records = sorted(records, key=(lambda x: x['id']))
preds = [x['pred'] for x in records]
return preds |
def stretch_audio(x, rate, window_size=512):
c = lr.stft(x, n_fft=window_size, hop_length=(window_size // 4), win_length=window_size)
re = interpolation.zoom(c.real, zoom=(1, rate))
im = interpolation.zoom(c.imag, zoom=(1, rate))
w = lr.istft((re + (im * 1j)), hop_length=(window_size // 4), win_length=w... |
def accuracy(output, target, topk=(1,), avg=False):
maxk = max(topk)
batch_size = target.size(0)
(_, pred) = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, (- 1)).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view((- 1)).float().s... |
def check_real_value(f, x1, y1, x, exact=True):
z1 = np.array([complex(x1, y1)])
if exact:
assert_equal(f(z1), x)
else:
assert_almost_equal(f(z1), x) |
def _call_torchmetrics(metric: retrieval_metrics.RetrievalMetric, scores, query2target_idx, **kwargs):
(preds, target, indexes) = _prepare_torchmetrics_input(scores, query2target_idx)
return metric(preds, target, indexes=indexes, **kwargs).item() |
def plot_likelihood_BO_limit(likelihood):
df = check_likelihood_BO_limit(likelihood)
(fig, axs) = plt.subplots(1, 3, figsize=(12, 4), sharex=True)
axs[0].plot(df['mz_hat'], df['A_BO'], '-', label='$A \\quad BO$')
axs[0].plot(df['mz_hat'], df['A_RS'], '--', label='$A \\quad RS$')
axs[0].set(xlabel='$... |
def normalize_sentence(sentence):
sentence = sentence.upper()
sentence = jiwer.RemovePunctuation()(sentence)
sentence = jiwer.RemoveWhiteSpace(replace_by_space=True)(sentence)
sentence = jiwer.RemoveMultipleSpaces()(sentence)
sentence = jiwer.Strip()(sentence)
sentence = sentence.upper()
ret... |
class ChangeAmplitude(object):
def __init__(self, amplitude_range=(0.7, 1.1)):
self.amplitude_range = amplitude_range
def __call__(self, data):
if (not should_apply_transform()):
return data
data = (data * random.uniform(*self.amplitude_range))
return data |
class StanfordURLTitleModel(Coref, StanfordModel):
def __init__(self, model, debug=False):
self.model = model
self.debug = debug
def predict(self, text, a, b, pronoun_offset, a_offset, b_offset, url, id, debug=False, **kwargs):
(doc, tokens, pronoun_offset, a_offset, b_offset, a_span, b_... |
def random_length(minlen=0, maxlen=None):
if (maxlen is None):
return (minlen + int(math.floor(random.expovariate(0.1))))
else:
return random.randint(minlen, maxlen) |
def match_vert_lists(short_list, long_list):
match_list = []
idx_short = 0
for idx_long in range(len(long_list)):
long_vertex = long_list[idx_long]
short_vertex = short_list[idx_short]
if all(np.isclose(short_vertex, long_vertex, atol=1e-05)):
match_list.append(idx_long)
... |
class BinaryActivation(nn.Module):
def __init__(self):
super(BinaryActivation, self).__init__()
def forward(self, x):
out_forward = torch.sign(x)
mask1 = (x < (- 1))
mask2 = (x < 0)
mask3 = (x < 1)
out1 = (((- 1) * mask1.type(torch.float32)) + (((x * x) + (2 * x))... |
def gen_config(seq_name, label_id):
seq_home = '../DAVIS/trainval'
save_home = '../result_davis_fig'
result_home = '../result_davis'
label_id = int(label_id)
img_dir = os.path.join(seq_home, 'JPEGImages/480p', seq_name)
img_list = sorted(glob.glob(os.path.join(img_dir, '*.jpg')))
gt_path = o... |
def _get_box_class_field(eval_boxes: EvalBoxes) -> str:
assert (len(eval_boxes.boxes) > 0)
box = None
for val in eval_boxes.boxes.values():
if (len(val) > 0):
box = val[0]
break
if isinstance(box, DetectionBox):
class_field = 'detection_name'
elif isinstance(b... |
def run_evaluation(args, data, knowledge):
results = [{'id': data[i]['id']} for i in range(len(data))]
if args.run_factual:
print('Running Factualness Evaluation...')
(factual_s, meta_data) = factual_scores(args.factual_method, data, knowledge, args.use_cuda, args.gpu_device)
for (i, x) ... |
class TestTransforms(unittest.TestCase):
def setUp(self):
setup_logger()
def test_apply_rotated_boxes(self):
np.random.seed(125)
cfg = get_cfg()
is_train = True
transform_gen = detection_utils.build_transform_gen(cfg, is_train)
image = np.random.rand(200, 300)
... |
class JsTracerTable():
events: list
timestamps: list
durations: list
line: list
column: list
length: int |
def optimization_command(args):
input_file = args.input_file[0]
output_file = args.output_file[0]
ext = os.path.splitext(input_file)[1]
if (ext == '.pb'):
if (os.path.splitext(output_file)[1] != '.pb'):
raise ValueError('Input or output file format error.')
optimize_pb_model_... |
class BertAttOutput(nn.Module):
def __init__(self, config):
super(BertAttOutput, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=1e-12)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
def... |
def test_0166_ByteMaskedArray():
content = ak.operations.from_iter([[2, 3, 5], [999], [], [7, 11], [], [13], [123, 999], [17, 19]], highlevel=False)
mask = ak.index.Index8(np.array([0, 1, 0, 0, 1, 0, 1, 0], dtype=np.int8))
array = ak.highlevel.Array(ak.contents.ByteMaskedArray(mask, content, valid_when=Fals... |
class Gather(Function):
def forward(ctx, target_device, dim, *inputs):
assert all(map((lambda i: (i.device.type != 'cpu')), inputs)), 'Gather function not implemented for CPU tensors'
target_device = _get_device_index(target_device, True)
ctx.target_device = target_device
ctx.dim = d... |
def main():
args = get_args()
with open(args.from_path, 'r') as fp:
in_ = json.load(fp)
text = 'This is just a short sentence for test.'
paragraph = {'context': text, 'qas': []}
article = {'paragraphs': [paragraph], 'title': 'dummy'}
in_['data'].append(article)
with open(args.to_path... |
def map_tokenized_to_id(tokenized: List[List[str]], word_to_id: 'lightautoml.addons.interpretation.utils.WrappedVocabulary', min_k: int) -> List[torch.LongTensor]:
dataset = []
for sent in tokenized:
sent_list = [word_to_id['<START>']]
sent_list.extend(map(word_to_id, sent))
pad_tokens =... |
def _evaluate_predictions_on_coco_segm(coco_gt, coco_dt, metrics, min_threshold=0.5):
coco_eval = DensePoseCocoEval(coco_gt, coco_dt, 'segm')
coco_eval.params.iouThrs = np.linspace(min_threshold, 0.95, (int(np.round(((0.95 - min_threshold) / 0.05))) + 1), endpoint=True)
coco_eval.evaluate()
coco_eval.ac... |
def _radius_of_gyration_individual(traj):
lats_lngs = traj[[constants.LATITUDE, constants.LONGITUDE]].values
center_of_mass = np.mean(lats_lngs, axis=0)
rg = np.sqrt(np.mean([(getDistanceByHaversine((lat, lng), center_of_mass) ** 2.0) for (lat, lng) in lats_lngs]))
return rg |
.operations('flaky')
def test_flaky(testdir, openapi3_schema_url):
testdir.make_test(f'''
def api_schema():
return schemathesis.from_uri('{openapi3_schema_url}')
lazy_schema = schemathesis.from_pytest_fixture("api_schema")
_schema.parametrize()
def test_(case):
case.call_and_validate()''')
result = test... |
def _strong_orientations_of_a_mixed_graph(Dg, V, E):
length = len(E)
i = 0
boundEdges = []
while (i < length):
(u, v) = E[i]
Dg.delete_edge(u, v)
if (not (v in Dg.depth_first_search(u))):
E[i] = E[(- 1)]
E.pop()
length -= 1
Dg.add_e... |
def execute(file_name: str=None, voxel_offset: tuple=None, voxel_size: tuple=None, dtype: str=None, layer_type: str=None):
(arr, _) = nrrd.read(file_name)
if dtype:
arr = arr.astype(dtype)
chunk = Chunk(arr, voxel_offset=voxel_offset, voxel_size=voxel_size)
breakpoint()
return chunk |
_args('v', 'v', 'f', 'i')
def add(g, input_a, input_b, scale, zero_point):
kwargs = {'Y_scale_f': scale, 'Y_zero_point_i': zero_point}
output = g.op('_caffe2::Int8Add', input_a, input_b, **kwargs)
sym_help._quantized_ops.add(output)
return output |
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 forgiving_state_restore(net, loaded_dict):
loaded_dict = {k.replace('module.', ''): v for (k, v) in loaded_dict.items()}
net_state_dict = net.state_dict()
new_loaded_dict = {}
for k in net_state_dict:
new_k = k
if ((new_k in loaded_dict) and (net_state_dict[k].size() == loaded_dict[n... |
def extract_clips_with_consecutive_frames(path, num_clips=8, num_frames_per_clip=16):
valid = True
clips = list()
try:
video_data = skvideo.io.vread(path)
except:
print('file {} error'.format(path))
valid = False
return (list(np.zeros(shape=(num_clips, num_frames_per_clip... |
class MegaOnnxConfig(OnnxConfig):
def inputs(self) -> Mapping[(str, Mapping[(int, str)])]:
if (self.task == 'multiple-choice'):
dynamic_axis = {0: 'batch', 1: 'choice', 2: 'sequence'}
else:
dynamic_axis = {0: 'batch', 1: 'sequence'}
return OrderedDict([('input_ids', d... |
_registry.register('google_qa_answer_satisfaction')
class GoogleQuestQAAnswerSatisfaction(GoogleQuestQALabel):
def label_columns(self):
return ['answer_satisfaction']
def label_types(self):
return [_NUMERICAL] |
class DepsTableUpdateCommand(Command):
description = 'build runtime dependency table'
user_options = [('dep-table-update', None, 'updates src/transformers/dependency_versions_table.py')]
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
entrie... |
def get_prior_BO_BN_instance(prior, ax, sample):
x_true = prior.sample()
noise = np.random.standard_normal(prior.size)
bx = ((ax * x_true) + (np.sqrt(ax) * noise))
(rx, vx) = prior.compute_forward_posterior(ax, bx)
vx = np.mean(vx)
mx = np.mean((x_true * rx))
qx = np.mean((rx ** 2))
mse_... |
def valuestr(data: Any, limit_rows: int, limit_cols: int, formatter: (Formatter | None)=None) -> str:
if (formatter is None):
formatter = Formatter()
if (isinstance(data, (ak.highlevel.Array, ak.highlevel.Record)) and (not data.layout.backend.nplike.known_data)):
data.layout._touch_data(recursiv... |
def DM_28_6_1():
z = 2
M = [[(0, 0), ((z + 1), 6), (1, 1), (1, 1), (1, 3), (1, 4), (0, 0), (1, 4), (z, 5)], [(z, 2), (0, 0), (1, 5), (z, 1), (z, 2), (z, 6), ((z + 1), 3), (0, 0), (z, 1)], [(z, 3), ((z + 1), 4), (0, 0), ((z + 1), 5), ((z + 1), 2), ((z + 1), 4), ((z + 1), 2), (1, 6), (0, 0)], [(0, 5), (z, 6), (0,... |
def activation(fn_name):
fn = None
if (fn_name == 'relu'):
fn = tf.nn.relu
elif (fn_name == 'elu'):
fn = tf.nn.elu
elif (fn_name == 'leaky_relu'):
fn = tf.nn.leaky_relu
return fn |
def capitalize(text, language, resources):
tokens = tokenize_light(text, language)
stop_words = get_stop_words(resources)
return get_default_sep(language).join(((t.title() if (t.lower() not in stop_words) else t.lower()) for t in tokens)) |
def rgb_to_yiq(r, g, b):
y = (((0.3 * r) + (0.59 * g)) + (0.11 * b))
i = ((0.74 * (r - y)) - (0.27 * (b - y)))
q = ((0.48 * (r - y)) + (0.41 * (b - y)))
return (y, i, q) |
.parametrize('n_unique_action, is_factorizable, evaluation_policy_type, epsilon, description', valid_input_of_generate_evaluation_policy_pscore)
def test_generate_evaluation_policy_pscore_using_valid_input_data(n_unique_action, is_factorizable, evaluation_policy_type, epsilon, description) -> None:
len_list = 3
... |
def _good_shape(x, shape, axes):
if ((shape is not None) and (axes is None)):
shape = _helper._iterable_of_int(shape, 'shape')
if (len(shape) != np.ndim(x)):
raise ValueError('when given, axes and shape arguments have to be of the same length')
return shape |
def ref_top_n_error(x, l, axis, n):
orig_x = x.copy()
x = np.rollaxis(x, axis, x.ndim).reshape((- 1), x.shape[axis])
ll = np.rollaxis(l, axis, x.ndim).flatten()
y = []
for (x_, ll_) in zip(x, ll):
threshold = x_[ll_]
count = 0
for x__ in x_:
if (x__ >= threshold):... |
def conv1x1(in_planes, out_planes, stride=1, bias=False):
return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, padding=0, bias=bias) |
class RandomExtremeCartPole(ModifiableCartPoleEnv):
def __init__(self):
super(RandomExtremeCartPole, self).__init__()
self.force_mag = uniform_exclude_inner(self.np_random.uniform, self.EXTREME_LOWER_FORCE_MAG, self.EXTREME_UPPER_FORCE_MAG, self.RANDOM_LOWER_FORCE_MAG, self.RANDOM_UPPER_FORCE_MAG)
... |
def sentence_distance(anaphor, antecedent):
return ('sentence_distance', __compute_sentence_distance(anaphor, antecedent)) |
def process_test(query_path, gallery_path):
query_img_paths = glob.glob(os.path.join(query_path, '*.jpg'))
gallery_img_paths = glob.glob(os.path.join(gallery_path, '*.jpg'))
query_paths = []
pattern = re.compile('([-\\d]+)_(\\d*)')
for img_path in query_img_paths:
(pid, camid) = map(int, pat... |
class ModelWrapper(object):
def __init__(self, name=None, display=False):
self.visuals = [('universe', pin.SE3.Identity(), pin.SE3.Identity().translation)]
self.name = (self.__class__.__name__ if (name is None) else name)
self.model = pin.Model()
self.display = display
self.a... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.