code stringlengths 101 5.91M |
|---|
def dequantize_model(model):
model.float()
params = model.state_dict()
for (n, p) in params.items():
if ('quantization' not in n):
qp = QTensor(tensor=p, scale=params[(n + '.quantization.scale')][0], zero_point=params[(n + '.quantization.zero_point')][0])
p.copy_(dequantize_t... |
class ConvReLU2d(nnqat.Conv2d, nni._FusedModule):
_FLOAT_MODULE = nni.ConvReLU2d
_FLOAT_CONV_MODULE = nn.Conv2d
_FLOAT_BN_MODULE = None
_FLOAT_RELU_MODULE = nn.ReLU
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', ... |
def compute_maxIoU_overlap_alignment_wrapper(opts, rel_lo=0, rel_hi=1, batch_size=8, data_loader_kwargs=None, max_items=None, **stats_kwargs):
dataset = dnnlib.util.construct_class_by_name(**opts.dataset_kwargs)
if (data_loader_kwargs is None):
data_loader_kwargs = dict(pin_memory=True, num_workers=3, p... |
class Argument(object):
def __init__(self, dest, nargs=1, obj=None):
self.dest = dest
self.nargs = nargs
self.obj = obj
def process(self, value, state):
if (self.nargs > 1):
holes = sum((1 for x in value if (x is None)))
if (holes == len(value)):
... |
def test_gemm():
A = np.random.rand(M, K).astype(np.float32)
B = np.random.rand(K, N).astype(np.float32)
C = np.random.rand(M, N).astype(np.float32)
origC = np.zeros([M, N], dtype=np.float32)
origC[:] = C
gemm(A, B, C, 1.0, 1.0)
realC = ((1.0 * (A B)) + (1.0 * origC))
diff = (np.linalg.... |
class ResFieldNetBase(ResNetBase):
def network_initialization(self, in_channels, out_channels, D):
field_ch = 32
field_ch2 = 64
self.field_network = nn.Sequential(ME.MinkowskiSinusoidal(in_channels, field_ch), ME.MinkowskiBatchNorm(field_ch), ME.MinkowskiReLU(inplace=True), ME.MinkowskiLinea... |
def get_sentence_map(segments, sentence_end):
current = 0
sent_map = []
sent_end_idx = 0
assert (len(sentence_end) == sum([len(s) for s in segments]))
for segment in segments:
for i in range(len(segment)):
sent_map.append(current)
current += int(sentence_end[sent_end_... |
class Dataset(torch.utils.data.Dataset):
def __init__(self, x1: np.ndarray, x2: np.ndarray, y: np.ndarray, device):
self.x1 = x1
self.x2 = x2
self.y = y
self.device = device
def __len__(self):
return len(self.y)
def __getitem__(self, index):
with torch.no_grad... |
def get_divergence(T, K, U_hat, W_hat, **context):
div_u = Array(T)
U_hat = cross2(U_hat, K, W_hat)
div_u = T.backward((1j * (((K[0] * U_hat[0]) + (K[1] * U_hat[1])) + (K[2] * U_hat[2]))), div_u)
return div_u |
class Estimator(nn.Module):
def __init__(self, n_output, cnn_input=128):
n_input = cnn_input
n_units = n_output
super().__init__()
self.layer0 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=4, stride=2, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU())
self.layer1 = nn.Seq... |
def forward_param_layer(input, param):
ndim = input.get_shape().ndims
param = tf.convert_to_tensor(param)
num_units = int(param.get_shape()[0])
reshaped_param = tf.reshape(param, (((1,) * (ndim - 1)) + (num_units,)))
tile_arg = tf.concat([tf.shape(input)[:(ndim - 1)], [1]], 0)
tiled = tf.tile(re... |
class GPT():
def __init__(self, engine='davinci', temperature=0.5, max_tokens=100, input_prefix='input: ', input_suffix='\n', output_prefix='output: ', output_suffix='\n\n', append_output_prefix_to_query=False):
self.examples = {}
self.engine = engine
self.temperature = temperature
s... |
def consult_tree(root, dic):
nodes = traverse(root)
for n in nodes:
n.label = dic[n.label]
return nodes[0] |
def numpy_azimint_naive(data, radius, npt):
rmax = radius.max()
res = np.zeros(npt, dtype=np.float64)
for i in range(npt):
r1 = ((rmax * i) / npt)
r2 = ((rmax * (i + 1)) / npt)
mask_r12 = np.logical_and((r1 <= radius), (radius < r2))
values_r12 = data[mask_r12]
res[i]... |
def get_log_info(log: SparkDataFrame, user_col='user_idx', item_col='item_idx') -> str:
cnt = log.count()
user_cnt = log.select(user_col).distinct().count()
item_cnt = log.select(item_col).distinct().count()
return ', '.join([f'total lines: {cnt}', f'total users: {user_cnt}', f'total items: {item_cnt}']... |
class TestGetTableSchema(TestCase):
def test_get_table_schema(self):
conn = testing.get_singleton_db_connection()
if (conn.driver == 'mysql'):
schema = get_table_schema(conn, 'iris.train')
expect = [('sepal_length', 'FLOAT'), ('sepal_width', 'FLOAT'), ('petal_length', 'FLOAT'... |
def ResNet_model(bn=False, num_classes=10, depth=56, nb_filters=16, kernel_size=3, inp_channels=3, k=1, pad_conv1=0, affine=True, inp_noise=0, VIB=False):
return ResNet(depth=depth, nb_filters=nb_filters, num_classes=num_classes, bn=bn, kernel_size=kernel_size, inp_channels=inp_channels, k=k, pad_conv1=pad_conv1, a... |
def get_descriptors(model, dataloader, device):
descriptors = []
with torch.no_grad():
with torch.autocast(device_type='cuda', dtype=torch.float16):
for batch in tqdm(dataloader, 'Calculating descritptors...'):
(imgs, labels) = batch
output = model(imgs.to(dev... |
def find_latest_tag_commit(tags):
for tag in reversed(tags):
s = re.match('v\\s*([\\d.]+)', tag.name)
print(f'Latest version tag is: {tag.name}', file=sys.stderr)
if (s is not None):
return tag.commit |
class CraigslistValidationPipeline(object):
def process_item(self, item, spider):
if (item == {}):
raise DropItem('parse error')
else:
return item |
def silent_net():
n = caffe.NetSpec()
(n.data, n.data2) = L.DummyData(shape=dict(dim=3), ntop=2)
n.silence_data = L.Silence(n.data, ntop=0)
n.silence_data2 = L.Silence(n.data2, ntop=0)
return n.to_proto() |
class SRWLPartBeam(object):
def __init__(self, _Iavg=0, _nPart=0, _partStatMom1=None, _arStatMom2=None):
self.Iavg = _Iavg
self.nPart = _nPart
self.partStatMom1 = (SRWLParticle() if (_partStatMom1 is None) else _partStatMom1)
self.arStatMom2 = (array('d', ([0] * 21)) if (_arStatMom2 ... |
class DropPath(nn.Module):
def __init__(self, p: float=None):
super().__init__()
self.p = p
def forward(self, x: Tensor) -> Tensor:
if ((self.p == 0.0) or (not self.training)):
return x
kp = (1 - self.p)
shape = ((x.shape[0],) + ((1,) * (x.ndim - 1)))
... |
class ErrorErasureChannel(Channel):
def __init__(self, space, number_errors, number_erasures):
if isinstance(number_errors, (Integer, int)):
number_errors = (number_errors, number_errors)
if (not isinstance(number_errors, (tuple, list))):
raise ValueError('number_errors must ... |
class MarianTokenizer():
def __init__(self, *args, **kwargs):
requires_sentencepiece(self)
def from_pretrained(self, *args, **kwargs):
requires_sentencepiece(self) |
('VariableLSTM')
def _variable_lstm_grad(op, act_grad, gate_grad, mem_grad):
initial_state = op.inputs[1]
initial_memory = op.inputs[2]
w_m_m = op.inputs[3]
act = op.outputs[0]
gate_raw_act = op.outputs[1]
memory = op.outputs[2]
return rnn.variable_lstm_grad(initial_state, initial_memory, w_... |
def trivial_loop(data: dace.float64[(I, J)]):
for i in range(1, 2):
for j in dace.map[0:J]:
data[(i, j)] = (data[(i, j)] + data[((i - 1), j)]) |
def dconv_bn_relu(in_dim, out_dim):
return nn.Sequential(nn.ConvTranspose2d(in_dim, out_dim, 5, 2, padding=2, output_padding=1, bias=False), nn.BatchNorm2d(out_dim), nn.ReLU()) |
class BeamsplitterTest(tf.test.TestCase):
def test_(self):
for hadamard in [True, False]:
for epsilon in [0, 0.1]:
bs = Beamsplitter(hadamard=hadamard, epsilon=epsilon)
self.assertAllClose((bs.matrix bs.inverse_matrix), IDENTITY)
self.assertAllClo... |
def write_results(results):
filename = tempfile.mktemp()
tmp_file = open(filename, 'w+')
tmp_file.write(results.encode('utf-8'))
return tmp_file |
def dist_gather_tensor(vecs, world_size, local_rank=0, detach=True):
all_tensors = [torch.empty_like(vecs) for _ in range(world_size)]
dist.all_gather(all_tensors, vecs)
if (not detach):
all_tensors[local_rank] = vecs
all_tensors = torch.cat(all_tensors, dim=0)
return all_tensors |
def process_events(events: List[Event], sentence_entities: List[List[Entity]], sentences: List[Tuple[(str, int, int)]]) -> List[List[Event]]:
sentence_events = [[] for _ in range(len(sentences))]
for event in events:
(start, end) = (event.trigger.start, event.trigger.end)
for (i, (_, s, e)) in e... |
class RASampler(torch.utils.data.Sampler):
def __init__(self, dataset_len, batch_size, repetitions=1, len_factor=3.0, shuffle=False, drop_last=False):
self.dataset_len = dataset_len
self.batch_size = batch_size
self.repetitions = repetitions
self.len_images = int((dataset_len * len_f... |
def drop_connect(inputs, p, training):
assert (0 <= p <= 1), 'p must be in range of [0,1]'
if (not training):
return inputs
batch_size = inputs.shape[0]
keep_prob = (1 - p)
random_tensor = keep_prob
random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype, device=inputs.devi... |
class TResNet(nn.Module):
def __init__(self, layers, in_chans=3, num_classes=1000, width_factor=1.0, no_aa_jit=False, global_pool='avg', drop_rate=0.0):
self.num_classes = num_classes
self.drop_rate = drop_rate
super(TResNet, self).__init__()
space_to_depth = SpaceToDepthModule()
... |
def get_f77flags(src):
flags = {}
f = open_latin1(src, 'r')
i = 0
for line in f:
i += 1
if (i > 20):
break
m = _f77flags_re.match(line)
if (not m):
continue
fcname = m.group('fcname').strip()
fflags = m.group('fflags').strip()
... |
def tokenize_sentences(x):
tokenized_s = tokenizer(x['s']['text'], add_special_tokens=False)
tokenized_s_with_context = tokenizer(x['s_with_context']['text'], add_special_tokens=False)
s_links = {}
for (k, v) in x['s']['links'].items():
anchors = []
for (start, end) in v:
if ... |
def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(1, 1), dilation=1):
(filters1, filters2, filters3) = filters
if (K.image_data_format() == 'channels_last'):
bn_axis = 3
else:
bn_axis = 1
conv_name_base = ((('res' + str(stage)) + block) + '_branch')
bn_name_ba... |
def make_latex_table(args):
csvs = glob.glob(f'{args.results_folder}/**/*Success.csv')
results = defaultdict((lambda : defaultdict(list)))
for csv in csvs:
(seed, real, coda, _, dyna, roll, mbpo, c3xm) = parse_title(csv)
coda_to_real_ratio = (int(coda) // int(real))
csv = pandas.read... |
def save_cog(out_np: np.ndarray, path_tiff_save: str, profile: dict, tags: Optional[dict]=None, dir_tmpfiles: str='.'):
for (idx, c) in enumerate(['count', 'height', 'width']):
if (c in profile):
assert (profile[c] == out_np.shape[idx]), f'Unexpected shape: {profile[c]} {out_np.shape}'
e... |
_call_aside
def _initialize(g=globals()):
manager = ResourceManager()
g['_manager'] = manager
g.update(((name, getattr(manager, name)) for name in dir(manager) if (not name.startswith('_')))) |
def __compute_torperf_error_rates(daily_counts):
err_rates = []
for day in daily_counts:
total = int(daily_counts[day]['requests'])
if (total <= 0):
continue
timeouts = int(daily_counts[day]['timeouts'])
failures = int(daily_counts[day]['failures'])
err_rates.... |
def import_module_404ok(*args, **kwargs):
try:
mod = import_module(*args, **kwargs)
except (ModuleNotFoundError, ImportError) as e:
mod = None
return mod |
class DownSample(nn.Module):
def __init__(self, in_features: int, out_features: int, dropout: float, add_IC: bool):
super().__init__()
assert (in_features > out_features)
self.in_features = in_features
self.out_features = out_features
self.add_IC = add_IC
if self.add_... |
def compute_overlap_alignment_laywise_IoU_layerwise_DocSim(opts, max_real, num_gen):
(stats_bbox_real, stats_bbox_fake, stats_bbox_class, stats_mask, stats_overlap, stats_alignment) = metric_utils_layout.compute_maxIoU_overlap_alignment_wrapper(opts=opts, rel_lo=0, rel_hi=1, max_items=max_real)
bbox_real = stat... |
def get_train_val_indices(train_dataset, val_split=0.2):
all_targets = [t for (i, (p, t)) in enumerate(train_dataset.samples)]
train_classes = np.unique(all_targets)
train_idxs = []
val_idxs = []
for cls in train_classes:
cls_idxs = np.where((all_targets == cls))[0]
v_ = np.random.ch... |
def get_masked_tokens_from_tagged_text(tagged_text):
chunks = tagged_text.split('__')
masks = []
curr_offset = 0
clean_text = ''
for (chunk_num, chunk) in enumerate(chunks):
if ((chunk_num % 2) == 1):
masks.append((curr_offset, (curr_offset + len(chunk))))
curr_offset += ... |
class ASR(sb.Brain):
def __init__(self, tea_modules_list=None, hparams=None, run_opts=None):
super(ASR, self).__init__(modules=None, opt_class=None, hparams=hparams, run_opts=run_opts, checkpointer=None)
tea_modules_list_ = []
for tea_modules in tea_modules_list:
tea_modules_ = t... |
_level_function()
def metadata(path, storage_options=None, row_groups=None, columns=None, ignore_metadata=False, scan_files=True):
import awkward._connect.pyarrow
pyarrow_parquet = awkward._connect.pyarrow.import_pyarrow_parquet('ak.from_parquet')
import fsspec.parquet
if (row_groups is not None):
... |
def to_rgb(img):
img = np.atleast_3d(img)
channels = img.shape[2]
if (channels < 3):
img = np.tile(img, 3)
img[np.isnan(img)] = 0
img -= np.amin(img)
img /= np.amax(img)
img *= 255
return img |
def warn_on_static_input_change(input_states):
for (input, traced_input) in zip(input_states[0], input_states[1]):
if isinstance(input, dict):
if (list(input.keys()) != list(traced_input.keys())):
warning = 'We detected that you are modifying a dictionnary that is an input to you... |
class BottleneckBlock(CNNBlockBase):
def __init__(self, in_channels, out_channels, *, bottleneck_channels, stride=1, num_groups=1, norm='BN', stride_in_1x1=False, dilation=1, has_pool=False):
super().__init__(in_channels, out_channels, stride)
self.has_pool = has_pool
self.pool_stride = stri... |
def _calculate_bin_centers(boundaries: torch.Tensor) -> torch.Tensor:
step = (boundaries[1] - boundaries[0])
bin_centers = (boundaries + (step / 2))
bin_centers = torch.cat([bin_centers, (bin_centers[(- 1)] + step).unsqueeze((- 1))], dim=0)
return bin_centers |
def run_codex_prediction(test_file):
print(f'Running codex on {test_file} ...')
output_file = test_file.replace('.json', '.json.codex')
print(f'Output file: {output_file} ...')
if os.path.exists(output_file):
passed_cases = open(output_file, 'r').readlines()
if (not passed_cases[(- 1)].e... |
def halluication(directory, lang):
mode = 'train'
if (not os.path.isfile(f'{directory}/{lang}.hall')):
print('missing .hall for', lang)
return
with open(f'{directory}/{lang}.hall.{mode}', 'w') as fp:
for toks in read_file(f'{directory}/{lang}.{mode}'):
print(*toks, sep='\... |
def train_fast(train_loader, train_table, model, model_bert, opt, bert_config, tokenizer, max_seq_length, num_target_layers, accumulate_gradients=1, check_grad=True, st_pos=0, opt_bert=None, path_db=None, dset_name='train'):
model.train()
model_bert.train()
ave_loss = 0
cnt = 0
cnt_sc = 0
cnt_sa... |
def get_scheduler(optimizer, opt):
if (opt.lr_policy == 'lambda'):
def lambda_rule(epoch):
lr_l = (1.0 - (max(0, (((epoch + 1) + opt.epoch_count) - opt.niter)) / float((opt.niter_decay + 1))))
return lr_l
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
... |
def import_sample(path: Union[(Path, str)]):
path = ((Path(__file__).parent.parent / 'samples') / Path(path))
if (not path.exists()):
raise ValueError(f'Sample {path} not found.')
name = path.stem
spec = importlib.util.spec_from_file_location(name, path)
loaded_module = importlib.util.module... |
class Discriminator(nn.Module):
def __init__(self, img_size: int=64, ndf: int=64, kd: int=4, nc: int=3, batch_norm: bool=True):
super(Discriminator, self).__init__()
self.img_size = img_size
self.ndf = ndf
self.kd = kd
self.nc = nc
pd = 1
sd = 2
self.s... |
def create_worker(queue, get_blob_data):
def dummy_worker(worker_id):
blob = ('blob_' + str(worker_id))
workspace.FeedBlob(blob, get_blob_data(worker_id))
workspace.RunOperatorOnce(core.CreateOperator('SafeEnqueueBlobs', [queue, blob], [blob, ('status_blob_' + str(worker_id))]))
return d... |
class LaserEmbedding(EmbeddingBase):
def __init__(self):
self.client: DockerClient = docker.from_env()
self.__init_laser()
self.size = 1024
def dim(self) -> int:
return self.size
def batcher(self, params, batch: List[List[str]]) -> np.ndarray:
batch = [(' '.join(sent)... |
def rebuild_sql_val(sql):
if ((sql is None) or (not DISABLE_VALUE)):
return sql
sql['from']['conds'] = rebuild_condition_val(sql['from']['conds'])
sql['having'] = rebuild_condition_val(sql['having'])
sql['where'] = rebuild_condition_val(sql['where'])
sql['intersect'] = rebuild_sql_val(sql['i... |
def _make_dict_of_lists_symmetric(dct: dict):
to_add_dict = defaultdict(list)
for (key, values) in dct.items():
for value in values:
to_add_dict[value].append(key)
for (key, to_add_values) in to_add_dict.items():
try:
dct[key] += to_add_dict[key]
except KeyErr... |
def test_does_rdataframe_see_these_as_boolean():
ak_array_in = ak.Array([True, False, True])
data_frame = ak.to_rdataframe({'x': ak_array_in})
assert (data_frame.GetColumnType('x') == 'bool')
data_frame_2 = data_frame.Define('y', '!x')
ak_array_out = ak.from_rdataframe(data_frame_2, columns=('y',))
... |
def softmax(x):
e = numpy.exp((x - numpy.max(x)))
if (e.ndim == 1):
return (e / numpy.sum(e, axis=0))
else:
return (e / numpy.array([numpy.sum(e, axis=1)]).T) |
class UniformBackgroundField(BaseSrc):
def __init__(self, receiver_list=None, amplitude=50000, inclination=90, declination=0, **kwargs):
self.amplitude = amplitude
self.inclination = inclination
self.declination = declination
super().__init__(receiver_list=receiver_list, **kwargs)
... |
def roi_array_to_dict(a):
l = []
a = a[['startx', 'starty', 'endx', 'endy', 'groupx', 'groupy']]
for (sx, sy, ex, ey, gx, gy) in a:
d = {'top_left': [int(sx), int(sy)], 'bottom_right': [int(ex), int(ey)], 'bin': [int(gx), int(gy)]}
l.append(d)
return l |
_torch
_vision
class DeiTImageProcessingTest(ImageProcessingSavingTestMixin, unittest.TestCase):
image_processing_class = (DeiTImageProcessor if is_vision_available() else None)
test_cast_dtype = True
def setUp(self):
self.image_processor_tester = DeiTImageProcessingTester(self)
def image_proces... |
def MonoidAlgebras(base_ring):
from sage.categories.monoids import Monoids
return Monoids().Algebras(base_ring) |
def p_assert_statement(s):
pos = s.position()
s.next()
cond = p_test(s)
if (s.sy == ','):
s.next()
value = p_test(s)
else:
value = None
return Nodes.AssertStatNode(pos, cond=cond, value=value) |
def generate_files(train_gen, dev_gen, train_preprocess_path, dev_preprocess_path):
if dev_gen:
gen_file(train_gen, train_preprocess_path)
gen_file(dev_gen, dev_preprocess_path)
else:
train_writer = tf.python_io.TFRecordWriter(train_preprocess_path)
dev_writer = tf.python_io.TFRe... |
def generate_backward_function_mapping(function_info):
function_list = utils.info_to_list(function_info)
utils.generate_from_template(join(base, 'python/src/nnabla/backward_functions.py.tmpl'), function_info=function_info, function_list=function_list) |
def read_labelmap(labelmap_file):
labelmap = []
class_ids = set()
name = ''
class_id = ''
for line in labelmap_file:
if line.startswith(' name:'):
name = line.split('"')[1]
elif (line.startswith(' id:') or line.startswith(' label_id:')):
class_id = int(line... |
def train_model(model_settings, output_path, tensorboard_logging=False):
num_of_envs = model_settings['num_of_envs']
model_path = os.path.join(output_path, 'model')
if tensorboard_logging:
tb_path = model_path
else:
tb_path = None
try:
os.makedirs(model_path)
ckpt_pat... |
def mult_sent_answer_counter():
count = 0
for article in aug_data['data']:
for para in article['paragraphs']:
for qa in para['qas']:
for answer in qa['answers']:
text = answer['text']
word_start = answer['answer_word_start']
... |
.parametrize('seed', [313])
.parametrize('axis', [None, 0, 1, 2, 3, (0, 2), (1, 2, 3)])
.parametrize('keepdims', [False, True])
.parametrize('inshape', [(2, 3, 4, 5), (2, 1, 4, 5)])
.parametrize('op, ctx, func_name', list_ctx_and_func_name(['sum', 'mean', 'max', 'min', 'prod']))
def test_reduction_forward_backward(op, ... |
def get_system(name, args, schema=None, timed=False, model_path=None):
if (name in ('rulebased', 'neural')):
lexicon = Lexicon(schema, args.learned_lex, stop_words=args.stop_words, lexicon_path=args.lexicon)
if args.inverse_lexicon:
realizer = InverseLexicon.from_file(args.inverse_lexico... |
def connect(host, port):
ssl_sock = ssl.wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
ssl_sock.connect((host, port))
return ssl_sock |
def accuracy(output, labels):
preds = output.max(1)[1].type_as(labels)
correct = preds.eq(labels).double()
correct = correct.sum()
return (correct / len(labels)) |
def run_return_code_old(command):
import subprocess
result = subprocess.Popen(command, shell=True)
output = result.communicate()[0]
return (result.returncode, output) |
def parse_request(r):
from . import exceptions
try:
data = r.json()
except Exception:
if (len(r.text) == 0):
data = {}
else:
data = {'message': r.text}
if (r.status_code > 204):
data['message'] = data.get('message', '')
data['status'] = dat... |
def common_pre_post_processing(func_raw):
def func(*args, **kwargs):
pre_normalise = kwargs.pop('pre_normalise', False)
post_standardise = kwargs.pop('post_standardise', False)
post_zeroonescaling = kwargs.pop('post_zeroonescaling', False)
post_edgeprior = kwargs.pop('post_edgeprior'... |
def override_option(ctx, param, value):
if ((value is None) or (isinstance(value, Iterable) and (len(value) == 0))):
value = ctx.params['_'.join(param.name.split('_')[1:])]
return value |
class SmallUpdateBlock(nn.Module):
def __init__(self, args, hidden_dim=96):
super(SmallUpdateBlock, self).__init__()
self.encoder = SmallMotionEncoder(args)
self.gru = ConvGRU(hidden_dim=hidden_dim, input_dim=(82 + 64))
self.flow_head = FlowHead(hidden_dim, hidden_dim=128)
def fo... |
def get_width(tensor_shape):
tensor_shape.assert_has_rank(rank=4)
return tensor_shape[2].value |
class TestConvLayer(unittest.TestCase):
def test_data_loops(self):
dls = ConvLayer.data_loops()
self.assertEqual(dls[de.FIL], DataDimLoops(le.IFM, le.OFM))
self.assertEqual(dls[de.IFM], DataDimLoops(le.IFM, le.BAT))
self.assertEqual(dls[de.OFM], DataDimLoops(le.OFM, le.BAT))
... |
def compatible_systems(split_prime_list, complement_exp_vec_dict):
S0 = split_prime_list
system_list = []
if (len(S0) == 1):
q = S0[0]
for exponent_vector in complement_exp_vec_dict[q]:
for complementary_vector in complement_exp_vec_dict[q][exponent_vector]:
pair ... |
class Shape(goos.ProblemGraphNode):
node_type = 'goos.shape'
def translate(self, offset: np.ndarray) -> 'Shape':
return TranslateShape(self, offset) |
def register_methods(root_module):
register_Ns3Address_methods(root_module, root_module['ns3::Address'])
register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstru... |
def setup(**attr):
cmdclass = numpy_cmdclass.copy()
new_attr = attr.copy()
if ('cmdclass' in new_attr):
cmdclass.update(new_attr['cmdclass'])
new_attr['cmdclass'] = cmdclass
if ('configuration' in new_attr):
configuration = new_attr.pop('configuration')
old_dist = distutils.c... |
class InterfaceFeature(Feature):
def __classcall__(cls, name, module, description=None):
if isinstance(module, str):
module = PythonModule(module)
return Feature.__classcall__(cls, name, module, description)
def __init__(self, name, module, description):
super().__init__(name... |
def convert_DateProperty(model, prop, kwargs):
if (prop.auto_now or prop.auto_now_add):
return None
kwargs.setdefault('format', '%Y-%m-%d')
return f.DateField(**kwargs) |
def embed_images_in_inception(imgs, inception_path, layer_name, batch_size=32):
input_tensor = tf.placeholder(tf.float32, [None, None, None, 3])
if (not os.path.exists(inception_path)):
raise ValueError(('Inception network file not found: ' + inception_path))
graph = tf.contrib.gan.eval.get_graph_de... |
_config
def task_finetune_lsmdcchoice():
exp_name = 'finetune_lsmdc_choice'
video_datasets = ['lsmdc_choice']
image_datasets = []
loss_names = _loss_names({'multiple_choice': 1})
batch_size = 256
max_epoch = 20
max_steps = None
warmup_steps = 0.1
draw_false_text = 5
learning_rate... |
def bench_training(model, batch_size, seq_length, n_samples=110):
start = torch.cuda.Event(enable_timing=True)
end = torch.cuda.Event(enable_timing=True)
timings = []
device = next(model.parameters()).data.device
data = torch.rand(batch_size, seq_length, 1, device=device).cumsum((- 1))
mask = to... |
_utils.test(arch=supported_archs_cgraph)
def test_ndarray_dtype_mismatch_runtime():
n = 4
def test(pos: ti.types.ndarray(ndim=1)):
for i in range(n):
pos[i] = 2.5
sym_pos = ti.graph.Arg(ti.graph.ArgKind.NDARRAY, 'pos', ti.f32, ndim=1)
g_init = ti.graph.GraphBuilder()
g_init.dispa... |
def tf_efficientnet_el(pretrained=False, **kwargs):
kwargs['bn_eps'] = BN_EPS_TF_DEFAULT
kwargs['pad_type'] = 'same'
model = _gen_efficientnet_edge('tf_efficientnet_el', channel_multiplier=1.2, depth_multiplier=1.4, pretrained=pretrained, **kwargs)
return model |
_module()
class YOLOF(SingleStageDetector):
'Implementation of `You Only Look One-level Feature\n <
def __init__(self, backbone, neck, bbox_head, train_cfg=None, test_cfg=None, pretrained=None):
super(YOLOF, self).__init__(backbone, neck, bbox_head, train_cfg, test_cfg, pretrained) |
def test_mixed_threads_processes(x):
expect = fft.fft(x, workers=2)
with multiprocessing.Pool(2) as p:
res = p.map(_mt_fft, [x for _ in range(4)])
for r in res:
assert_allclose(r, expect)
fft.fft(x, workers=2) |
def map_sent_entities(document, entities, verbose=True):
errors = 0
spans = []
char_index = [s.abs_char_offsets[0] for s in document.sentences]
for t in entities:
position = None
for i in range((len(char_index) - 1)):
if ((t.abs_char_start >= char_index[i]) and (t.abs_char_en... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.