code stringlengths 101 5.91M |
|---|
_require_initialized
def get_worker_info(worker_name=None):
if worker_name:
return _get_current_rpc_agent().get_worker_info(worker_name)
else:
return _get_current_rpc_agent().get_worker_info() |
def _clean_up_temporary_files(dataset_dir):
for filename in [_TRAIN_DATA_FILENAME, _TRAIN_LABELS_FILENAME, _TEST_DATA_FILENAME, _TEST_LABELS_FILENAME]:
filepath = os.path.join(dataset_dir, filename)
tf.gfile.Remove(filepath) |
def get_padding_value(padding, kernel_size, **kwargs):
dynamic = False
if isinstance(padding, str):
padding = padding.lower()
if (padding == 'same'):
if is_static_pad(kernel_size, **kwargs):
padding = get_padding(kernel_size, **kwargs)
else:
... |
def partial_dtype_fmt():
ld = np.dtype('longdouble')
partial_ld_off = partial_ld_offset()
return dt_fmt().format(ld.itemsize, partial_ld_off, (partial_ld_off + ld.itemsize)) |
def test_categorical_column_with_numbers():
data = pd.DataFrame({'category_col': [1, 2, 1, 2, 1, 2, np.nan, 1, 1, np.nan, 2, 2, np.nan, 2, 1, 1, np.nan, 1, 2, 2], 'numerical_col': np.random.rand(20)})
metadata = SingleTableMetadata()
metadata.detect_from_dataframe(data)
synthesizer = GaussianCopulaSynth... |
class ResidualCNN(nn.Module):
def __init__(self, in_channels, out_channels, kernel, stride, dropout, n_feats):
super(ResidualCNN, self).__init__()
self.cnn1 = nn.Conv2d(in_channels, out_channels, kernel, stride, padding=(kernel // 2))
self.cnn2 = nn.Conv2d(out_channels, out_channels, kernel,... |
((not workspace.C.use_mkldnn), 'No MKLDNN support.')
class ExpandDimsSqueezeTest(hu.HypothesisTestCase):
(squeeze_dims=st.lists(st.integers(0, 3), min_size=1, max_size=3), inplace=st.booleans(), **mu.gcs)
def test_squeeze(self, squeeze_dims, inplace, gc, dc):
shape = [(1 if (dim in squeeze_dims) else np... |
class _DenseLayer(nn.Sequential):
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
super(_DenseLayer, self).__init__()
(self.add_module('norm1', nn.BatchNorm2d(num_input_features)),)
(self.add_module('relu1', nn.ReLU(inplace=True)),)
(self.add_module('conv1', ... |
def make_replay_loader(replay_dir, max_size, batch_size, num_workers, save_snapshot, nstep, discount):
max_size_per_worker = (max_size // max(1, num_workers))
iterable = ReplayBuffer(replay_dir, max_size_per_worker, num_workers, nstep, discount, fetch_every=1000, save_snapshot=save_snapshot)
loader = torch.... |
class TArtPointVisitor(object):
thisown = _swig_property((lambda x: x.this.own()), (lambda x, v: x.this.own(v)), doc='The membership flag')
__repr__ = _swig_repr
VnLowH = _swig_property(_snap.TArtPointVisitor_VnLowH_get, _snap.TArtPointVisitor_VnLowH_set)
ParentH = _swig_property(_snap.TArtPointVisitor_... |
class PcxImageFile(ImageFile.ImageFile):
format = 'PCX'
format_description = 'Paintbrush'
def _open(self):
s = self.fp.read(128)
if (not _accept(s)):
raise SyntaxError('not a PCX file')
bbox = (i16(s, 4), i16(s, 6), (i16(s, 8) + 1), (i16(s, 10) + 1))
if ((bbox[2] ... |
def to_floatTensor(x: (list, tuple, np.ndarray)):
if isinstance(x, torch.Tensor):
return x.float()
if isinstance(x, np.ndarray):
return torch.from_numpy(x).float()
else:
return torch.tensor(x, dtype=torch.float) |
class SequenceDataset():
def __init__(self, data, batch_size, number_batches, minimum_size=10):
self.current_batch = 0
self.number_batches = number_batches
self.items = []
for i_sequence in range(len(data[0])):
if (batch_size is None):
self.items.append([d... |
def has_valid_keypoint(obj):
if (max(obj['keypoints']) == 0):
return False
return True |
def get_single_dataset(data_dir, FaceDataset, data_name='', train=True, label=None, img_size=256, map_size=32, transform=None, debug_subset_size=None, UUID=(- 1)):
if train:
if (data_name in ['OULU']):
data_set = FaceDataset(data_name, os.path.join(data_dir, 'OULU-NPU/preposess'), split='train',... |
def test_box_center_distance():
p1 = np.array([1, 1, 3, 3])
p2 = np.array([2, 2, 4, 2])
assert (utils.box_center_distance(p1, p2) == 1) |
def add_block_f(inputs, outputs):
return nn.Sequential(nn.Conv2d(in_channels=inputs, out_channels=outputs, kernel_size=3, padding=1), nn.LeakyReLU(0.2), nn.BatchNorm2d(outputs), nn.Conv2d(in_channels=outputs, out_channels=outputs, kernel_size=3, padding=1), nn.LeakyReLU(0.2), nn.BatchNorm2d(outputs), nn.Conv2d(in_c... |
('mlm_seq_loader')
class MLMMaskedSequenceDatasetReader(DatasetReader):
def __init__(self, tokenizer: Tokenizer=None, token_indexers: Dict[(str, TokenIndexer)]=None, max_doc_length: int=(- 1), min_doc_length: int=(- 1), mlm_mask_whole_words: bool=True, mask_probability: float=0.1, mlm_mask_replace_probability: floa... |
def test_read_meshes():
from sfepy.discrete.fem import Mesh
conf_dir = op.dirname(__file__)
oks = []
for (ii, filename) in enumerate(filename_meshes):
tst.report(('%d. mesh: %s' % ((ii + 1), filename)))
try:
mesh = Mesh.from_file(filename, prefix_dir=conf_dir)
except ... |
class Upsample2DBlock(nn.Module):
def __init__(self, in_planes, out_planes, kernel_size, stride):
super(Upsample2DBlock, self).__init__()
assert (kernel_size == 2)
assert (stride == 2)
self.block = nn.Sequential(nn.ConvTranspose2d(in_planes, out_planes, kernel_size=kernel_size, strid... |
def convert(idx):
global fnames
fname = fnames[idx]
dataset = tf.data.TFRecordDataset(fname, compression_type='')
for (frame_id, data) in enumerate(dataset):
frame = dataset_pb2.Frame()
frame.ParseFromString(bytearray(data.numpy()))
decoded_frame = waymo_decoder.decode_frame(fram... |
class TRStr(object):
thisown = _swig_property((lambda x: x.this.own()), (lambda x, v: x.this.own(v)), doc='The membership flag')
__repr__ = _swig_repr
Bf = _swig_property(_snap.TRStr_Bf_get, _snap.TRStr_Bf_set)
Refs = _swig_property(_snap.TRStr_Refs_get, _snap.TRStr_Refs_set)
__swig_destroy__ = _sna... |
def test_return_none(capture):
n_inst = ConstructorStats.detail_reg_inst()
with capture:
p = m.Parent()
assert (capture == 'Allocating parent.')
with capture:
p.returnNullChildKeepAliveChild()
assert (ConstructorStats.detail_reg_inst() == (n_inst + 1))
assert (capture == '')
... |
def test_default_parameters() -> None:
mapie_cal = MapieCalibrator()
assert (mapie_cal.method == 'top_label')
assert (mapie_cal.calibrator is None)
assert (mapie_cal.cv == 'split') |
.parametrize('shape', [[], [1], [2], [1, 2, 3]])
def test_exact_thompson_sampler_sample_raises_for_invalid_at_shape(shape: ShapeLike) -> None:
with pytest.raises(TF_DEBUGGING_ERROR_TYPES):
ExactThompsonSampler().sample(QuadraticMeanAndRBFKernel(), 5, tf.zeros(shape)) |
_inherit(core.Dataset)
class Dataset(core.Dataset):
def __init__(self, data_home=None):
super().__init__(data_home, name='dcase_bioacoustic', clip_class=Clip, bibtex=BIBTEX, remotes=REMOTES, license_info=LICENSE_INFO)
_docs(load_audio)
def load_audio(self, *args, **kwargs):
return load_audio... |
class MetricsMeanSquaredError(Metrics):
def __init__(self, dtype=bb.DType.FP32):
core_metrics = bb.search_core_object('MetricsMeanSquaredError', [dtype]).create()
super(MetricsMeanSquaredError, self).__init__(core_metrics=core_metrics) |
def apply_to_all_elements(x, fn):
if (type(x) not in (list, tuple)):
return fn(x)
return [apply_to_all_elements(y, fn) for y in x] |
class MobileNetV3(MyNetwork):
def __init__(self, first_conv, blocks, final_expand_layer, feature_mix_layer, classifier):
super(MobileNetV3, self).__init__()
self.first_conv = first_conv
self.blocks = nn.ModuleList(blocks)
self.final_expand_layer = final_expand_layer
self.feat... |
def starts_stops_to_index(starts, stops):
toindex = []
for x in range(len(starts)):
if ((stops[x] - starts[x]) > 0):
for y in range((stops[x] - starts[x])):
toindex.append((starts[x] + y))
else:
toindex.append(starts[x])
return toindex |
class Partition7(nn.Module):
LAYER_SCOPES = ['T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[21]/ModuleList[layer]/T5LayerSelfAttention[0]/T5LayerNorm[layer_norm]', 'T5ForConditionalGeneration/T5Stack[encoder]/ModuleList[block]/T5Block[21]/ModuleList[layer]/T5LayerSelfAttention[0]/T5Attention... |
.parametrize('with_data', [pytest.param(True), pytest.param(False)])
.parametrize('language', [pytest.param('CPP'), pytest.param('Python')])
def test_map_with_tasklets(language: str, with_data: bool):
sdfg = _make_sdfg(language, with_data)
sdfg.compile()
sdfg.simplify()
num = sdfg.apply_transformations_... |
def save_video(save_dir, file_name, frames, episode_id=0):
filename = os.path.join(save_dir, (file_name + '_episode_{}'.format(episode_id)))
if (not os.path.exists(filename)):
os.makedirs(filename)
num_frames = frames.shape[0]
for i in range(num_frames):
img = Image.fromarray(np.flipud(f... |
class YahooAnswers(XiangZhangDataset):
dirname = 'yahoo_answers_csv'
columns = ['class_index', 'question_title', 'question_content', 'best_answer'] |
def register_Ns3LteUeNetDevice_methods(root_module, cls):
cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)
cls.add_constructor([])
cls.add_method('DoDispose', 'void', [], is_virtual=True)
cls.add_method('Send', 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const ... |
def test_broadcast_single_bool():
base = ak.Array([[{'x': 0.1, 'y': 0.2, 'z': 0.3}, {'x': 0.4, 'y': 0.5, 'z': 0.6}]])
base_new1 = ak.operations.with_field(base, True, 'always_true')
assert (to_list(base_new1.always_true) == [[True, True]])
base_new2 = ak.operations.with_field(base_new1, (base.x > 0.3), ... |
def overall_accuracy_calc(TP, POP):
try:
overall_accuracy = (sum(TP.values()) / POP)
return overall_accuracy
except Exception:
return 'None' |
class DiagPC(object):
def setUp(self, pc):
A = pc.getOperators()[0]
self.idiag = (1.0 / A.getDiagonal())
def apply(self, pc, x, y):
y.pointwiseMult(x, self.idiag) |
class TestAlignments(object):
def source_words(self):
return [['a', 'c', 'b', 'c'], ['1', '3', '2', '2', '2'], []]
def target_words(self):
return [['c', 'z', 'b', 'c'], ['1', 'c'], ['2', '4']]
def aligns(self, source_words, target_words):
return Alignments(source_words, target_words)... |
def simplify(save_dir, save_name, nets, total, sup_config):
dataloader_dict = {}
(hps, seeds) = (['12'], set())
for hp in hps:
sub_save_dir = (save_dir / 'raw-data-{:}'.format(hp))
ckps = sorted(list(sub_save_dir.glob('arch-*-seed-*.pth')))
seed2names = defaultdict(list)
for ... |
def pandas_data_to_tetrad(df: DataFrame, int_as_cont=False):
dtypes = ['float16', 'float32', 'float64']
if int_as_cont:
for i in range(3, 7):
dtypes.append(f'int{(2 ** i)}')
dtypes.append(f'uint{(2 ** i)}')
cols = df.columns
discrete_cols = [col for col in cols if (df[col... |
def init_pretrained_weights(model, key=''):
import os
import errno
import gdown
from collections import OrderedDict
import warnings
import logging
logger = logging.getLogger(__name__)
def _get_torch_home():
ENV_TORCH_HOME = 'TORCH_HOME'
ENV_XDG_CACHE_HOME = 'XDG_CACHE_HOM... |
def cleanup(ax):
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
ax.tick_params(axis='both', which='both', bottom='off', top='off', la... |
def register_Ns3SimpleOfdmWimaxPhy_methods(root_module, cls):
cls.add_constructor([param('ns3::SimpleOfdmWimaxPhy const &', 'arg0')])
cls.add_constructor([])
cls.add_constructor([param('char *', 'tracesPath')])
cls.add_method('ActivateLoss', 'void', [param('bool', 'loss')])
cls.add_method('AssignStr... |
(scope='function', autouse=True)
def scope_function():
nn.set_auto_forward(False)
nn.clear_parameters()
nn.graph_def.reset_default_graph()
ctx = nn.get_current_context()
(yield)
nn.set_default_context(ctx) |
_request
def s3_etag(url, proxies=None):
s3_resource = boto3.resource('s3', config=Config(proxies=proxies))
(bucket_name, s3_path) = split_s3_path(url)
s3_object = s3_resource.Object(bucket_name, s3_path)
return s3_object.e_tag |
def save_results(model, train_results, dev_results, test_results, results_fname):
results = [['n_classes', 'embedding_size', 'hidden_size', 'nlayers', 'dropout_p', 'train_loss', 'dev_loss', 'test_loss', 'train_acc', 'dev_acc', 'test_acc']]
results += [[model.n_classes, model.embedding_size, model.hidden_size, m... |
def test_is_failing(test_case_chromosome):
chromosome = test_case_chromosome
result = MagicMock(ExecutionResult)
result.has_test_exceptions.return_value = True
chromosome.set_last_execution_result(result)
assert chromosome.is_failing() |
def test_xml_dataset():
dataconfig = {'ann_file': 'data/VOCdevkit/VOC2007/ImageSets/Main/test.txt', 'img_prefix': 'data/VOCdevkit/VOC2007/', 'pipeline': [{'type': 'LoadImageFromFile'}]}
XMLDataset = DATASETS.get('XMLDataset')
class XMLDatasetSubClass(XMLDataset):
CLASSES = None
with pytest.raise... |
class GlobalFeatureImportance(ExplanationBase):
def __init__(self):
super().__init__()
self.explanations = {}
def add(self, feature_names, importance_scores, sort=False, **kwargs):
scores = list(zip(feature_names, importance_scores))
if sort:
scores = sorted(scores, k... |
def _has_route_to_root(criteria, key, all_keys, connected):
if (key in connected):
return True
if (key not in criteria):
return False
for p in criteria[key].iter_parent():
try:
pkey = all_keys[id(p)]
except KeyError:
continue
if (pkey in connec... |
def tensor2img(img):
img = img[0].cpu().float().numpy()
if (img.shape[0] == 1):
img = np.tile(img, (3, 1, 1))
img = (((np.transpose(img, (1, 2, 0)) + 1) / 2.0) * 255.0)
return img.astype(np.uint8) |
class ResNeXt(nn.Module):
def __init__(self, num_blocks, cardinality, bottleneck_width, num_classes=10, in_ch=3, in_dim=32, bn=True):
super(ResNeXt, self).__init__()
self.cardinality = cardinality
self.bottleneck_width = bottleneck_width
self.in_planes = 64
self.bn = bn
... |
class IntersphinxCache():
def __init__(self):
self.inventories = {}
self.real_fetch_inventory = sphinx.ext.intersphinx.fetch_inventory
sphinx.ext.intersphinx.fetch_inventory = self.fetch_inventory
def fetch_inventory(self, app, uri, inv):
t = (uri, inv)
try:
r... |
def known_nicknames():
nicknames = list((value for (key, value) in TRANSFORMER_NICKNAMES.items()))
nicknames.append('transformer')
nicknames = sorted(nicknames, key=(lambda x: (- len(x))))
return nicknames |
def test_is_invertible_module_wrapped():
X = torch.zeros(1, 10, 10, 10)
assert (not is_invertible_module(InvertibleModuleWrapper(torch.nn.Conv2d(10, 10, kernel_size=(1, 1))), test_input_shape=X.shape))
fn = InvertibleModuleWrapper(AdditiveCoupling(SubModule(), implementation_bwd=(- 1), implementation_fwd=(-... |
_task('denoising')
class DenoisingTask(FairseqTask):
def add_args(parser):
parser.add_argument('data', help='path to data directory')
parser.add_argument('--tokens-per-sample', default=512, type=int, help='max number of total tokens over all segments per sample for dataset')
parser.add_argum... |
.unit
.convert
def test_filter_on_extension_with_predicate():
test_files = ['file_one.fits', 'file_two.fits', 'file_three.exclude']
extensions = ['fits']
expected_list = test_files[:1]
predicate = (lambda f: (f == test_files[1]))
actual_list = convert.filter_on_extension(test_files, extensions, pred... |
def less_equal_backward(grad_inputs, inputs, input_shapes, outputs, output_shapes):
return ([None] * (len(grad_inputs) + len(inputs))) |
_utils.test(arch=[ti.cpu, ti.cuda, ti.vulkan], exclude=[vk_on_mac], debug=True)
def test_print_matrix_fstring():
x = ti.Matrix.field(2, 3, dtype=ti.f32, shape=())
y = ti.Vector.field(3, dtype=ti.f32, shape=3)
def func(k: ti.f32):
x[None][(0, 0)] = (- 1.0)
y[2] += 1.0
print(f'hello {x... |
class GraphSAINT(GraphSamplingBase):
def __init__(self, args, data, train_idx, processed_dir):
super(GraphSAINT, self).__init__(args, data, train_idx, processed_dir)
self.use_norm = args.use_norm
self.dropout = args.dropout
self.args = args
if (args.gnn_type == 'gnn'):
... |
def createLabelImage(annotation, encoding, outline=None):
size = (annotation.imgWidth, annotation.imgHeight)
if (encoding == 'ids'):
background = name2label['unlabeled'].id
elif (encoding == 'trainIds'):
background = name2label['unlabeled'].trainId
elif (encoding == 'color'):
bac... |
class EllipticEU(BuiltinFunction):
def __init__(self):
BuiltinFunction.__init__(self, 'elliptic_eu', nargs=2, conversions=dict(maxima='elliptic_eu'))
def _eval_(self, u, m):
pass
def _evalf_(self, u, m, parent=None, algorithm=None):
R = (parent or s_parent(u))
return _mpmath_... |
class CodeVisitor(ast.NodeVisitor):
def visit_BinOp(self, node):
if isinstance(node.op, ast.Add):
node.op = ast.Sub()
self.generic_visit(node)
def visit_Assign(self, node):
print(('Assign %s' % node.value))
self.generic_visit(node)
def visit_Name(self, node):
... |
class BertNer(BertForTokenClassification):
def forward(self, input_ids, token_type_ids=None, attention_mask=None, valid_ids=None, device=None):
sequence_output = self.bert(input_ids, token_type_ids, attention_mask, head_mask=None)[0]
(batch_size, max_len, feat_dim) = sequence_output.shape
va... |
class langchain_openai_llm():
def __init__(self, llm_name):
openai.api_key = OPENAI_API_KEY
self.prompt_temp = PromptTemplate(input_variables=['prompt'], template='{prompt}')
self.llm_name = llm_name
def run(self, prompt, temperature=0.9, stop=['\n'], max_tokens=128):
llm = OpenA... |
def AddParameterUpdate(model):
ITER = model.Iter('iter')
LR = model.LearningRate(ITER, 'LR', base_lr=(- 1e-08), policy='step', stepsize=10000, gamma=0.999)
ONE = model.param_init_net.ConstantFill([], 'ONE', shape=[1], value=1.0)
for param in model.params:
param_grad = model.param_to_grad[param]
... |
def _smallest_size_at_least(height, width, smallest_side):
smallest_side = tf.convert_to_tensor(smallest_side, dtype=tf.int32)
height = tf.to_float(height)
width = tf.to_float(width)
smallest_side = tf.to_float(smallest_side)
scale = tf.cond(tf.greater(height, width), (lambda : (smallest_side / widt... |
def assert_graphql(schema):
assert (len(list(schema.get_all_operations())) == 4)
def filter_operations(context):
return context.operation.definition.is_query
for operation in schema.get_all_operations():
assert (not operation.ok().definition.is_mutation) |
def get_training_config(config_path, model_name, dataset):
with open(config_path, 'r') as conf:
full_config = yaml.load(conf, Loader=yaml.FullLoader)
dataset_specific_config = full_config['global']
model_specific_config = full_config[dataset][model_name]
if (model_specific_config is not None):
... |
def build_transformer_decoder(cfg, in_channels, mask_classification=True):
name = cfg.MODEL.M2FP.TRANSFORMER_DECODER_NAME
return TRANSFORMER_DECODER_REGISTRY.get(name)(cfg, in_channels, mask_classification) |
def optimal_state_change(state_tensor, action_tensor, lens, delta, kappa, max_action_state_distance=500):
return _lookforthechange_ops.optimal_state_change(state_tensor.contiguous(), action_tensor.contiguous(), lens, delta, kappa, max_action_state_distance) |
def test_adaptive_padding():
for padding in ('same', 'corner'):
kernel_size = 16
stride = 16
dilation = 1
input = torch.rand(1, 1, 15, 17)
adap_pool = AdaptivePadding(kernel_size=kernel_size, stride=stride, dilation=dilation, padding=padding)
out = adap_pool(input)
... |
_module()
class ABIConvertor(AttnConvertor):
def str2tensor(self, strings):
assert utils.is_type_list(strings, str)
(tensors, padded_targets) = ([], [])
indexes = self.str2idx(strings)
for index in indexes:
tensor = torch.LongTensor((index[:(self.max_seq_len - 1)] + [self... |
def pytest_configure(config):
config.addinivalue_line('markers', 'slow: marks test as slow (deselect with \'-m "not slow"\')') |
def __compute_auc_roc(y, loss_mean, loss_max, loss_top6_mean, scores_top6_max_prob, scores_top6_min_logprob, scores_top6_max_entropy, plot_graph=False, plot_histogram=False):
__compute_auc_roc_for_metric(y=y, metric=loss_mean, metric_name_str='loss_mean', plot_graph=plot_graph, plot_histogram=plot_histogram)
__... |
class Finalize(Transition):
def __init__(self, *label):
self.label = tuple(label)
def update_state(self, state, model):
constituents = state.constituents
children = [constituents.value]
constituents = constituents.pop()
label = self.label
return (state.word_positi... |
class GlobalMaxPool(nn.AdaptiveMaxPool2d):
def __init__(self, output_size=1, *args, **kwargs):
super().__init__(output_size) |
def reset_nan_backward(grad_inputs, inputs, input_shapes, outputs, output_shapes, val=0):
dy = grad_inputs[0]
x0 = inputs[0]
raise NotImplementedError('reset_nan_backward is not implemented.') |
class TrainArgs(alpaca.TrainArgs):
lora: LoraConfig = LoraConfig()
merged_hf_save_path: Optional[str] = None
merged_hf_upload: Optional[str] = None |
def get_command(id_):
os.environ['DEBUG'] = os.environ.get('DEBUG', 'false')
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
commands_dict = {}
split_id = id_.split('$$$')
checkpoint_path = split_id[1]
id_ = split_id[0]
num_gpus = 1
fb_256_bart_args = [f'--max_source_length 256', f'--max_... |
.torch
def test_bert_validation_dataset_getitem(sequential_dataset):
batch = Bert4RecValidationDataset(sequential_dataset, sequential_dataset, sequential_dataset, 8)[2]
assert (batch.query_id.item() == 2)
assert all((batch.padding_mask == torch.tensor([0, 0, 0, 0, 0, 0, 1, 1], dtype=torch.bool)))
assert... |
def merge_models_nodes(inner_model_node: BaseNode, outer_graph: Graph, inner_graph: Graph) -> List[BaseNode]:
res_nodes = copy.copy(list(outer_graph.nodes))
res_nodes.extend(inner_graph.nodes)
for input_node in inner_graph.get_inputs():
res_nodes.remove(input_node)
res_nodes.remove(inner_model_n... |
def mis_resblock(x_init, z, channels, use_bias=True, sn=False, scope='mis_resblock'):
with tf.variable_scope(scope):
z = tf.reshape(z, shape=[(- 1), 1, 1, z.shape[(- 1)]])
z = tf.tile(z, multiples=[1, x_init.shape[1], x_init.shape[2], 1])
with tf.variable_scope('mis1'):
x = conv(... |
def write_wavs(model, inputs, output_dir, external_vocoder=None):
if (external_vocoder is None):
print('The provided model has the vocoder embedded in the graph.\nGenerating waveform directly')
t0 = perf_counter()
(wavs, wav_lengths) = model.run(None, inputs)
infer_secs = (perf_count... |
def get_strategy():
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimen... |
class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebra_multiplicative):
def __init__(self, Sym):
classical.SymmetricFunctionAlgebra_classical.__init__(self, Sym, 'elementary', 'e')
def _dual_basis_default(self):
return self.dual_basis(scalar=None, prefix='f', basis_nam... |
def build_save_graph(nlp, data_root, split, max_len):
scanrefer = json.load(open(os.path.join(data_root, 'ScanRefer', (('ScanRefer_filtered_' + split) + '.json'))))
if (os.path.exists(os.path.join(data_root, 'features', split, 'graph')) == False):
os.makedirs(os.path.join(data_root, 'features', split, '... |
class EmailReplyPlayer(RecipePlayer):
def __init__(self, state):
fields = state.fields
by = [element for element in state.dom_elements if ((element.text == fields['by']) and (element.ref in EMAIL_SENDER_REFS))]
by_action = A.MiniWoBElementClick(by[0])
reply_action = (EMAIL_REPLY_REF,... |
class FirstResBlockDiscriminator(nn.Module):
def __init__(self, in_ch, out_ch, stride=1):
super().__init__()
self.model = nn.Sequential(nn.Conv2d(in_ch, out_ch, 3, 1, padding=1), nn.ReLU(), nn.Conv2d(out_ch, out_ch, 3, 1, padding=1))
self.downsample = (nn.AvgPool2d(2, stride=stride, padding=... |
class InitialBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super(InitialBlock, self).__init__()
self.conv = nn.Conv2d(in_channels, (out_channels - in_channels), kernel_size=3, stride=2, padding=1, bias=False)
self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
... |
def instantiate_models(args, verbose=True):
p = Dict2Obj(args.model)
if (args.task == constants.CL):
if (p.name_model == constants.LENET5):
model = models_cl.__dict__[p.name_model](num_classes=args.num_classes)
elif (p.name_model == constants.SOTASSL):
model = models_cl._... |
class SharedMLP(nn.Sequential):
def __init__(self, args: List[int], *, bn: bool=False, activation=nn.ReLU(inplace=True), preact: bool=False, first: bool=False, name: str='', instance_norm: bool=False):
super(SharedMLP, self).__init__()
for i in range((len(args) - 1)):
self.add_module((na... |
_module
class ContrastiveHead(nn.Module):
def __init__(self, temperature=0.1):
super(ContrastiveHead, self).__init__()
self.criterion = nn.CrossEntropyLoss()
self.temperature = temperature
def forward(self, pos, neg):
N = pos.size(0)
logits = torch.cat((pos, neg), dim=1)
... |
def main():
all_commands = []
all_eval_commands = []
for (att, fixed) in itertools.product((0, 1, 2, 3), (['init'], ['data', 'model'])):
steps = (list(range(1100, 40000, 1000)) + [40000])
for step in steps:
infer_command = (((('python infer.py --config configs/spider-/nl2code-042... |
class NameAxisLayer(_ConcatInputLayer):
layer_class = 'name_axis'
def __init__(self, axis, description, **kwargs):
super(NameAxisLayer, self).__init__(**kwargs)
from returnn.tf.layers.base import LayerBase
batch_dim = LayerBase.get_recent_layer().get_batch_info().dim
for (i, dyn_... |
_test(run_synthesis=False)
def test_axpy_unroll_mixed():
(csdfg, sdfg) = _exec_hbmtransform((lambda : create_vadd_sdfg('axpy_mixed')), [('x', 'DDR', '0'), ('y', 'HBM', '0:2'), ('z', 'HBM', '0:2')])
validate_vadd_sdfg(csdfg, [2, 20])
return sdfg |
class LayerNorm1d(nn.LayerNorm):
def __init__(self, num_channels, **kwargs):
super().__init__(num_channels)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return F.layer_norm(x.permute(0, 2, 1), self.normalized_shape, self.weight, self.bias, self.eps).permute(0, 2, 1).contiguous() |
def main(argv=None):
set_up_environment(visible_devices=FLAGS.visible_devices)
(x_train, y_train, x_test, y_test, spec_df) = get_data(FLAGS.dataset)
if FLAGS.train_interaction_model:
train_interaction_model(x_train, y_train, x_test, y_test)
(model, random_weights) = load_interaction_model()
... |
class Evaluator():
def __init__(self, opt, projection_mode='orthogonal'):
self.opt = opt
self.load_size = self.opt.loadSize
self.to_tensor = transforms.Compose([transforms.Resize(self.load_size), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
cuda = (... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.