code stringlengths 101 5.91M |
|---|
_spec_function('cub200')
def get_cub200_spec(run_human_eval: bool=False) -> RunSpec:
scenario_spec = ScenarioSpec(class_name='helm.benchmark.scenarios.image_generation.cub200_scenario.CUB200Scenario', args={})
adapter_spec = get_image_generation_adapter_spec(num_outputs=1)
metric_specs: List[MetricSpec] = (... |
class GeneratorHubInterface(nn.Module):
def __init__(self, args, task, models):
super().__init__()
self.args = args
self.task = task
self.models = nn.ModuleList(models)
self.src_dict = task.source_dictionary
self.tgt_dict = task.target_dictionary
for model in ... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--noisy', action='store_true', help='Noisy actions')
parser.add_argument('--maze', type=str, default='u-maze', help='Maze type. small or default')
parser.add_argument('--num_samples', type=int, default=int(1000000.0), help='Num samples ... |
def register_Ns3OlsrHelper_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::OlsrHelper const &', 'arg0')])
cls.add_method('Copy', 'ns3::OlsrHelper *', [], is_const=True, is_virtual=True)
cls.add_method('ExcludeInterface', 'void', [param('ns3::Ptr< ns3::Node >', 'node')... |
def main():
train_dataset = torchvision.datasets.MNIST('./data', train=True, download=False)
epochs = 200
model = LatentModel(128).cuda()
model.train()
optim = t.optim.Adam(model.parameters(), lr=0.0001)
writer = SummaryWriter()
global_step = 0
for epoch in range(epochs):
dloader... |
def main(args):
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
(args.out_dir / 'checkpoints').mkdir(exist_ok=True)
(args.out_dir / 'samples').mkdir(exist_ok=True)
((args.out_dir / 'samples') / 'text').mkdir(exist_ok=True)
((args.out_dir / 'samples') / 'image').... |
def compress_init_box(input_box, tol=1e-09):
inputs = len(input_box)
dtype = type(input_box[0][0])
assert (dtype in [float, np.float64, np.float32]), f'input_box dtype should be float32/64, got {dtype}'
cur_bias = np.array(([0] * inputs), dtype=dtype)
cur_bm_transpose = []
new_input_box = []
... |
class TdbCmdBackend(cmd.Cmd):
def __init__(self, bmodel_file: str=None, final_mlir_fn: str=None, tensor_loc_file: str=None, input_data_fn: str=None, reference_data_fn: List[str]=None, extra_plugins: List[str]=[], extra_check: List[str]=[], completekey='tab', stdin=None, stdout=None, ddr_size=(2 ** 32)):
sup... |
class UpstreamExpert(nn.Module):
def __init__(self, ckpt: str=None, model_name: str=None, window_secs: float=1, hop_secs: float=0.05, model_config: str=None):
super().__init__()
self.model = serab.load_model(ckpt, model_name)
self.frame_duration = (window_secs * 1000)
self.hop_size =... |
_tokenizers
class CpmTokenizationTest(XLNetModelTest):
def is_pipeline_test_to_skip(self, pipeline_test_casse_name, config_class, model_architecture, tokenizer_name, processor_name):
return True
def test_pre_tokenization(self):
tokenizer = CpmTokenizer.from_pretrained('TsinghuaAI/CPM-Generate')
... |
class vanilla_transformer_block(nn.Module):
def __init__(self, dim, head, FFNdim) -> None:
super(vanilla_transformer_block, self).__init__()
self.mha = MultiheadAttention(embed_dim=dim, num_heads=head)
self.FFN = FeedForwardNetwork(dim, FFNdim)
self.ln1 = nn.LayerNorm(dim, eps=1e-05)... |
.parametrize('workers', (1, 2))
def test_explicit_headers(testdir, unique_hook, empty_open_api_3_schema, cli, openapi3_base_url, hypothesis_max_examples, workers, snapshot_cli):
header_name = 'X-Session-ID'
empty_open_api_3_schema['paths'] = {'/success': {'get': {'parameters': [{'name': name, 'in': location, 'r... |
class AstVector(Z3PPObject):
def __init__(self, v=None, ctx=None):
self.vector = None
if (v is None):
self.ctx = _get_ctx(ctx)
self.vector = Z3_mk_ast_vector(self.ctx.ref())
else:
self.vector = v
assert (ctx is not None)
self.ctx = ... |
class CSFI2(nn.Module):
def __init__(self, mid_channels):
super().__init__()
self.conv1to2 = _conv1x1_layer(mid_channels, mid_channels)
self.conv2to1 = _conv3x3_layer(mid_channels, mid_channels, stride=2)
self.conv_merge1 = _conv3x3_layer((mid_channels * 2), mid_channels)
sel... |
class VoxLingua(HearScene):
_cfg(**HearScene.setup.default_except(corpus=dict(CLS=field(hear_scene_kfolds, '\nThe corpus class. You can add the **kwargs right below this CLS key', str), dataset_root=field('???', 'The root path of the corpus', str), test_fold=field('???', 'The testing fold id. Options: [0, 1, 2, 3, ... |
class _PatchAnalysis(object):
def __init__(self, patchinfo: PatchInfo, points_in_patch: List[Point], line: LineModel):
self.patchinfo = patchinfo
self.points = points_in_patch
self.ransacline: LineModel = line
pass
def __str__(self):
display = ('Line=%s Points in line=%d ... |
class FoilGainExpandCriterion(SplitCriterion):
def __init__(self, min_branch_frac_option=0.01):
super().__init__()
self.min_branch_frac_option = min_branch_frac_option
self.best_idx = 0
self.class_idx = 0
def get_merit_of_split(self, pre_split_dist, post_split_dist):
if (... |
class DDPG():
def __init__(self, state_shape, action_shape, max_action=1, discount=0.99, tau=0.005, batch_size=256, device='cpu', seed=0, logger=None):
np.random.seed(seed)
torch.manual_seed(seed)
self.actor = DeterministicPolicy(state_shape=state_shape, action_shape=action_shape, hidden_uni... |
def est_rank(layer):
W = layer.weight.data
mode3 = tl.base.unfold(W, 0)
mode4 = tl.base.unfold(W, 1)
diag_0 = EVBMF(mode3)
diag_1 = EVBMF(mode4)
return int((np.ceil((max([diag_0.shape[0], diag_1.shape[0]]) / 16)) * 16)) |
def convert_conv2convsamepadding_model(module, process_group=None, channel_last=False):
mod = module
if isinstance(module, torch.nn.modules.conv._ConvNd):
if isinstance(module.bias, torch.Tensor):
bias = True
else:
bias = False
mod = Conv2dSamePadding(module.in_ch... |
class Sinc2_autograd(torch.autograd.Function):
def forward(ctx, theta):
ctx.save_for_backward(theta)
return sinc2(theta)
def backward(ctx, grad_output):
(theta,) = ctx.saved_tensors
grad_theta = None
if ctx.needs_input_grad[0]:
grad_theta = (grad_output * sinc... |
def dense_layer(inputs, output_units, bias=True, activation=None, batch_norm=None, dropout=None, scope='dense-layer', reuse=False):
with tf.variable_scope(scope, reuse=reuse):
W = tf.get_variable(name='weights', initializer=tf.contrib.layers.variance_scaling_initializer(), shape=[shape(inputs, (- 1)), outpu... |
class TestCorpora(unittest.TestCase):
def setUp(self):
directory = (os.path.dirname(os.path.realpath(__file__)) + '/resources/')
self.input_data = open((directory + 'input.conll'), 'r')
def test_conll_reader(self):
corpus = Corpus.from_file('test', self.input_data)
self.assertEqu... |
def direct_kark_sort(s):
alphabet = ([None] + sorted(set(s)))
k = len(alphabet)
n = len(s)
t = dict(((c, i) for (i, c) in enumerate(alphabet)))
SA = array('i', ([0] * (n + 3)))
kark_sort(array('i', ([t[c] for c in s] + ([0] * 3))), SA, n, k)
return SA[:n] |
def import_object(model_dir, model_path, axis_forward='-Z', axis_up='Y'):
for o in bpy.data.objects:
o.select_set(False)
name = osp.basename(model_dir)
path = osp.join(model_dir, model_path)
bpy.ops.import_scene.obj(filepath=path, axis_forward=axis_forward, axis_up=axis_up)
selected_objs = b... |
def loop_train(model, optimizer, train_noisy_speech, train_clean_speech):
with tf.GradientTape() as tape:
train_predict_speech = model(train_noisy_speech)
if (loss_function == 'SDR'):
train_loss = modified_SDR_loss(train_predict_speech, train_clean_speech)
elif (loss_function == ... |
def test_check_input2():
with pytest.raises(TypeError, match=('Please check you are using the right model object,' + ' or the right order of the attributes!')):
trainer = Trainer(dataHandler, None, losses, validation_metrics, save_to_path, params)
trainer.train() |
class GenDictWithBasering():
def __init__(self, parent, start):
P = self._P = parent
if isinstance(start, list):
self._D = start
return
self._D = [start]
while (hasattr(P, 'base_ring') and (P.base_ring() is not P)):
P = P.base_ring()
D ... |
class TestGetWindow():
def test_boxcar(self):
w = windows.get_window('boxcar', 12)
assert_array_equal(w, np.ones_like(w))
w = windows.get_window(('boxcar',), 16)
assert_array_equal(w, np.ones_like(w))
def test_cheb_odd(self):
with suppress_warnings() as sup:
s... |
_builder('laion2B_multi')
class Laion2BMultiBuilder(BaseDatasetBuilder):
train_dataset_cls = LaionDataset
DATASET_CONFIG_DICT = {'default': 'configs/datasets/laion/defaults_2B_multi.yaml'}
def _download_ann(self):
pass
def _download_vis(self):
pass
def build(self):
self.build... |
class PairedDataset():
def __init__(self, dataset1, dataset2):
self.dataset1 = dataset1
self.dataset2 = dataset2
def __len__(self):
return len(self.dataset1)
def __getitem__(self, k):
ret1 = self.dataset1[k]
ret1 = (ret1 if isinstance(ret1, tuple) else (ret1,))
... |
class FreqEncoder():
def __init__(self, **kwargs):
self.kwargs = kwargs
self.create_embedding_fn()
def create_embedding_fn(self):
embed_fns = []
d = self.kwargs['input_dims']
out_dim = 0
if self.kwargs['include_input']:
embed_fns.append((lambda x: x))
... |
(Output('topic-data', 'data'), [Input('date-dropdown', 'value')])
def get_topic_data(value):
with MongoClient(**MONGO_ARGS) as connection:
read_collection = connection[READ_DB][READ_COL]
data = read_collection.find({'_id': value})
data = list(data)[0]
return data |
class TestBool(object):
def test_exceptions(self):
a = np.ones(1, dtype=np.bool_)
assert_raises(TypeError, np.negative, a)
assert_raises(TypeError, np.positive, a)
assert_raises(TypeError, np.subtract, a, a)
def test_truth_table_logical(self):
input1 = [0, 0, 3, 2]
... |
def get_transforms(split, size):
normalize = tv.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
if (size == 448):
resize_dim = 512
crop_dim = 448
elif (size == 224):
resize_dim = 256
crop_dim = 224
elif (size == 384):
resize_dim = 438
... |
class FlopCountAnalysis(JitModelAnalysis):
def __init__(self, model: nn.Module, inputs: Union[(Tensor, Tuple[(Tensor, ...)])]) -> None:
super().__init__(model=model, inputs=inputs)
self.set_op_handle(**_DEFAULT_SUPPORTED_OPS)
__init__.__doc__ = JitModelAnalysis.__init__.__doc__ |
def get_installed_distributions(local_only=True, skip=stdlib_pkgs, include_editables=True, editables_only=False, user_only=False):
if local_only:
local_test = dist_is_local
else:
def local_test(d):
return True
if include_editables:
def editable_test(d):
return... |
def repr_lincomb(terms, is_latex=False, scalar_mult='*', strip_one=False, repr_monomial=None, latex_scalar_mult=None):
if is_latex:
if (latex_scalar_mult is not None):
scalar_mult = latex_scalar_mult
elif (scalar_mult == '*'):
scalar_mult = ' '
if (repr_monomial is None):... |
(scope='function')
def estimators():
return numba_interface.Estimators(j_estimator=np.array([0.0, 0.0], dtype=np.float64), nu_bar_estimator=np.array([0.0, 0.0], dtype=np.float64), j_blue_estimator=np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]], dtype=np.float64), Edotlu_estimator=np.array([[0.0, 0.0, 1.0], [0.0, 0.0, ... |
def main():
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
if ((len(sys.argv) == 2) and sys.argv[1].endswith('.json')):
(model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
(model_args, data_args,... |
class _SplitOffSimpleInequalities(_TransformHrepresentation):
def _transform_(self):
inequalities = self.inequalities
B = self.B
import logging
logger = logging.getLogger(__name__)
from itertools import takewhile
from .representation import repr_pretty
from sa... |
def let_data_to_variable(variable, data, ctx=None, data_name=None, variable_name=None):
try:
if (data.dtype <= np.float64):
variable.data.cast(data.dtype)[...] = data
else:
variable.d = data
except:
if (variable.shape != data.shape):
logger.critical('S... |
def emulate_int8_histogram(w, scale=None, zero_point=None):
if (scale is None):
obs = torch.quantization.observer.HistogramObserver()
_ = obs(w.float())
(scale, zero_point) = obs.calculate_qparams()
scale = scale.cuda().type_as(w)
zero_point = zero_point.cuda().type_as(w)
... |
class NormalizationData(object):
GROUP_INPUTS = 'inputs'
GROUP_OUTPUTS = 'outputs'
DATASET_MEAN = 'mean'
DATASET_MEAN_OF_SQUARES = 'meanOfSquares'
DATASET_VARIANCE = 'variance'
DATASET_TOTAL_FRAMES = 'totalNumberOfFrames'
DATASET_TIME_DIMENSION_INDEX = 0
DATASET_FEATURE_DIMENSION_INDEX =... |
class TransformerDecoderLayer(nn.Module):
def __init__(self, args, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False, drop_path_rate=0.0, use_adapter=False, adapter_dim=200):
super().__init__()
self.embed_dim = args.decoder_embed_dim
self.use_adapter = use_adapter
if (use... |
class NodeMetaType(enum.Enum):
OPTPLAN_NODE = 'optplan_node'
TRANSFORMATION = 'transformation' |
def resnet_adapt101(args, pretrained=True, **kwargs):
model = ResNet3X3(args, **kwargs)
if pretrained:
print(' pretrained ')
model.load_state_dict(torch.load('./pretrained/resnet_adapt101-imagenet.pth', map_location='cpu'))
return model |
_REGISTRY
class FSD50KDataModule(pl.LightningDataModule):
def __init__(self, channels_last: bool=True, random_crop: Optional[int]=None, data_dir: Optional[str]='.cache', num_workers: int=3, batch_size: int=64, normalize: bool=True, pin_memory: bool=False, root='../datasets', *args, **kwargs):
super().__init... |
def _random_distributive_lattice(n):
from sage.combinat.posets.hasse_diagram import HasseDiagram
from copy import copy
from sage.combinat.subset import Subsets
from sage.graphs.digraph_generators import digraphs
if (n < 4):
return digraphs.Path((n - 1))
H = HasseDiagram({0: []})
whil... |
class TCFCProcessor(DataProcessor):
def get_example_from_tensor_dict(self, tensor_dict):
return InputExample(tensor_dict['idx'].numpy(), tensor_dict['sentence1'].numpy().decode('utf-8'), tensor_dict['sentence2'].numpy().decode('utf-8'), str(tensor_dict['label'].numpy()))
def get_train_examples(self, dat... |
def create_train_examples(X, Y, yspace, num=(- 1), balanced=True):
X_inp = []
Y_inp = []
outp = []
for (x, y) in zip(X, Y):
neg_samples = yspace[:]
neg_samples.remove(y)
if (num == (- 1)):
pass
else:
neg_samples = [i for i in random.sample(neg_samp... |
def save_npz(file, matrix, compressed=True):
arrays_dict = {}
if (matrix.format in ('csc', 'csr', 'bsr')):
arrays_dict.update(indices=matrix.indices, indptr=matrix.indptr)
elif (matrix.format == 'dia'):
arrays_dict.update(offsets=matrix.offsets)
elif (matrix.format == 'coo'):
arr... |
def require_access_token(method):
def wrapper(self, *args, **kwargs):
if self.access_token:
return method(self, *args, **kwargs)
else:
raise exceptions.MissingZenodoAccessToken(self.token_name)
return wrapper |
class TFDebertaV2Model(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def test_unet_basic_conv_block():
with pytest.raises(AssertionError):
dcn = dict(type='DCN', deform_groups=1, fallback_on_stride=False)
BasicConvBlock(64, 64, dcn=dcn)
with pytest.raises(AssertionError):
plugins = [dict(cfg=dict(type='ContextBlock', ratio=(1.0 / 16)), position='after_con... |
def bind_forward_vars(vars, ssspG, sssp_configs, binding):
for edge in zip(sssp_configs, sssp_configs[1:]):
if (ssspG.edges[edge]['cfg'] is None):
continue
for (var, layout) in ssspG.edges[edge]['cfg'].items():
if (var == 'SB2'):
continue
binding =... |
class _ReflectionPadNd(Module):
__constants__ = ['padding']
def forward(self, input: Tensor) -> Tensor:
return F.pad(input, self.padding, 'reflect')
def extra_repr(self) -> str:
return '{}'.format(self.padding) |
def training_loop(run_dir='.', training_set_kwargs={}, data_loader_kwargs={}, G_kwargs={}, D_kwargs={}, G_opt_kwargs={}, D_opt_kwargs={}, augment_kwargs=None, loss_kwargs={}, metrics=[], random_seed=0, world_size=1, rank=0, gpu=0, batch_gpu=4, batch_size=4, ema_kimg=10, ema_rampup=None, G_reg_interval=4, D_reg_interval... |
_test(assert_ii_1=False)
def test_fusion_with_transient_fpga():
A = np.random.rand(2, 20)
expected = ((A * A) * 2)
sdfg = fusion_with_transient.to_sdfg()
sdfg.simplify()
assert (sdfg.apply_transformations_repeated(MapFusion) >= 2)
assert (sdfg.apply_transformations_repeated(FPGATransformSDFG) ==... |
def P9():
A = Matrix(GF(2), [[1, 0, 0, 0, 1, 0, 0, 1, 1], [0, 1, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0, 1], [0, 0, 0, 1, 0, 0, 1, 1, 0]])
M = BinaryMatroid(A, 'abcdefghi')
M.rename(('P9: ' + repr(M)))
return M |
class HaydnOp20Dataset(RemoteFolderDataset):
_info = DatasetInfo(_NAME, _DESCRIPTION, _HOMEPAGE)
_citation = _CITATION
_sources = {'haydn': {'filename': 'haydnop20v1.3_annotated.zip', 'url': ' 'archive': True, 'size': 130954, 'md5': '1c65c8da312e1c9dda681d0496bf527f', 'sha256': '96986cccebfd37a36cc97a2fc0eb... |
def sample_gaussian(mean, std):
return (mean + std.mul(gaussian_noise(std.size(0), std.size(1)).to(std))) |
def train_controller(xloader, network, criterion, optimizer, prev_baseline, epoch_str, print_freq, logger, normalizer):
(data_time, batch_time) = (AverageMeter(), AverageMeter())
(GradnormMeter, LossMeter, ValAccMeter, EntropyMeter, BaselineMeter, RewardMeter, xend) = (AverageMeter(), AverageMeter(), AverageMet... |
class Video(object):
def __init__(self, name, root, video_dir, init_rect, img_names, gt_rect, attr, load_img=False):
self.name = name
self.video_dir = video_dir
self.init_rect = init_rect
self.gt_traj = gt_rect
self.attr = attr
self.pred_trajs = {}
self.img_na... |
def formatted_holistic_pose(width: int, height: int, additional_face_points: int=0):
dimensions = PoseHeaderDimensions(width=width, height=height, depth=1000)
header = PoseHeader(version=0.1, dimensions=dimensions, components=holistic_components('XYZC', additional_face_points))
body = NumPyPoseBody(fps=0, d... |
class DenseNet161(nn.Module):
def __init__(self):
super(DenseNet161, self).__init__()
self.net = timm.create_model('densenet161', pretrained=True)
self.net.global_pool = nn.Identity()
self.net.classifier = nn.Identity()
self._handles = []
self._features = {}
s... |
def isogeny_degrees_cm(E, verbose=False):
if (not E.has_cm()):
raise ValueError('possible_isogeny_degrees_cm(E) requires E to be an elliptic curve with CM')
d = E.cm_discriminant()
if verbose:
print(('CM case, discriminant = %s' % d))
from sage.libs.pari.all import pari
from sage.set... |
class Observation(object):
def __init__(self, left_shoulder_rgb: np.ndarray, left_shoulder_depth: np.ndarray, left_shoulder_mask: np.ndarray, left_shoulder_point_cloud: np.ndarray, right_shoulder_rgb: np.ndarray, right_shoulder_depth: np.ndarray, right_shoulder_mask: np.ndarray, right_shoulder_point_cloud: np.ndarr... |
_BODY.register('pfpn')
class PFPN(nn.Module):
def __init__(self, cfg, dim_in, spatial_in):
super().__init__()
panoptic_dim = cfg.FPN.PANOPTIC.CONV_DIM
norm = cfg.FPN.PANOPTIC.NORM
self.spatial_in = spatial_in
self.use_fpn = cfg.FPN.PANOPTIC.USE_FPN
if self.use_fpn:
... |
class Literal(Token):
def __init__(self, matchString):
super(Literal, self).__init__()
self.match = matchString
self.matchLen = len(matchString)
try:
self.firstMatchChar = matchString[0]
except IndexError:
warnings.warn('null string passed to Literal; ... |
def construction_3_4(k, n, m, r, s, explain_construction=False):
if explain_construction:
return (((('Construction 3.4 with n={},m={},r={},s={} from:\n' + ' Julian R. Abel, Nicholas Cavenagh\n') + ' Concerning eight mutually orthogonal latin squares,\n') + ' Vol. 15, n.3, pp. 255-261,\n') + ' Journal of... |
def display_results(df, sorted_cols=['data', 'feature', 'type', 'l-val_top1'], max_num=1):
cols = [c for c in df.columns if (c not in [])]
df = df[cols]
if (max_num is not None):
df = filter_df(df, sorted_cols[3:], max_num)
return df.sort_values(sorted_cols).reset_index(drop=True) |
def _construct_lookups():
for (name, info) in _concrete_typeinfo.items():
obj = info.type
nbytes[obj] = (info.bits // 8)
_alignment[obj] = info.alignment
if (len(info) > 5):
_maxvals[obj] = info.max
_minvals[obj] = info.min
else:
_maxvals[o... |
def ppo_benchmarks():
iterate_experiments(ppo_garage_pytorch, MuJoCo1M_ENV_SET)
iterate_experiments(ppo_garage_tf, MuJoCo1M_ENV_SET) |
def save(nntagger, args):
outdir = args.save
modelname = (outdir + '.model')
nntagger.model.save(modelname)
import pickle
print(nntagger.task2tag2idx)
myparams = {'num_words': len(nntagger.w2i), 'num_chars': len(nntagger.c2i), 'tasks_ids': nntagger.tasks_ids, 'w2i': nntagger.w2i, 'c2i': nntagger... |
class PrimarySimilarityClassType(Element, metaclass=InheritComparisonClasscallMetaclass):
def __classcall_private__(cls, deg, par):
par = Partition(par)
P = PrimarySimilarityClassTypes((par.size() * deg))
return P(deg, par)
def __init__(self, parent, deg, par):
self._deg = deg
... |
def test_runningmeanstd():
for (x1, x2, x3) in [(np.random.randn(3), np.random.randn(4), np.random.randn(5)), (np.random.randn(3, 2), np.random.randn(4, 2), np.random.randn(5, 2))]:
rms = RunningMeanStd(epsilon=0.0, shape=x1.shape[1:])
x = np.concatenate([x1, x2, x3], axis=0)
ms1 = [x.mean(a... |
class StringToLongTensor():
def __init__(self, tokenizer, max_len=None):
self.tokenizer = tokenizer
self.max_len = max_len
def __call__(self, x: str):
tok_idxs = self.tokenizer.encode(x)
tok_idxs = torch.LongTensor(tok_idxs)
num_tokens = tok_idxs.size(0)
if ((self... |
class SafeRepresenter(BaseRepresenter):
def ignore_aliases(self, data):
if (data is None):
return True
if (isinstance(data, tuple) and (data == ())):
return True
if isinstance(data, (str, bytes, bool, int, float)):
return True
def represent_none(self, ... |
class Attention(torch.nn.Module):
def __init__(self, dim, key_dim, num_heads, attn_ratio=4, activation=None, norm_cfg=dict(type='BN', requires_grad=True)):
super().__init__()
self.num_heads = num_heads
self.scale = (key_dim ** (- 0.5))
self.key_dim = key_dim
self.nh_kd = nh_k... |
def _seg_79():
return [(195097, 'M', u''), (195098, 'M', u''), (195099, 'M', u''), (195100, 'M', u''), (195101, 'M', u''), (195102, 'X'), (917760, 'I'), (918000, 'X')] |
def get_trans_list():
trans_list = ['Invert', 'Sharpness', 'AutoContrast', 'Posterize', 'ShearX', 'TranslateX', 'TranslateY', 'ShearY', 'Cutout', 'Rotate', 'Equalize', 'Contrast', 'Color', 'Solarize', 'Brightness']
return trans_list |
def lowercase_and_remove_accent(text):
text = ' '.join(text)
text = text.lower()
text = unicodedata.normalize('NFD', text)
output = []
for char in text:
cat = unicodedata.category(char)
if (cat == 'Mn'):
continue
output.append(char)
return ''.join(output).lowe... |
def DatasetManager(dataset: str, root: str, split: str='public', train_samples_per_class: Optional[Union[(float, int)]]=None, val_samples_per_class: Optional[Union[(float, int)]]=None, test_samples_per_class: Optional[Union[(float, int)]]=None, train_size: Optional[int]=None, val_size: Optional[int]=None, test_size: Op... |
def test_timm_backbone():
with pytest.raises(TypeError):
model = TIMMBackbone()
model.init_weights(pretrained=0)
model = TIMMBackbone(model_name='resnet18', features_only=True, pretrained=False, output_stride=32, norm_layer='BN2d')
model = TIMMBackbone(model_name='resnet18', features_only=Tr... |
def query_weibull(category_name, weibull_model, distance_type='eucos'):
category_weibull = []
category_weibull += [weibull_model[category_name]['mean_vec']]
category_weibull += [weibull_model[category_name][('distances_%s' % distance_type)]]
category_weibull += [weibull_model[category_name]['weibull_mod... |
class ShapenetCaptionEvalDataset(ShapenetCaptionDataset):
def __getitem__(self, index):
data = super().__getitem__(index)
if (data != None):
del data['text_input']
return data |
def load_forbidden_symbols(dataset):
if (dataset == 'guacamol'):
forbidden_symbols = {'Ag', 'Al', 'Am', 'Ar', 'At', 'Au', 'D', 'E', 'Fe', 'G', 'K', 'L', 'M', 'Ra', 'Re', 'Rf', 'Rg', 'Rh', 'Ru', 'T', 'U', 'V', 'W', 'Xe', 'Y', 'Zr', 'a', 'd', 'f', 'g', 'h', 'k', 'm', 'si', 't', 'te', 'u', 'v', 'y'}
else:
... |
def parse_args():
parser = argparse.ArgumentParser(description='Matting demo')
parser.add_argument('config', help='test config file path')
parser.add_argument('checkpoint', help='checkpoint file')
parser.add_argument('img_path', help='path to input image file')
parser.add_argument('trimap_path', hel... |
def test_get_query_results_from_db_wrong_query(metric_evaluator):
dict_pred = {'db_id': [f'{DB_NAME}_1', f'{DB_NAME}_2', f'{DB_NAME}_3'], 'query': ([f'SELECT * FROM wrong_table_name'] * 3), 'prediction': ([f'SELECT * FROM {TABLE_NAME}'] * 3)}
pred_df = pd.DataFrame(dict_pred)
with pytest.raises(sqlite3.Oper... |
def News20_dataset(args=None):
dataset = Dataset(name='20News_sports', path='preprocess/20News/vec_20news_sports.p', min_length=6, max_length=500, args=args)
set_balanced_pos_weight(dataset)
return dataset |
def basis_seq(V, vecs):
for z in vecs:
z.set_immutable()
return Sequence(vecs, universe=V, check=False, immutable=True, cr=True) |
def test_polygamma():
assert (polygamma(0, (- 9)) == zoo)
assert (polygamma(0, (- 9)) == zoo)
assert (polygamma(0, (- 1)) == zoo)
assert (polygamma(0, 0) == zoo)
assert (polygamma(0, 1) == (- EulerGamma))
assert (polygamma(0, 7) == (Rational(49, 20) - EulerGamma))
assert (polygamma(1, 1) == ... |
class CountFeaturizer(Featurizer):
def __init__(self, is_ontology_expansion: bool=False, excluded_codes: Iterable[str]=[], excluded_event_filter: Optional[Callable[([Event], bool)]]=None, time_bins: Optional[List[datetime.timedelta]]=None, numeric_value_decile: bool=False, string_value_combination: bool=False, char... |
_module()
class FeatureRelayHead(nn.Module):
def __init__(self, in_channels=1024, out_conv_channels=256, roi_feat_size=7, scale_factor=2):
super(FeatureRelayHead, self).__init__()
assert isinstance(roi_feat_size, int)
self.in_channels = in_channels
self.out_conv_channels = out_conv_c... |
def register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module, cls):
cls.add_constructor([])
cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentRequest const &', 'arg0')])
cls.add_instance_attribute('reestablishmentCause', 'ns3::LteRrcSap::ReestablishmentCause', is_co... |
def get_reward(purchased_product, goal, price, options, **kwargs):
r_type_dict = get_type_reward(purchased_product, goal)
r_price = ((price <= goal['price_upper']) if (goal['price_upper'] > 0) else None)
(r_att, num_attr_matches) = get_attribute_reward(purchased_product, goal)
(r_option, num_option_matc... |
.parametrize('ST,quad', all_trial_bases_and_quads)
def test_eval(ST, quad):
kwargs = {}
if (not (ST.family() == 'fourier')):
kwargs['quad'] = quad
ST = ST(N, **kwargs)
(points, weights) = ST.points_and_weights(N)
fk = shenfun.Function(ST)
fk[:4] = 1
ST.eval(np.array([0.0]), fk)
f... |
def recursive_split(segment, bpe_codes, vocab, separator, final=False):
try:
if final:
(left, right) = bpe_codes[(segment + '</w>')]
right = right[:(- 4)]
else:
(left, right) = bpe_codes[segment]
except:
(yield segment)
return
if ((left + s... |
class Circuit():
def __init__(self, size: int) -> None:
self.size: int = size
self.gates: List[GATE_INFO_TYPE] = []
self.measured_qubits: List[int] = []
self._cache: Optional[np.ndarray] = None
def get_unitary_matrix(self) -> np.ndarray:
if (self._cache is None):
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.