code stringlengths 101 5.91M |
|---|
def transfer_gradient_from_player_to_shared(player, shared_model, gpu_id):
for (param, shared_param) in zip(player.model.parameters(), shared_model.parameters()):
if shared_param.requires_grad:
if (param.grad is None):
shared_param._grad = torch.zeros(shared_param.shape)
... |
def parse_args(args):
parser = argparse.ArgumentParser(description='hsp', formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--layout', type=str, required=True, help='layout name')
parser.add_argument('--k', type=int, default=18, help='number of selected policies')
parser.add_arg... |
def test_efficientnet_backbone():
with pytest.raises(AssertionError):
EfficientNet(arch='c3')
model = EfficientNet(arch='b0', out_indices=(0, 1, 2, 3, 4, 5, 6))
model.train()
imgs = torch.randn(2, 3, 32, 32)
feat = model(imgs)
assert (len(feat) == 7)
assert (feat[0].shape == torch.Si... |
.parametrize('n_ensembles', [2])
.parametrize('batch_size', [32])
.parametrize('reduction', ['min', 'max', 'mean', 'none'])
def test_reduce_ensemble(n_ensembles: int, batch_size: int, reduction: str) -> None:
y = torch.rand(n_ensembles, batch_size, 1)
ret = _reduce_ensemble(y, reduction)
if (reduction == 'm... |
def test_point_f1_score_nan():
expected = pd.DataFrame({'timestamp': [2, 3]})
observed = pd.DataFrame({'timestamp': [4, 5]})
returned = point_f1_score(expected, observed)
assert np.isnan(returned) |
class Buf(object):
def __init__(self):
self.head = []
self.tail = self.head
def append_left(self, item):
self.head = [item, self.head]
def append(self, item):
last = self.tail
self.tail = []
last.append(item)
last.append(self.tail)
def extend(self,... |
class MyReLU(torch.autograd.Function):
def forward(ctx, input):
ctx.save_for_backward(input)
return input.clamp_min_(0)
def backward(ctx, grad_output):
(input,) = ctx.saved_tensors
grad_input = torch.ones_like(input, dtype=input.dtype, device=input.device)
grad_input[(inp... |
_function_dispatch(_count_dispatcher)
def rfind(a, sub, start=0, end=None):
return _vec_string(a, integer, 'rfind', ([sub, start] + _clean_args(end))) |
def test_set_schema_path_context(monkeypatch):
monkeypatch.setattr(pyhf.schema.variables, 'schemas', pyhf.schema.variables.schemas, raising=True)
new_path = pathlib.Path('a/new/path')
with pyhf.schema(new_path):
assert (pyhf.schema.path == new_path) |
def test_allowable_amino_acid_locations_do_not_contain_amino_acids_we_cant_create(msa_sampler):
actual_allowed = map_aa_idx_to_tok_set(msa_sampler)
non_single_standard = set('XBUXZO.')
assert actual_allowed.isdisjoint(non_single_standard) |
def test_case_3():
int_0 = 2423
queue_0 = module_0.Queue(int_0)
assert (f'{type(queue_0).__module__}.{type(queue_0).__qualname__}' == 'queue_example.Queue')
assert (queue_0.max == 2423)
assert (queue_0.head == 0)
assert (queue_0.tail == 0)
assert (queue_0.size == 0)
assert (f'{type(queue... |
def mtg_jamendo_read_file(tsv_file):
tracks = {}
tags = defaultdict(dict)
artist_ids = set()
albums_ids = set()
with open(tsv_file) as fp:
reader = csv.reader(fp, delimiter='\t')
next(reader, None)
for row in reader:
track_id = get_id(row[0])
tracks[tr... |
class TestSimulator(unittest.TestCase):
def testScheduleNow(self):
def callback(args):
self._args_received = args
self._cb_time = Simulator.Now()
Simulator.Destroy()
self._args_received = None
self._cb_time = None
Simulator.ScheduleNow(callback, 'args'... |
def string_builder(string):
newstring = string
if string[0].isdigit():
newstring = ('_' + string)
out = re.sub('[^a-zA-Z0-9_]', '_', newstring)
return out |
def expert_reward(state, action):
state_action = tensor(np.hstack([state, action]), dtype=dtype)
with torch.no_grad():
return (- math.log(discrim_net(state_action)[0].item())) |
_level_function()
def argmin(array, axis=None, *, keepdims=False, mask_identity=True, highlevel=True, behavior=None, attrs=None):
(yield (array,))
return _impl(array, axis, keepdims, mask_identity, highlevel, behavior, attrs) |
def one_hot(index: torch.Tensor, n_cat: int) -> torch.Tensor:
onehot = torch.zeros(index.size(0), n_cat, device=index.device)
onehot.scatter_(1, index.type(torch.long), 1)
return onehot.type(torch.float32) |
def complex_conv_op(input, real_weight, imag_weight, bias, stride, padding, dilation, conv1d):
cat_real = torch.cat([real_weight, (- imag_weight)], dim=1)
cat_imag = torch.cat([imag_weight, real_weight], dim=1)
cat_complex = torch.cat([cat_real, cat_imag], dim=0)
if conv1d:
convfunc = F.conv1d
... |
class TestLeakyRelu(hu.HypothesisTestCase):
def _get_inputs(self, N, C, H, W, order):
input_data = (np.random.rand(N, C, H, W).astype(np.float32) - 0.5)
input_data[np.logical_and((input_data >= 0), (input_data <= 0.051))] = 0.051
input_data[np.logical_and((input_data <= 0), (input_data >= (-... |
def cuda_setup(cuda=False, gpu_idx=0):
if (cuda and torch.cuda.is_available()):
device = torch.device('cuda')
torch.cuda.set_device(gpu_idx)
else:
device = torch.device('cpu')
return device |
def average(metrics, count=1.0):
if (world_size == 1):
return metrics
tensor = torch.tensor((list(metrics) + [1]), device='cuda', dtype=torch.float32)
tensor *= count
torch.distributed.all_reduce(tensor, op=torch.distributed.ReduceOp.SUM)
return (tensor[:(- 1)] / tensor[(- 1)]).cpu().numpy()... |
def pose_around(theta1, theta2, c2w):
c2w = ((trans_t(theta1).cpu() rot_theta(((theta2 / 180.0) * np.pi)).cpu()) c2w)
return c2w |
class LSTMModel(torch.nn.Module):
def __init__(self, diag_vocab_size, med_vocab_size, diag_embedding_size, med_embedding_size, diag_hidden_size, med_hidden_size, hidden_size, end_index, pad_index, bidirectional=True):
super().__init__()
self.pad_index = pad_index
self.end_index = end_index
... |
class NONLocalBlock3D(_NonLocalBlockND):
def __init__(self, in_channels, inter_channels=None, sub_sample=True, bn_layer=True):
super(NONLocalBlock3D, self).__init__(in_channels, inter_channels=inter_channels, dimension=3, sub_sample=sub_sample, bn_layer=bn_layer) |
def _check(gt_labels, pred_labels):
if (gt_labels.ndim != 1):
raise ValueError(('gt_labels must be 1D: shape is %r' % (gt_labels.shape,)))
if (pred_labels.ndim != 1):
raise ValueError(('pred_labels must be 1D: shape is %r' % (pred_labels.shape,)))
if (gt_labels.shape != pred_labels.shape):
... |
def iteration(summary, phase, global_step, epoch, num_epochs, step, num_steps, values, multiple_lines=False):
logger = get_logger()
msg = ((_current_total_formatter(epoch, num_epochs) + ' ') + _current_total_formatter(step, num_steps))
for (k, v) in values.items():
if isinstance(v, AverageMeter):
... |
class InfiniteDataLoader():
def __init__(self, dataset, weights, batch_size, num_workers):
super().__init__()
if (weights is None):
sampler = torch.utils.data.RandomSampler(dataset, replacement=True)
else:
sampler = torch.utils.data.WeightedRandomSampler(weights, repl... |
def main():
args = get_args()
data = np.load(args.dataset_path_input)
data = to_categorical(data, 2)
if (args.model == 'cvae_style'):
data = np.argmax(data, axis=(- 1))
data = np.expand_dims(data, axis=(- 1))
data = ((2 * data) - 1)
if args.split:
(x_train, x_test) = ... |
_grad()
def eval(loader, model, std, mean, device):
batch_rmse_loss = 0
batch_mae_loss = 0
batch_mape_loss = 0
for (idx, (inputs, targets)) in enumerate(tqdm(loader)):
model.eval()
inputs = inputs.to(device)
targets = targets.to(device)
output = model(inputs)
out_... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--ensemble', type=bool, default=False, help='ensemble flag. If True, generate a logit file which is used in the ensemble part')
parser.add_argument('--split', type=str, default='test')
parser.add_argument('--input', type=str, defa... |
class BiTrainer(Trainer):
def _save(self, output_dir: Optional[str]=None):
output_dir = (output_dir if (output_dir is not None) else self.args.output_dir)
os.makedirs(output_dir, exist_ok=True)
logger.info('Saving model checkpoint to %s', output_dir)
if (not hasattr(self.model, 'save... |
class CNN(nn.Module):
n_labels: int = 1
def __call__(self, x):
x = nn.Conv(features=32, kernel_size=(3, 3))(x)
x = nn.relu(x)
x = nn.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
x = nn.Conv(features=64, kernel_size=(3, 3))(x)
x = nn.relu(x)
x = nn.avg_pool(x, ... |
def test_diff(variable_x, variable_y, functional_hxy):
hxy_x = sn.diff(functional_hxy, variable_x)
hxy_y = sn.diff(functional_hxy, variable_x) |
def test_desc_to_dlpack():
mydata = np.arange(6).reshape(2, 3).astype(np.float32)
ptr = ctypes.c_void_p(mydata.__array_interface__['data'][0])
tensor = array_to_torch_tensor(ptr, dace.float32[(2, 3)])
assert np.allclose(tensor, mydata)
mydata += 1
assert np.allclose(tensor, mydata) |
class ImgVisualizer(Visualizer):
def __init__(self, img_rgb, meta, **kwargs):
super(ImgVisualizer, self).__init__(img_rgb, meta, **kwargs)
def draw_text(self, text, position, *, font_size=None, color='w', horizontal_alignment='center', vertical_alignment='bottom', box_facecolor='black', alpha=0.5):
... |
def read_wtq_table(PATH):
all_table = []
for csv_file in range(200, 205):
tagged_path = ((PATH + str(csv_file)) + '-tagged/')
page_path = ((PATH + str(csv_file)) + '-page/')
for i in range(1000):
try:
table = {}
skip = False
wit... |
def perceptual_loss(id_featureA, id_featureB):
cosine_d = torch.sum((id_featureA * id_featureB), dim=(- 1))
return (torch.sum((1 - cosine_d)) / cosine_d.shape[0]) |
def solve(*args, **keywords):
show = keywords.pop('show', False)
s = Solver()
s.set(**keywords)
s.add(*args)
if show:
print(s)
r = s.check()
if (r == unsat):
print('no solution')
elif (r == unknown):
print('failed to solve')
try:
print(s.model(... |
def dispatch_on(*dispatch_args):
assert dispatch_args, 'No dispatch args passed'
dispatch_str = ('(%s,)' % ', '.join(dispatch_args))
def check(arguments, wrong=operator.ne, msg=''):
if wrong(len(arguments), len(dispatch_args)):
raise TypeError(('Expected %d arguments, got %d%s' % (len(di... |
def worker_init_function(worker_id: int) -> None:
(global_rank, process_seed) = (int(os.environ['LOCAL_RANK']), torch.initial_seed())
base_seed = (process_seed - worker_id)
seed_seq = np.random.SeedSequence([base_seed, worker_id, global_rank])
np.random.seed(seed_seq.generate_state(4))
(torch_seed_s... |
def parse_arguments(parser: argparse.ArgumentParser):
parser = add_base_arguments(parser)
group_data = parser.add_argument_group('dataset')
group_data.add_argument('--dataset', type=str, default='conll2003', help='dataset name')
group_data.add_argument('--doc_level', default=False, action='store_true', ... |
def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
logger.info('Loading weights from: {}'.format(weights_file))
ws_blobs = workspace.Blobs()
src_blobs = load_object(weights_file)
if ('cfg' in src_blobs):
saved_cfg = load_cfg(src_blobs['cfg'])
configure_bbox_reg_weights(... |
class NFSDataset(Dataset):
def __init__(self, name, dataset_root, load_img=False):
super(NFSDataset, self).__init__(name, dataset_root)
with open(os.path.join(dataset_root, (name + '.json')), 'r') as f:
meta_data = json.load(f)
pbar = tqdm(meta_data.keys(), desc=('loading ' + nam... |
class NodeNameFilter(BaseNodeMatcher):
def __init__(self, node_name):
self.node_name = node_name
def apply(self, input_object: Any) -> bool:
if (input_object.name == self.node_name):
return True |
def _set_input_and_output_names(graph, input_names, output_names):
def set_names(node_list, name_list, descriptor):
if (name_list is None):
return
if (len(name_list) > len(node_list)):
raise RuntimeError(('number of %s names provided (%d) exceeded number of %ss (%d)' % (descr... |
class CustomBuildExtCommand(build_ext):
def run(self):
import numpy
self.include_dirs.append(numpy.get_include())
build_ext.run(self) |
class Message():
role: MessageRole
content: str
type: (MessageType | None) = None
def raw(self) -> MessageDict:
return {'role': self.role, 'content': self.content} |
def run_openpose(video_file, output_folder, staf_folder, vis=False):
pwd = os.getcwd()
os.chdir(staf_folder)
render = (1 if vis else 0)
display = (2 if vis else 0)
cmd = ['build/examples/openpose/openpose.bin', '--model_pose', 'BODY_21A', '--tracking', '1', '--render_pose', str(render), '--video', v... |
class Contiguous(Module):
def updateOutput(self, input):
if (not input.is_contiguous()):
self.output.resize_as_(input).copy_(input)
else:
self.output.set_(input)
return self.output
def updateGradInput(self, input, gradOutput):
if (not gradOutput.is_contigu... |
def asmatrix(*args, **kwargs):
with warnings.catch_warnings(record=True):
warnings.filterwarnings('ignore', '.*the matrix subclass is not the recommended way.*')
return np.asmatrix(*args, **kwargs) |
def set_beta(args, epoch):
if (args.warmup == 0):
beta = 1.0
else:
beta = ((1.0 * epoch) / args.warmup)
if (beta > 1.0):
beta = 1.0
return beta |
def get_inferable_quantizer_kwargs(node_qc: BaseNodeQuantizationConfig, quantization_target: QuantizationTarget) -> Dict[(str, Any)]:
if (quantization_target == QuantizationTarget.Weights):
if (not isinstance(node_qc, NodeWeightsQuantizationConfig)):
Logger.error(f'Non-compatible node quantizati... |
def node_multiple_outputs_model(input_shape):
inputs = Input(shape=input_shape)
y = tf.split(inputs, num_or_size_splits=2, axis=0)
x1 = Conv2D(2, 3)(y[0])
x2 = Conv2D(2, 3)(y[1])
outputs = keras.layers.Concatenate()([x1, x2])
return keras.Model(inputs=inputs, outputs=outputs) |
def get_variable_by_name(prefix, net_name, var_name, iter_num=0):
return np.load(os.path.join(current_path, 'logdata', '{}-{}-{}-{}.npy'.format(prefix, net_name, var_name.replace('/', '-'), iter_num))) |
def get_predictions_br(system_pairs, systems, metric):
random.seed(666)
preds = {}
for pair in system_pairs:
sys1 = systems[pair[0]][metric]
sys2 = systems[pair[1]][metric]
n = len(sys1)
points = [i for i in range(0, n)]
is_better = 0
N = 1000
for i in... |
def dist_init(port):
if (mp.get_start_method(allow_none=True) != 'spawn'):
mp.set_start_method('spawn')
proc_id = int(os.environ['SLURM_PROCID'])
ntasks = int(os.environ['SLURM_NTASKS'])
node_list = os.environ['SLURM_NODELIST']
num_gpus = torch.cuda.device_count()
torch.cuda.set_device((... |
class CombineAdapterFactory(LoggerAdapterFactory):
_adapter_factories: Sequence[LoggerAdapterFactory]
def __init__(self, adapter_factories: Sequence[LoggerAdapterFactory]):
self._adapter_factories = adapter_factories
def create(self, experiment_name: str) -> CombineAdapter:
return CombineAda... |
def filenum_to_shard_51(filenum):
if ((filenum >= 1) and (filenum <= 815)):
return 0
if ((filenum >= 1001) and (filenum <= 1136)):
return 0
if ((filenum >= 886) and (filenum <= 931)):
return 1
if ((filenum >= 1148) and (filenum <= 1151)):
return 1
if ((filenum >= 816)... |
class CyclicPermutationGroup(PermutationGroup_unique):
def __init__(self, n):
n = Integer(n)
if (n < 1):
raise ValueError(('n (=%s) must be >= 1' % n))
gens = tuple(range(1, (n + 1)))
PermutationGroup_generic.__init__(self, [gens], n)
def _repr_(self):
return ... |
_duration
_to_mask
def time_symmetrize(clip):
return concatenate_videoclips([clip, clip.fx(time_mirror)]) |
class TFAutoModelForSeq2SeqLM(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class RQ_DQ_reg(atomic_reg):
OP_NAME = 'RQ&DQ'
_fields_ = [('cmd_short', ctypes.c_uint64, 1), ('op_code', ctypes.c_uint64, 16), ('cmd_id_dep', ctypes.c_uint64, 24), ('tsk_typ', ctypes.c_uint64, 4), ('tsk_eu_typ', ctypes.c_uint64, 5), ('opt_rq', ctypes.c_uint64, 1), ('tsk_opd_num', ctypes.c_uint64, 2), ('pad_mod... |
def parse_xml(filename, lines):
new_lines = []
for (i, line) in enumerate(lines[7:]):
line = line.strip()
if (line.startswith('<S ID') or line.startswith('<ENDTIME>') or line.startswith('<END_TIME>')):
continue
if ((line == '</S>') or (line == '<HEADLINE>') or (line == '</HEA... |
class BCHUnderlyingGRSDecoder(Decoder):
def __init__(self, code, grs_decoder='KeyEquationSyndrome', **kwargs):
self._grs_code = code.bch_to_grs()
self._grs_decoder = self._grs_code.decoder(grs_decoder, **kwargs)
self._decoder_type = copy(self._grs_decoder.decoder_type())
super().__in... |
class Decoder(nn.Module):
def __init__(self, input_size, embedding_size, hidden_size, output_size, num_layers, p):
super(Decoder, self).__init__()
self.dropout = nn.Dropout(p)
self.hidden_size = hidden_size
self.num_layers = num_layers
self.embedding = nn.Embedding(input_size... |
def update_alpha_parameters(model, layers, p, pi, print_info=True):
standarlization = (lambda x: ((x - torch.mean(x)) / torch.std(x)))
alpha_grad_attn = torch.stack([torch.cat([getattr(model.module.visual_encoder.blocks, str(i)).attn.alpha.grad for i in range(layers)]), torch.stack([getattr(model.module.text_en... |
def smallest_poly(F, prec=53, norm_type='norm', emb=None):
def insert_item(pts, item, index):
N = len(pts)
if (N == 0):
return [item]
elif (N == 1):
if (item[index] > pts[0][index]):
pts.insert(0, item)
else:
pts.append(item... |
def makeSpiderHeader(im):
(nsam, nrow) = im.size
lenbyt = (nsam * 4)
labrec = int((1024 / lenbyt))
if ((1024 % lenbyt) != 0):
labrec += 1
labbyt = (labrec * lenbyt)
hdr = []
nvalues = int((labbyt / 4))
for i in range(nvalues):
hdr.append(0.0)
if (len(hdr) < 23):
... |
_utils.test(arch=[ti.cpu, ti.cuda])
def test_break_in_real_func():
_func
def bar() -> int:
a = 0
for i in range(10):
if (i == 5):
break
a += 1
return a
def foo() -> int:
return bar()
assert (foo() == 5) |
def GetCOCOCatNames():
ClassNames = {}
ClassNames[0] = 'person'
ClassNames[1] = 'bicycle'
ClassNames[2] = 'car'
ClassNames[3] = 'motorcycle'
ClassNames[4] = 'airplane'
ClassNames[5] = 'bus'
ClassNames[6] = 'train'
ClassNames[7] = 'truck'
ClassNames[8] = 'boat'
ClassNames[9] =... |
def setup(app: Sphinx) -> Dict[(str, Any)]:
app.add_autodocumenter(ModuleDocumenter)
app.add_autodocumenter(ClassDocumenter)
app.add_autodocumenter(ExceptionDocumenter)
app.add_autodocumenter(DataDocumenter)
app.add_autodocumenter(NewTypeDataDocumenter)
app.add_autodocumenter(FunctionDocumenter)... |
def load_all(stream, Loader=None):
if (Loader is None):
load_warning('load_all')
Loader = FullLoader
loader = Loader(stream)
try:
while loader.check_data():
(yield loader.get_data())
finally:
loader.dispose() |
def imread(fname, dtype=None, img_num=None, **kwargs):
if isinstance(fname, str):
with open(fname, 'rb') as f:
im = Image.open(f)
return pil_to_ndarray(im, dtype=dtype, img_num=img_num)
else:
im = Image.open(fname)
return pil_to_ndarray(im, dtype=dtype, img_num=im... |
def build_network(opt):
opt = deepcopy(opt)
network_type = opt.pop('type')
net = ARCH_REGISTRY.get(network_type)(**opt)
logger = get_root_logger()
logger.info(f'Network [{net.__class__.__name__}] is created.')
return net |
def load_data(name):
if (name == 'bsds300'):
return datasets.BSDS300()
elif (name == 'power'):
return datasets.POWER()
elif (name == 'gas'):
return datasets.GAS()
elif (name == 'hepmass'):
return datasets.HEPMASS()
elif (name == 'miniboone'):
return datasets.M... |
class RowLogger(Logger):
def __init__(self, filename, columns=None, append=False):
super(RowLogger, self).__init__(filename, columns=columns, append=append)
def initAppend(self, append):
if (append and os.path.exists(self.fname)):
with open(self.fname, 'r') as f:
line... |
class StartingBlock(Block):
def __init__(self, x=0, y=0, h=1, w=1, value=(- 0.1), startingPoint=None):
super(StartingBlock, self).__init__(x, y, h, w)
self.color = '#00FF00FF'
self.name = 'StartingBlock'
self.value = value
self.startingPoint = [(x + (w / 2.0)), (y + (h / 2.0)... |
class ClipCountAcc():
SIZE = 1
def from_reader(reader: _ResponseReader):
assert (reader.remaining() >= ClipCountAcc.SIZE)
rv = ClipCountAcc()
rv.value = reader.read_u8()
return rv
def __repr__(self):
return _pretty_print(self) |
def compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p):
d_cnt = 0
w_cnt = 0
w_cnt_h = 0
for uid in hyp_uid_to_tra:
ref = ref_uid_to_tra[uid].split()
if (g2p is not None):
hyp = g2p(hyp_uid_to_tra[uid])
hyp = [p for p in hyp if ((p != "'") and (p != ' '))]
... |
class CudaRemoteModuleTest(CommonRemoteModuleTest):
_if_lt_x_gpu(1)
_utils.dist_init
def test_valid_device(self):
if (self.rank != 0):
return
dst_rank = ((self.rank + 1) % self.world_size)
dst_worker_name = dist_utils.worker_name(dst_rank)
for remote_module in sel... |
class Timer():
def __init__(self, enable, cuda):
self._enable = enable
self._cuda = cuda
self._elapsed_ms = None
if self._cuda:
self._gpu_timer = pyrenderer.GpuTimer()
def elapsed_ms(self):
assert (self._elapsed_ms is not None), 'No timings recorded'
r... |
class DiagonalNoiseModel(NoiseModel):
def __init__(self, information_diag: T.Optional[T.Sequence[sf.Scalar]]=None, sqrt_information_diag: T.Optional[T.Sequence[sf.Scalar]]=None) -> None:
if (sqrt_information_diag is not None):
self.sqrt_information_matrix = sf.Matrix.diag(sqrt_information_diag)
... |
def get_points_from_angles(distance, elevation, azimuth, degrees=True):
if (isinstance(distance, float) or isinstance(distance, int)):
if degrees:
elevation = math.radians(elevation)
azimuth = math.radians(azimuth)
return (((distance * math.cos(elevation)) * math.sin(azimuth)... |
def set_seed(seed: Optional[int]) -> None:
if (seed is not None):
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed) |
_kl(Gumbel, Beta)
_kl(Gumbel, Exponential)
_kl(Gumbel, Gamma)
_kl(Gumbel, Pareto)
_kl(Gumbel, Uniform)
def _kl_gumbel_infinity(p, q):
return _infinite_like(p.loc) |
def main(args):
VERBOSE = False
parse_line_list = (lambda line, delimiter, T: [T(y) for y in [x.strip() for x in line.strip().split(delimiter)] if y])
if (len(args) < 2):
print('Error: no case or direction provided')
exit(1)
spOption = ''
wCalc = False
for arg in args:
if... |
def to_delta_state(line):
delta_state = {'inform': {}, 'request': {}}
try:
if ((line == 'None') or (line.strip() == '') or (line.strip() == ';')):
return delta_state
(inform, request) = [[y.strip() for y in x.strip().split(',')] for x in line.split(';')]
inform_pairs = {}
... |
def lm_rank(strs, probs):
if (lm is None):
return strs[0]
a = FLAGS.alpha
lmscores = [(lm.score(s) / (1 + len(s.split()))) for s in strs]
probs = [(p / (len(s) + 1)) for (s, p) in zip(strs, probs)]
rescores = [(((1 - a) * p) + (a * l)) for (l, p) in zip(lmscores, probs)]
rerank = [rs[0] ... |
def require_world_size(world_size):
if (int(os.environ['WORLD_SIZE']) < world_size):
return sandcastle_skip(('Test requires world size of %d' % world_size))
return (lambda func: func) |
class _GlobalPooling2D(Layer):
_global_pooling_support
def __init__(self, data_format=None, **kwargs):
super(_GlobalPooling2D, self).__init__(**kwargs)
self.data_format = conv_utils.normalize_data_format(data_format)
self.input_spec = InputSpec(ndim=4)
def compute_output_shape(self, ... |
def get_model_conditional(batch_size, max_seq_length, input_size, hidden_size, target_size, vocab_size, pretrain, tanhOrSoftmax, dropout):
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
inputs_cond = tf.placeholder(tf.int32, [batch_size, max_seq_length])
cont_train = True
if (pretrain =... |
.parametrize('categorical_as_dictionary', [False, True])
.parametrize('through', [through_arrow, through_parquet])
.parametrize('extensionarray', [False, True])
def test_dictionary_encoding(tmp_path, categorical_as_dictionary, through, extensionarray):
akarray = ak.contents.IndexedArray(ak.index.Index64(np.array([3... |
class XLMTokenizationTest(CommonTestCases.CommonTokenizerTester):
tokenizer_class = XLMTokenizer
def setUp(self):
super(XLMTokenizationTest, self).setUp()
vocab = ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'w</w>', 'r</w>', 't</w>', 'lo', 'low', 'er</w>', 'low</w>', 'lowest</w>', 'newer<... |
class StochasticFrameSkip(gym.Wrapper):
def __init__(self, env, n, stickprob, seed):
print(stickprob)
gym.Wrapper.__init__(self, env)
self.n = n
self.stickprob = stickprob
self.curac = None
self.rng = np.random.RandomState(seed)
self.supports_want_render = has... |
def train(sess, model, train_url, test_url, batch_size, vocab_size, analytical, alternate_epochs=1, lexicon=[], result_file='test.txt', B=1, warm_up_period=100):
(train_set, train_count) = utils.data_set(train_url)
(test_set, test_count) = utils.data_set(test_url)
train_size = len(train_set)
validation_... |
def chunk_pair_distance(chunk1: tuple, chunk2: tuple, overlap_distance: int=(- 1)):
((_, s1, e1), (_, s2, e2)) = (chunk1, chunk2)
if (e1 <= s2):
return (s2 - e1)
elif (e2 <= s1):
return (s1 - e2)
else:
return overlap_distance |
class GATT(nn.Module):
def __init__(self, in_features, out_features, hidden_features, n_layers, n_heads, activation=F.leaky_relu, dropout=0.0):
super(GATT, self).__init__()
self.in_features = in_features
self.hidden_features = hidden_features
self.out_features = out_features
... |
.parametrize('max_iter', range(1, 5))
def test_labeled_iter(max_iter):
st = SelfTrainingClassifier(KNeighborsClassifier(), max_iter=max_iter)
st.fit(X_train, y_train_missing_labels)
amount_iter_0 = len(st.labeled_iter_[(st.labeled_iter_ == 0)])
assert (amount_iter_0 == n_labeled_samples)
assert (np.... |
def removing_general():
all_ok_files = ['defense_1_ok.txt', 'defense_2_ok.txt', 'defense_3_ok.txt', 'defense_4_ok.txt', 'defense_5_ok.txt', 'eiffel_1_ok.txt', 'eiffel_2_ok.txt', 'eiffel_3_ok.txt', 'eiffel_4_ok.txt', 'eiffel_5_ok.txt', 'invalides_1_ok.txt', 'invalides_2_ok.txt', 'invalides_3_ok.txt', 'invalides_4_ok... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--prompt_dir', default=None, type=str, required=True, help='directory to prompt file (.txt)')
parser.add_argument('--eng', default=None, type=str, required=True, help='engine')
parser.add_argument('--num_test', default=(- 1), type=int, ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.