code stringlengths 101 5.91M |
|---|
class LabelEncoder(object):
def __init__(self, dictionary):
self.dictionary = dictionary
def __call__(self, label):
return self.dictionary.encode_line(label, append_eos=False, add_if_not_exist=False) |
def test_lang_setting(corenlp_client):
ann = corenlp_client.annotate(GERMAN_DOC, properties_key='german', output_format='text')
assert (ann.strip() == GERMAN_DOC_GOLD.strip()) |
def _worker_populate_task(G, env, policy, scope=None):
G = _get_scoped_G(G, scope)
G.env = pickle.loads(env)
G.policy = pickle.loads(policy) |
class TestFrenchPipeline():
(scope='class')
def pipeline(self):
pipeline = stanza.Pipeline(processors='tokenize,mwt,pos,lemma,depparse', dir=TEST_MODELS_DIR, lang='fr')
return pipeline
def test_single(self, pipeline):
doc = pipeline(FR_MWT_SENTENCE)
compare_ignoring_whitespac... |
def _get_neighbors(adj, nodes):
sp_nodes = _sp_row_vec_from_idx_list(list(nodes), adj.shape[1])
sp_neighbors = sp_nodes.dot(adj)
neighbors = set(ssp.find(sp_neighbors)[1])
return neighbors |
class Kernel(Module, metaclass=abc.ABCMeta):
def __init__(self):
super().__init__()
def K(self, x: Tensor, y: Tensor) -> Tensor:
pass
def trK(self, x: Tensor) -> Tensor:
pass
def diagK(self, x: Tensor) -> Tensor:
pass
def forward(self, x: Tensor, y: Tensor) -> Tensor:... |
class TestLMContextWindow(unittest.TestCase):
def test_eval_dataloader(self):
dictionary = test_utils.dummy_dictionary(10)
assert (len(dictionary) == 14)
assert (dictionary.pad() == 1)
dataset = test_utils.TestDataset([torch.tensor([4, 5, 6, 7], dtype=torch.long), torch.tensor([8, 9,... |
def _ensure_html_header(response):
content_type = response.headers.get('Content-Type', '')
if (not content_type.lower().startswith('text/html')):
raise _NotHTML(content_type, response.request.method) |
def build_model(cfg, gpu_id=None):
if torch.cuda.is_available():
assert (cfg.NUM_GPUS <= torch.cuda.device_count()), 'Cannot use more GPU devices than available'
else:
assert (cfg.NUM_GPUS == 0), 'Cuda is not available. Please set `NUM_GPUS: 0 for running on CPUs.'
name = cfg.MODEL.MODEL_NAM... |
def test_invalid_given_usage(testdir):
testdir.make_test('\nlazy_schema = schemathesis.from_pytest_fixture("simple_schema")\n\_schema.parametrize()\_schema.given()\ndef test(case):\n pass\n ')
result = testdir.runpytest()
result.assert_outcomes(failed=1)
result.stdout.re_match_lines(['.+given ... |
class OptionParser(object):
def __init__(self, ctx=None):
self.ctx = ctx
self.allow_interspersed_args = True
self.ignore_unknown_options = False
if (ctx is not None):
self.allow_interspersed_args = ctx.allow_interspersed_args
self.ignore_unknown_options = ctx.... |
def extract_video(vid_filename, output_folder):
cmd = ['ffmpeg', '-i', vid_filename, f'{output_folder}/%06d.jpg', '-threads', '16']
print(' '.join(cmd))
try:
subprocess.call(cmd)
except OSError:
print('OSError') |
def build_feature_connector(t_channel, s_channel):
C = [nn.Conv2d(s_channel, t_channel, kernel_size=1, stride=1, padding=0, bias=False), nn.BatchNorm2d(t_channel)]
for m in C:
if isinstance(m, nn.Conv2d):
n = ((m.kernel_size[0] * m.kernel_size[1]) * m.out_channels)
m.weight.data.... |
def __dblquad(f, lims, args=(), epsrel=1e-11):
def int_x(y, *args):
return quad(f, lims[0], lims[1], args=(y, *args), epsrel=(0.01 * epsrel))[0]
return quad(int_x, lims[2], lims[3], args=args, epsrel=epsrel)[0] |
def _read_input(filename_queue):
class DataRecord(object):
pass
reader = tf.WholeFileReader()
(key, value) = reader.read(filename_queue)
record = DataRecord()
decoded_image = tf.image.decode_jpeg(value, channels=NUM_OF_CHANNELS)
decoded_image_4d = tf.expand_dims(decoded_image, 0)
res... |
def _run_on_dask(jobs, verbose):
try:
import dask
except ImportError as ie:
ie.msg += '\n\nIt seems like `dask` is not installed.\nPlease install `dask` and `distributed` using:\n\n pip install dask distributed'
raise
scorer = dask.delayed(_run_job)
persisted = dask.persist(*[... |
def get_default_config(dataset, algorithm='ERM', data_fraction=1.0):
config = Namespace(dataset=dataset, algorithm=algorithm, model_kwargs={}, optimizer_kwargs={}, loader_kwargs={}, dataset_kwargs={}, scheduler_kwargs={}, train_transform=None, eval_transform=None, no_group_logging=True, distinct_groups=True, frac=d... |
class Metric(ABC):
_logger: Optional[logging.Logger] = None
_scala_udf_name: Optional[str] = None
def __init__(self, use_scala_udf: bool=False) -> None:
self._use_scala_udf = use_scala_udf
def logger(self) -> logging.Logger:
if (self._logger is None):
self._logger = logging.g... |
def failed_files_in_labels(labels_replaced, failed_files):
for (key, values) in labels_replaced.items():
val_new = values
for value in values:
if (value in failed_files):
print('Attention we couldnt read in the relevant file {}, therefore we now remove it from the labels'... |
def conll2004_demo():
return JsonIO(text_key='tokens', chunk_key='entities', chunk_type_key='type', chunk_start_key='start', chunk_end_key='end', relation_key='relations', relation_type_key='type', relation_head_key='head', relation_tail_key='tail', verbose=False).read('data/conll2004/demo.conll04_train.json') |
def ComputeRHS(rhs, ur_hat, solver, work, K, K2, K_over_K2, P_hat, T, Tp, VM, VMp, ur_dealias, mask, **context):
rhs = solver.conv(rhs, ur_hat, work, T, Tp, VM, VMp, K, ur_dealias)
if (mask is not None):
rhs.mask_nyquist(mask)
rhs = solver.add_pressure_diffusion(rhs, ur_hat, P_hat, K_over_K2, K, K2,... |
def create_pool_all_agree():
return ([create_base_classifier(return_value=np.zeros(1), return_prob=np.array([[0.61, 0.39]]))] * 100) |
class Schema():
db_id = attr.ib()
tables = attr.ib()
columns = attr.ib()
foreign_key_graph = attr.ib()
orig = attr.ib() |
class PoseSegmentsDataset(Dataset):
def __init__(self, data: List[PoseSegmentsDatum], hand_normalization=False, optical_flow=False, only_optical_flow=False, classes='bio'):
self.data = data
self.cached_data: List[Any] = ([None] * len(data))
self.hand_normalization = hand_normalization
... |
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
import pybind11
include_dirs = [pybind11.get_include(True), pybind11.get_include(False)]
config = Configuration('_pocketfft', parent_package, top_path)
ext = config.add_extension('pypocketfft', s... |
def load_tf_mixed7a(weights, layer):
if (len(weights) != 28):
raise ValueError(f'Number of weight arrays ({len(weights)}) not equal to 28')
load_tf_basicConv2d(weights[:4], layer.branch0[0])
load_tf_basicConv2d(weights[4:8], layer.branch0[1])
load_tf_basicConv2d(weights[8:12], layer.branch1[0])
... |
def remote_exec(bash_script, remote_machine, stdout=None, stderr=None, env={}, python_venv=None, port=22):
full_cmd = ' '.join(map((lambda k: ('export %s=%s;' % (k[0], k[1]))), env.items()))
if (python_venv is not None):
full_cmd += (' source %s/bin/activate; ' % python_venv)
full_cmd += bash_script... |
class TestOneHotEncoding():
def test__validate_inputs(self):
with pytest.raises(AggregateConstraintsError) as error:
OneHotEncoding._validate_inputs(not_column_names=None, something_else=None)
err_msg = 'Missing required values {(.*)} in a OneHotEncoding constraint.\\n\\nInvalid values {... |
class EMA():
def __init__(self, weighting=0.9):
self.weighting = weighting
self.val = None
def update(self, val):
if (self.val is None):
self.val = val
else:
self.val = ((self.weighting * val) + ((1 - self.weighting) * self.val))
def value(self):
... |
def get_note_density(mid):
duration = mid.get_end_time()
n_notes = sum([1 for instrument in mid.instruments for note in instrument.notes])
density = (n_notes / duration)
return density |
def _calculate_record_field_size_b(data_schema: Dict[(str, SizeData)], field_name: str) -> int:
schema = data_schema[field_name]
element_size_b = np.dtype(schema.dtype).itemsize
record_field_size_b = (reduce(mul, schema.shape) * element_size_b)
return record_field_size_b |
def test_clipgroups():
data_home_dir = 'tests/resources/sound_datasets'
for dataset_name in DATASETS:
module = importlib.import_module('soundata.datasets.{}'.format(dataset_name))
dataset = module.Dataset(os.path.join(TEST_DATA_HOME, dataset_name))
if (dataset_name in CUSTOM_TEST_MCLIPS)... |
def save_model(model, optimizer, save_variable_list, args):
argparse_dict = vars(args)
with open(os.path.join(args.save_path, 'config.json'), 'w') as fjson:
json.dump(argparse_dict, fjson)
torch.save({**save_variable_list, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.sta... |
class Encoder(nn.Module):
def __init__(self, input_size, embedding_size, hidden_size, num_layers, p):
super(Encoder, self).__init__()
self.dropout = nn.Dropout(p)
self.hidden_size = hidden_size
self.num_layers = num_layers
self.embedding = nn.Embedding(input_size, embedding_s... |
class DeiTFeatureExtractor(metaclass=DummyObject):
_backends = ['vision']
def __init__(self, *args, **kwargs):
requires_backends(self, ['vision']) |
class MocBackbone(object):
def __init__(self, configer):
self.configer = configer
def __call__(self):
arch = self.configer.sub_arch
from lib.models.backbones.hrnet.moc_config import MODEL_CONFIGS
if (arch in ['moc_small', 'moc_base', 'moct_small']):
arch_net = HighRes... |
class ScaledSetBBreakoutWorld(RandomScaledBreakoutWorld):
warnings.warn('This env. parameter was dropped and should no longer be used.', DeprecationWarning)
scale_range_start = 0.95
scale_range_end = 1.0 |
def apply_taggers(documents, taggers, ngrams=6, stopwords=[]):
markup = defaultdict((lambda : defaultdict(list)))
for doc in documents:
for name in taggers:
tags = taggers[name].tag(doc, ngrams=ngrams, stopwords=stopwords)
for layer in tags:
markup[doc.name][layer... |
class So3Block(nn.Module):
def __init__(self, b_in, b_out, f_in, f_out):
super(So3Block, self).__init__()
self.grid_so3 = so3_near_identity_grid(n_alpha=(2 * b_in), n_beta=2, n_gamma=2)
self.cnn = SO3Convolution(nfeature_in=f_in, nfeature_out=f_out, b_in=b_in, b_out=b_out, grid=self.grid_so3... |
def predict(args, model, data, device, tokenizer, executor):
model.eval()
(count, correct) = (0, 0)
with torch.no_grad():
all_outputs = []
for batch in tqdm(data, total=len(data)):
source_ids = batch[0].to(device)
outputs = model.generate(input_ids=source_ids, max_len... |
def display_hypothesis_output(hypothesis_output: list[str]) -> None:
if hypothesis_output:
display_section_name('HYPOTHESIS OUTPUT')
output = '\n'.join(hypothesis_output)
click.secho(output, fg='red') |
class BigBirdForSequenceClassification(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
def get_default(arg, default, msg_if_none=None):
if (arg is None):
out = default
else:
out = arg
if ((out is None) and (msg_if_none is not None)):
raise ValueError(msg_if_none)
return out |
class Encoder(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding=None, complex=False, padding_mode='zeros'):
super().__init__()
if (padding is None):
padding = [((i - 1) // 2) for i in kernel_size]
if complex:
conv = complex_nn.Comp... |
class AttachmentMetric(Metric):
def __init__(self, eps=1e-12):
super().__init__()
self.eps = eps
self.n = 0.0
self.n_ucm = 0.0
self.n_lcm = 0.0
self.total = 0.0
self.correct_arcs = 0.0
self.correct_rels = 0.0
def __repr__(self):
s = f'UCM: ... |
def load_image(path):
image = tf.io.read_file(path)
image = tf.image.decode_jpeg(image)
image = tf.image.resize(image, (224, 224))
image = tf.cast(image, tf.uint8)
return image |
def quote_args(args):
args = list(args)
for i in range(len(args)):
a = args[i]
if ((' ' in a) and (a[0] not in '"\'')):
args[i] = ('"%s"' % a)
return args |
.parametrize('observation_shape', [(8,), (3, 84, 84)])
.parametrize('action_size', [2])
.parametrize('length', [100])
.parametrize('size', [10])
.parametrize('terminated', [True, False])
.parametrize('n_frames', [1, 4])
def test_frame_stack_trajectory_slicer(observation_shape: Sequence[int], action_size: int, length: i... |
def extract_instances_for_current_subtask(task_instances, sub_task):
return task_instances[sub_task] |
def inputInt():
while True:
try:
user_input = int(input('Enter a number: '))
except ValueError:
print('Invalid input')
continue
print('The number is: ', user_input)
return user_input
break
return user_input |
def normal_kl(mean1, logvar1, mean2, logvar2):
tensor = None
for obj in (mean1, logvar1, mean2, logvar2):
if isinstance(obj, th.Tensor):
tensor = obj
break
assert (tensor is not None), 'at least one argument must be a Tensor'
(logvar1, logvar2) = [(x if isinstance(x, th.T... |
class FractionSpecializationMorphism(Morphism):
def __init__(self, domain, D):
if (not is_FractionField(domain)):
raise TypeError('domain must be a fraction field')
self._specialization = SpecializationMorphism(domain.base(), D)
self._repr_type_str = 'Fraction Specialization'
... |
def outer_sqrt_with_intermediate(Y: dace.float32[(3, 3)]):
intermediate = dace.define_local([3, 3], dace.float32)
W = dace.define_local([3, 3], dace.float32)
intermediate[:] = dace.elementwise((lambda x: sqrt(x)), Y)
W[:] = middle_sqrt_no_sum(intermediate)
Z = np.sum(W)
return Z |
class TransferNet(nn.Module):
def __init__(self, args, dim_word, dim_hidden, vocab):
super().__init__()
self.args = args
self.vocab = vocab
self.kg = KnowledgeGraph(args, vocab)
num_words = len(vocab['word2id'])
num_entities = len(vocab['entity2id'])
num_relat... |
class KLConcrete(nn.Module):
def __init__(self, K, M, kl_type='categorical', logits_p='train', tau_p=1.0):
super().__init__()
l = torch.ones(M, K)
if (logits_p == 'uniform'):
self.logits_p = move_to_device(l, cuda_device)
elif (logits_p == 'train'):
self.logit... |
def ctcdc(xs, y, k=3, base=2, warning=True):
xis = [centropydc(column(xs, i), y, k, base, warning) for i in range(0, len(xs[0]))]
return (np.sum(xis) - centropydc(xs, y, k, base, warning)) |
class TestClipReward():
def test_clip_reward(self):
env = DummyRewardBoxEnv(random=True)
env_wrap = ClipReward(env)
env.reset()
env_wrap.reset()
(_, reward, _, _) = env.step(0)
(_, reward_wrap, _, _) = env_wrap.step(0)
assert (reward == 10)
assert (rew... |
def test_build_optimizer_constructor():
optimizer_cfg = dict(type='SGD', lr=base_lr, weight_decay=base_wd, momentum=momentum)
optim_constructor_cfg = dict(type='DefaultOptimizerConstructor', optimizer_cfg=optimizer_cfg)
optim_constructor = build_optimizer_constructor(optim_constructor_cfg)
assert (type(... |
def convert_percentiles(idx):
pdf = [(300, 2.1), (350, 4.2), (400, 5.4), (450, 6.5), (500, 7.9), (550, 9.6), (600, 12.0), (650, 13.8), (700, 17.0), (750, 15.8), (800, 5.7), (850, 0)]
def convert_one(x):
partial = 0
for ((v, s), (v2, _)) in zip(pdf, pdf[1:]):
if ((partial + s) >= x):
... |
def configure_logger(level: (int | str)=logging.INFO) -> None:
if isinstance(level, str):
level = logging.getLevelName(level)
format_string = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
logging.basicConfig(format=format_string, level=level)
for handler in logging.getLogger('pytorch_li... |
def get_dataloader(args):
if (args.dataset == 'gaussian'):
dataset = GaussianDataNumpy(mu_pos=(np.ones(args.dimension) * 0), mu_neg=(np.ones(args.dimension) * args.negative_gaussian_mean), cov_pos=np.identity(10), cov_neg=np.identity(10), n_pos_tr=args.training_samples, n_neg_tr=args.training_samples, n_pos... |
def format_trace_inputs(declaration):
gather_tensor_options = 'TensorOptions().dtype(dtype).layout(layout).device(device).pinned_memory(pin_memory)'
def dispatch_trace_input(arg_spec):
(name, value, simple_type, nullable) = arg_spec
if ((simple_type == 'TensorList') and nullable):
re... |
_test(run_synthesis=False)
def test_axpy_unroll_3():
(csdfg, sdfg) = _exec_hbmtransform((lambda : create_vadd_sdfg('axpy_unroll_3')), [('x', 'HBM', '3:6'), ('y', 'HBM', '0:3'), ('z', 'HBM', '6:9')])
validate_vadd_sdfg(csdfg, [3, 20])
return sdfg |
def dep_bigram(corpus, dep, lemma=True, lower=True, pron=False, dep_upos=None, head_upos=None, dep_text=None, head_text=None):
(bi_freq, dep_freq, head_freq, range_freq) = ({}, {}, {}, {})
match_sentences = []
def dicter(item, d):
if (item not in d):
d[item] = 1
else:
... |
def main(argv):
parser = argparse.ArgumentParser(description='')
parser.add_argument('-i', '--glsl-path', help='', default='.')
parser.add_argument('-c', '--glslc-path', required=True, help='')
parser.add_argument('-t', '--tmp-dir-path', required=True, help='/tmp')
parser.add_argument('-o', '--outpu... |
class SemanticMatcher():
def __init__(self, reverse_properties, relation_dr, relations, upper_types, types):
self.reverse_properties = reverse_properties
self.relation_dr = relation_dr
self.relations = relations
self.upper_types = upper_types
self.types = types
def same_l... |
class SegDataParameter(_message.Message):
__metaclass__ = _reflection.GeneratedProtocolMessageType
DESCRIPTOR = _SEGDATAPARAMETER |
def create_h5(path):
import h5py
path = get_absolute_path(path)
make_parent_dir(path)
return h5py.File(path, 'w') |
class UnidirectionalRNNEncoder(Encoder):
def __init__(self, params, mode, name='forward_rnn_encoder'):
super(UnidirectionalRNNEncoder, self).__init__(params, mode, name)
self.params['rnn_cell'] = _toggle_dropout(self.params['rnn_cell'], mode)
def default_params():
return {'rnn_cell': _de... |
def preprocessor(output_directory, filepath, stats, hip_clang_launch, is_pytorch_extension, clean_ctx):
fin_path = os.path.join(output_directory, filepath)
with open(fin_path, 'r', encoding='utf-8') as fin:
output_source = fin.read()
fout_path = os.path.join(output_directory, get_hip_file_path(filep... |
class TestSampling(unittest.TestCase):
def test_sampling(self):
n_trials = 5
train = load_dataset('gnad10')['train']
for n_examples_per_label in [2, 8, 16]:
texts_per_trial = []
for i in range(n_trials):
try:
train_sample = sample(t... |
class Discriminator(nn.Module):
def __init__(self, conv_dim=64, repeat_num=6):
super(Discriminator, self).__init__()
self._name = 'global_d'
layers = []
layers.append(nn.Conv2d(3, conv_dim, kernel_size=4, stride=2, padding=1))
layers.append(nn.LeakyReLU(0.01, inplace=True))
... |
class CleanObjectAction(BaseAction):
valid_actions = {'PutObject', 'PickupObject', 'ToggleObjectOn', 'ToggleObjectOff'}
def get_reward(self, state, prev_state, expert_plan, goal_idx):
if (state.metadata['lastAction'] not in self.valid_actions):
(reward, done) = (self.rewards['invalid_action'... |
_REGISTRY.register()
class ResNet(nn.Module):
def __init__(self, cfg):
super(ResNet, self).__init__()
self.num_pathways = 1
self._construct_network(cfg)
def _compute_dim_in(self, idx, trans_func, width_per_group):
if (trans_func == 'basic_transform'):
factor = (1 if (... |
def build_mphf(ksize, records_iter_fn):
all_kmers = set()
sum_kmers = 0
multicounts = set()
records_iter = records_iter_fn()
for (n, record) in enumerate(records_iter):
if (((n % 50000) == 0) and n):
print('... contig', n, end='\r')
kmers = hash_sequence(record.sequence, ... |
class SkipQuantModel(torch.nn.Module):
def __init__(self):
super().__init__()
self.sub = InnerModule()
self.fc = torch.nn.Linear(5, 5).to(dtype=torch.float)
def forward(self, x):
return self.fc(self.sub(x))
def fuse_modules(self):
self.sub.fuse_modules() |
class AtrousPyramid3D(nn.Module):
def __init__(self, in_channels, pyramid_channels, dilation_rates, out_channels=None, include_1x1_conv=True):
super().__init__()
pyramid_channels = ([pyramid_channels] * len(dilation_rates))
atrous_convs = [nn.Conv3d(in_channels, channels, 3, padding=rate, di... |
def ring_env(render='drgb'):
name = 'ring'
network_name = RingNetwork
env_name = WaveAttenuationPOEnv
net_params = NetParams(additional_params=ADDITIONAL_NET_PARAMS)
initial_config = InitialConfig(spacing='uniform', shuffle=False)
vehicles = VehicleParams()
vehicles.add('human', acceleration... |
class PixelDiscriminator(BaseNetwork):
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d, active_fn='nn.ReLU'):
super(PixelDiscriminator, self).__init__()
if (type(norm_layer) == functools.partial):
use_bias = (norm_layer.func == nn.InstanceNorm2d)
else:
... |
def _initialize(module, cfg, wholemodule=False):
func = build_from_cfg(cfg, INITIALIZERS)
func.wholemodule = wholemodule
func(module) |
(func_name='attn_add_fun', noinline=True)
def _attn_add_fun(v, keys, query):
return math_ops.reduce_sum((v * math_ops.tanh((keys + query))), [2]) |
def metrics_for_verification(prediction, gold):
def extract_label(o):
verification_label = 'REFUTES'
if (('is "supports"' in o.lower()) or ('no fact-checking is needed for this claim' in o.lower()) or ('the fact-checking result is not applicable to this response' in o.lower())):
verifica... |
def random_sample(batch_size, input_shape, device):
return torch.randn(batch_size, *input_shape, dtype=torch.float).to(device)
a = np.random.rand(batch_size, *input_shape)
b = a.astype(np.float32)
import pdb
pdb.set_trace()
c = torch.tensor(b)
d = c.to(device)
return d |
def get_default_config_path():
directory = os.path.dirname(os.path.abspath(__file__))
configs_dir = os.path.join(directory, '..', 'configs')
fb_defaults = os.path.join(configs_dir, 'fb_defaults.yaml')
if PathManager.exists(fb_defaults):
return fb_defaults
else:
return os.path.join(co... |
def _internal_eval(model, global_step, sess, iterator, iterator_feed_dict, summary_writer, label):
sess.run(iterator.initializer, feed_dict=iterator_feed_dict)
ppl = model_helper.compute_perplexity(model, sess, label)
utils.add_summary(summary_writer, global_step, ('%s_ppl' % label), ppl)
return ppl |
class RobertaConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=Fa... |
class LipsDataset(dataset.Dataset):
def __init__(self, root, align_root, flag=1, mode='train', transform=None, seq_len=75):
assert (mode in ['train', 'valid'])
self._root = os.path.expanduser(root)
self._align_root = align_root
self._flag = flag
self._transform = transform
... |
class YelpReviewFull(XiangZhangDataset):
dirname = 'yelp_review_full_csv'
columns = ['rating', 'review'] |
def nested_symbol_dynamic(A: dace.float64[N]):
for i in range(5):
nested(A[0:i], A[0:i], i) |
def test_determine_files_to_download_raies_file_not_found(tmp_path):
file_to_download = files_resources.FilesResource(url=MOCK_URL, download_path=pathlib.Path('foo', 'bar.zip'), file_name='bar.txt', data_dir=str(tmp_path))
with pytest.raises(FileNotFoundError):
download_utils.determine_files_to_download... |
class ConvBlock(nn.Module):
def __init__(self, ni, no, ks, stride=1, pad=1, use_act=True):
super(ConvBlock, self).__init__()
self.use_act = use_act
self.conv = nn.Conv2d(ni, no, ks, stride=stride, padding=pad)
self.bn = nn.BatchNorm2d(no)
self.act = nn.LeakyReLU(0.2, inplace=... |
_end_docstrings(INIT_TOKENIZER_DOCSTRING)
class PreTrainedTokenizerBase(SpecialTokensMixin):
vocab_files_names: Dict[(str, str)] = {}
pretrained_vocab_files_map: Dict[(str, Dict[(str, str)])] = {}
pretrained_init_configuration: Dict[(str, Dict[(str, Any)])] = {}
max_model_input_sizes: Dict[(str, Optiona... |
def train(args, model, device, train_loader, optimizer, epoch):
model.train()
output = None
for (batch_idx, (data, target)) in enumerate(train_loader):
(data, target) = (data.to(device), target.to(device))
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, t... |
def create_ngram_index(light_scenarios: List[LightScenario], n_values: List[int], tokenizer: LightTokenizer, stats_key_counts: Dict[(DataOverlapStatsKey, int)]) -> NgramIndex:
ngram_index: NgramIndex = {n: {} for n in n_values}
for scenario in light_scenarios:
hlog(f'Building ngram indexes for {scenario... |
def flat_transform_bmes_label(start_labels, end_labels, span_labels, ner_cate, threshold=0.5):
bmes_labels = (len(start_labels) * ['O'])
start_labels = [idx for (idx, tmp) in enumerate(start_labels) if (tmp != 0)]
end_labels = [idx for (idx, tmp) in enumerate(end_labels) if (tmp != 0)]
for start_item in... |
def gausspulse(t, fc=1000, bw=0.5, bwr=(- 6), tpr=(- 60), retquad=False, retenv=False):
if (fc < 0):
raise ValueError(('Center frequency (fc=%.2f) must be >=0.' % fc))
if (bw <= 0):
raise ValueError(('Fractional bandwidth (bw=%.2f) must be > 0.' % bw))
if (bwr >= 0):
raise ValueError... |
class KNN(Function):
def forward(ctx, k: int, xyz: torch.Tensor, center_xyz: torch.Tensor=None, transposed: bool=False) -> torch.Tensor:
assert ((k > 0) & (k < 100)), 'k should be in range(0, 100)'
if (center_xyz is None):
center_xyz = xyz
if transposed:
xyz = xyz.tra... |
class Trainer(object):
def __init__(self, optimizer, max_epochs, hooks):
self.loss = None
self.optimizer = optimizer
self.max_epochs = max_epochs
self.hooks = hooks
def __call__(self, batcher, placeholders, loss, acc_thresh, pretrain, embedd, sep=False, model=None, session=None):... |
def test_UnionArray_RecordArray_NumpyArray():
v1 = json.loads('{"class":"UnionArray8_64","tags":"i8","index":"i64","contents":[{"class":"RecordArray","contents":{"nest":{"class":"NumpyArray","inner_shape":[],"itemsize":8,"format":"l","primitive":"int64","parameters":{},"form_key":null}},"parameters":{},"form_key":n... |
def reduce_process(output_queue, output):
interval_start = default_timer()
period = 100000
ordering_buffer = {}
next_ordinal = 0
while True:
if (next_ordinal in ordering_buffer):
output.write(ordering_buffer.pop(next_ordinal))
next_ordinal += 1
if ((next_o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.