code stringlengths 101 5.91M |
|---|
def is_tf_113():
version = get_tf_version()
return ((int(version[0]) == 1) and (int(version[1]) == 13)) |
def test_TargetPipelineCreator_repeated_names() -> None:
creator = TargetPipelineCreator()
creator.add('zscore')
creator.add('zscore')
pipeline = creator.to_pipeline()
assert isinstance(pipeline, JuTargetPipeline)
assert (len(pipeline.steps) == 2)
assert (pipeline.steps[0][0] == 'zscore')
... |
def test_lambda_closure_cleanup():
m.test_cleanup()
cstats = m.payload_cstats()
assert (cstats.alive() == 0)
assert (cstats.copy_constructions == 1)
assert (cstats.move_constructions >= 1) |
class Preprocess(Layer):
def call(self, x, mask=None):
(bsize, nb_rows, nb_cols, nb_colors) = K.int_shape(x)
if ((nb_rows != 256) or (nb_cols != 256)):
x256 = tf.image.resize_bilinear(x, [256, 256], align_corners=True, name='resize')
else:
x256 = x
if (K.dtype... |
def getLargestCC(segmentation):
labels = label(segmentation, connectivity=1)
largestCC = (labels == np.argmax(np.bincount(labels.flat)))
return largestCC |
class Output(nn.Module):
def __init__(self, input_nc, output_nc, kernel_size=3, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=True, use_coord=False):
super(Output, self).__init__()
kwargs = {'kernel_size': kernel_size, 'padding': 0, 'bias': True}
self.conv1 = coord_conv(i... |
class BertEncoderWithPabee(BertEncoder):
def adaptive_forward(self, hidden_states, current_layer, attention_mask=None, head_mask=None):
layer_outputs = self.layer[current_layer](hidden_states, attention_mask, head_mask[current_layer])
hidden_states = layer_outputs[0]
return hidden_states |
def main():
if (args.gpu is not None):
print(f'Use GPU: {args.gpu} for training')
print('=====> Preparing data...')
print(f'File (.csv): {args.dataset}.csv')
df = pd.read_csv(os.path.join(args.data_dir, f'{args.dataset}.csv'))
(df_train, df_val, df_test) = (df[(df['split'] == 'train')], df[(... |
def compute_r2_score(input_probs, target):
r2 = metrics.r2_score(target.cpu().detach().numpy(), input_probs.cpu().detach().numpy())
return r2 |
def main(train_file, valid_file, embeddings_file, target_dir, hidden_size=300, dropout=0.5, num_classes=3, epochs=64, batch_size=32, lr=0.0004, patience=5, max_grad_norm=10.0, checkpoint=None):
device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
print((20 * '='), ' Preparing for training '... |
def test_mp_ref_energies() -> None:
for (key, val) in mp_elemental_ref_energies.items():
actual = mp_elem_reference_entries[key].energy_per_atom
assert (actual == approx(val, abs=0.001)), f'key={key!r}'
assert (actual == approx(val, abs=0.001)), f'key={key!r}' |
class Word2VecPooled(Word2Vec):
def __init__(self, TEXT=None, embedding_dim=50, batch_size=10, n_gram=4, pooling='avg_pool'):
super(Word2VecPooled, self).__init__(TEXT=TEXT, embedding_dim=embedding_dim, batch_size=batch_size, n_gram=n_gram)
self.pooling = pooling
if (self.pooling == 'avg_poo... |
def single_tune(data_continuum, default_params, tune_params, params_keep, tmp_acc, run):
tune_data = []
test_loaders_full = setup_test_loader(data_continuum.test_data(), default_params)
tune_test_loaders = test_loaders_full[:default_params.num_val]
test_loaders = test_loaders_full[default_params.num_val... |
class NERTransformer(BaseTransformer):
mode = 'token-classification'
def __init__(self, hparams):
if (type(hparams) == dict):
hparams = Namespace(**hparams)
module = import_module('tasks')
try:
token_classification_task_clazz = getattr(module, hparams.task_type)
... |
def train_self_play(results_dir, scenario_name, print_train_results=True):
scenario: PSROScenario = scenario_catalog.get(scenario_name=scenario_name)
env_class = scenario.env_class
env_config = scenario.env_config
trainer_class = scenario.trainer_class
policy_classes: Dict[(str, Type[Policy])] = sce... |
class CTViTTrainer(nn.Module):
def __init__(self, vae: CTViT, *, num_train_steps, batch_size, folder, train_on_images=False, num_frames=17, lr=3e-05, grad_accum_every=1, wd=0.0, max_grad_norm=0.5, discr_max_grad_norm=None, save_results_every=50, save_model_every=250, results_folder='./results', valid_frac=0.05, ran... |
def generate_hash(n_points, d, b, h):
torch.manual_seed(0)
x = torch.rand(n_points, d).cuda()
a = torch.randn(b, (d + 1)).cuda()
compute_hashes(x, a, h)
return h |
def DeepSetsTrain(X_deepset_transductive_train, Y_deepset_transductive_train, num_epochs):
deepsets_transductive_model.load_weights((('models/' + dataset_name) + '/deepsets_transductive_model.h5'))
history = deepsets_transductive_model.fit(X_deepset_transductive_train, Y_deepset_transductive_train, epochs=num_e... |
def prepare_static_timestepping():
static_timestepping_func = None
if (not master):
if bcast():
static_timestepping_func = (lambda a=(- 1): bcast())
return static_timestepping_func
apply_static_timestepping = False
if (static_timestepping is None):
pass
elif isins... |
def make_conf_nll_loss_evaluator(cfg):
default_args = cfg.model.cmn.losses.nll_loss.copy()
default_args.update(sparse=cfg.data.sparse)
default_args.pop('weight')
return ConfidenceNllLoss(**default_args) |
def _tensor_to_tensorinfo(tensor):
tensor_info = {}
if isinstance(tensor, sparse_tensor.SparseTensor):
tensor_info['is_dense'] = False
tensor_info['values'] = _tensor_to_map(tensor.values)
tensor_info['indices'] = _tensor_to_map(tensor.indices)
tensor_info['dense_shape'] = _tenso... |
class StopWatch(object):
def __init__(self):
self.reset()
def reset(self):
self.timings = OrderedDict()
self.starts = {}
def toogle(self, name):
if (name in self.starts):
self.stop(name)
else:
self.start(name)
def start(self, name):
... |
def read_MR(path, seed=1234):
file_path = os.path.join(path, 'rt-polarity.all')
(data, labels) = read_corpus(file_path, encoding='latin-1')
random.seed(seed)
perm = list(range(len(data)))
random.shuffle(perm)
data = [data[i] for i in perm]
labels = [labels[i] for i in perm]
return (data,... |
def euclidean_squared_distance(input1, input2):
(m, n) = (input1.size(0), input2.size(0))
mat1 = torch.pow(input1, 2).sum(dim=1, keepdim=True).expand(m, n)
mat2 = torch.pow(input2, 2).sum(dim=1, keepdim=True).expand(n, m).t()
distmat = (mat1 + mat2)
distmat.addmm_(1, (- 2), input1, input2.t())
r... |
def test_array(doc):
l = m.cast_array()
assert (l == [1, 2])
assert m.load_array(l)
assert (doc(m.cast_array) == 'cast_array() -> List[int[2]]')
assert (doc(m.load_array) == 'load_array(arg0: List[int[2]]) -> bool') |
def get_closest(code_line, project_type):
if (code_line == ''):
return ''
idx_path = ('./retrieval/%s/lucene_index_bline2fline' % project_type.lower())
closest_line = find_top(code_line, idx_path)
if (closest_line == None):
closest_line = ''
return closest_line |
class CG(torch.nn.Module):
def __init__(self, hidden_channels, num_layers, max_z, train_dataset, use_feature=False, node_embedding=None, dropout=0.5, jk=True, train_eps=False):
super(CG, self).__init__()
self.use_feature = use_feature
self.node_embedding = node_embedding
self.max_z =... |
def softmax_dropout(x: torch.Tensor, p: float, mask: Optional[torch.Tensor]=None, causal: bool=False, mask_type: str='qk') -> torch.Tensor:
if (p == 0.0):
return softmax(x, mask=mask, mask_type=mask_type)
else:
return _softmax_dropout_dispatch(x, p, mask, causal, mask_type=mask_type) |
class Optimizer(object):
def __init__(self, opt_name, parameters, lr, clip_grad_norm=None):
opt_name = opt_name.lower().replace('_', '').strip()
if (opt_name == 'sgd'):
optimizer = opt.SGD
elif (opt_name == 'rmsprop'):
optimizer = opt.RMSprop
elif (opt_name ==... |
class _Transition(nn.Module):
def __init__(self):
super(_Transition, self).__init__()
self.pool = nn.AvgPool2d(kernel_size=2, stride=2)
def forward(self, x):
x = self.pool(x)
return x |
class XLMRobertaTokenizer(PreTrainedTokenizer):
vocab_files_names = VOCAB_FILES_NAMES
pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
model_input_names = ['attention_mask']
def __init__(self, vocab_file, bos_token='<s>', eos_toke... |
def _Graph_fromSDString(s: str, options: MDLOptions=MDLOptions(), add: bool=True) -> List[Graph]:
return _graphsLoad(_Graph_fromSDString_orig(s, options), add) |
class DatasetCatalog(object):
human = cfg.human
dataset_attrs = {'Human{}_0001_Train'.format(human): {'data_root': 'data/zju_mocap/CoreView_{}'.format(human), 'human': 'CoreView_{}'.format(human), 'ann_file': 'data/zju_mocap/CoreView_{}/annots.npy'.format(human), 'split': 'train'}, 'Human{}_0001_Test'.format(hu... |
_module()
class CPM(BaseBackbone):
def __init__(self, in_channels, out_channels, feat_channels=128, middle_channels=32, num_stages=6, norm_cfg=dict(type='BN', requires_grad=True)):
norm_cfg = copy.deepcopy(norm_cfg)
super().__init__()
assert (in_channels == 3)
self.num_stages = num_s... |
def _get_config_module(fname):
from mmcv import Config
config_dpath = _get_config_directory()
config_fpath = join(config_dpath, fname)
config_mod = Config.fromfile(config_fpath)
return config_mod |
def main(rank, device_count, world_size, cfg):
setup(rank, world_size)
device_id = (rank % device_count)
device = torch.device(f'cuda:{device_id}')
torch.cuda.set_device(device_id)
if ('kitti' in cfg.DATASET):
tracklet_anns = KittiLoader.load_all_annotations(cfg.DATA_DIR, 'test')
tra... |
class Compose(object):
def __init__(self, transforms):
self.transforms = transforms
def __call__(self, *args):
assert ((len(args) == 2) or (isinstance(args[0], (list, tuple)) and (len(args[0]) == 2))), 'Two arguments must be specified, an image and a corresponding label'
input = (list(ar... |
class ConvSeq3x3Branch(nn.Module):
def __init__(self, in_channels, out_channels_list, kernel_size_list, strides_list, padding_list):
super(ConvSeq3x3Branch, self).__init__()
self.conv_list = nn.Sequential()
for (i, (out_channels, kernel_size, strides, padding)) in enumerate(zip(out_channels_... |
def load_tf_model_weights(mdl, layer_lookup, tf_mdl_dir, is_resnet=True, arg_num=None):
tf.reset_default_graph()
with tf.Session() as sess:
(tf_layers, tf_params, tf_shapes) = import_tf_params(tf_mdl_dir, sess)
layer_info = get_layer_indices(layer_lookup, tf_layers)
for (layer_name, info... |
def extract_features(data_loader, attr_file, attr2idx_file, device, image_model, attribute_topk=8, batch_size=128):
model = EfficientNet.from_pretrained('efficientnet-b7')
ckpt = torch.load(image_model, map_location='cpu')
print('[INFO] Loading weights from {}'.format(image_model))
if ('model_state' in ... |
class VoltageControlEnv(BaseEnvironment):
def __init__(self):
self._environment = VoltageControl()
self.possible_agents = [f'agent_{id}' for id in range(self._environment.get_num_of_agents())]
self.num_agents = len(self.possible_agents)
self._num_actions = self._environment.get_total... |
def translate_y_abs(img, pixels, **kwargs):
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs) |
class ZoeDepthNK(DepthModel):
def __init__(self, core, bin_conf, bin_centers_type='softplus', bin_embedding_dim=128, n_attractors=[16, 8, 4, 1], attractor_alpha=300, attractor_gamma=2, attractor_kind='sum', attractor_type='exp', min_temp=5, max_temp=50, memory_efficient=False, train_midas=True, is_midas_pretrained=... |
def make_network_cnn(num_outputs: int, mlp_units: Sequence[int], conv_n_channels: int) -> FeedForwardNetwork:
def network_fn(observation: Observation) -> chex.Array:
board = observation.board.astype(float)[(..., None)]
torso = hk.Sequential([hk.Conv2D(conv_n_channels, (2, 2), 1, padding='VALID'), ja... |
class Parser(_Parser):
def find_tags(self, tokens, **kwargs):
if (kwargs.get('tagset') in (PENN, None)):
kwargs.setdefault('map', (lambda token, tag: (token, tag)))
if (kwargs.get('tagset') == UNIVERSAL):
kwargs.setdefault('map', (lambda token, tag: penntreebank2universal(tok... |
class SegmentationDecoder(nn.Module):
def __init__(self, num_class=21, fc_dim=2048, pool_scales=(1, 2, 3, 6), task_type='C'):
super(SegmentationDecoder, self).__init__()
self.task_type = task_type
self.ppm = []
for scale in pool_scales:
self.ppm.append(nn.Sequential(nn.Ad... |
class MicroConverter():
def __init__(self, model_conf, net_def, model_weights, model_name, offset16=False, write_magic=False):
self.model_conf = model_conf
data_type = model_conf.get(ModelKeys.data_type, mace_pb2.DT_FLOAT)
if (model_conf.get(ModelKeys.quantize_schema) == 'int8'):
... |
class LombScargleAsyncProcess(GPUAsyncProcess):
def __init__(self, *args, **kwargs):
super(LombScargleAsyncProcess, self).__init__(*args, **kwargs)
self.nfft_proc = NFFTAsyncProcess(*args, **kwargs)
self._cpp_defs = self.nfft_proc._cpp_defs
self.real_type = self.nfft_proc.real_type
... |
class Inertial(xmlr.Object):
def __init__(self, mass=0.0, inertia=None, origin=None):
self.mass = mass
self.inertia = inertia
self.origin = origin |
class InteractionNet(pyg.nn.MessagePassing):
def __init__(self, edge_index, input_dim, update_edges=True, hidden_layers=1, hidden_dim=None, edge_chunk_sizes=None, aggr_chunk_sizes=None, aggr='sum'):
assert (aggr in ('sum', 'mean')), f'Unknown aggregation method: {aggr}'
super().__init__(aggr=aggr)
... |
class StatsCollectorTest(unittest.TestCase):
def test_job_metric_collector(self):
collector = JobMetricCollector('1111', 'default', 'local', 'dlrover')
collector.collect_dataset_metric('test', 1000)
speed_monitor = SpeedMonitor()
t = int(time.time())
speed_monitor.set_target_... |
def eval(args, epoch, dataset, dataloader, flownmt):
flownmt.eval()
flownmt.sync()
reconstruct(epoch, dataset, dataloader, flownmt, args.result_path, args.log)
bleu = translate(epoch, dataset, dataloader, flownmt, args.result_path, args.log)
recon_loss = 0.0
kl_loss = 0.0
length_loss = 0.0
... |
class _CommonSchemaConstants():
LOCAL_IMPORTANCE = 'local_importance'
SUMMARY_IMPORTANCE = 'summary_importance'
METADATA = 'metadata' |
class SteerControllerParam(PIDParam):
kP: float = 4
kI: float = 0.1
kD: float = 0.2
antiwindup: tuple[(float, float)] = ((- 0.5), 0.5)
setpoint_minmax: tuple[(float, float)] = (((- math.pi) / 6), (math.pi / 6))
output_minmax: tuple[(float, float)] = ((- 1), 1)
def from_vehicle_params(cls, ve... |
def forwardXXreverse(args, cpc_model, device, data_loader, output_ark, output_scp):
logger.info('Starting Forward Passing')
cpc_model.eval()
ark_scp_output = ((('ark:| copy-feats --compress=true ark:- ark,scp:' + output_ark) + ',') + output_scp)
with torch.no_grad():
with ko.open_or_fd(ark_scp_o... |
def get_imagenet_label_wid_pairs():
path = get_imagenet_path()
dataset = datasets.ImageNet(path, split='val', transform='none')
classes_extended = dataset.classes
wids = dataset.wnids
label_wid_pairs = []
for (a, b) in zip(classes_extended, wids):
label_wid_pairs.append((a[0], b))
re... |
class Token_transformer(nn.Module):
def __init__(self, dim, in_dim, num_heads, mlp_ratio=1.0, qkv_bias=False, qk_scale=None, drop=0.0, attn_drop=0.0, drop_path=0.0, act_layer=nn.GELU, norm_layer=nn.LayerNorm):
super().__init__()
self.norm1 = norm_layer(dim)
self.attn = Attention(dim, in_dim=... |
class SimulatedDynamics(AbstractDynamics):
def __init__(self):
pass
def apply(self, state, action, dt):
if (action.reset_seq or (action.reference is not state.reference) or (action.reference is None)):
seq = 1
elif action.finish_sequence:
seq = 0
else:
... |
def test_sz_zero_gaussian_spin_overlap():
local_spin_exchange = physics.spin.create_local_spin_exchange(slog_psi_apply=_gaussian_two_particle_wavefn, nelec=jnp.array([1, 1]))
(_, random_x) = _get_random_samples(seed=6, nelec_total=2)
local_spin_exchange_out = local_spin_exchange(None, random_x)
norms = ... |
def test_cls_and_dtype_conversion(simple_dtype):
s = m.SimpleStruct()
assert (s.astuple() == (False, 0, 0.0, 0.0))
assert (m.SimpleStruct.fromtuple(s.astuple()).astuple() == s.astuple())
s.uint_ = 2
assert (m.f_simple(s) == 20)
s_recarray = np.array([(False, 2, 0.0, 0.0)], dtype=simple_dtype)
... |
('pybaseball.cache.config.enabled', True)
('glob.glob', MagicMock(return_value=['1.cache_record.json']))
('pybaseball.cache.file_utils.load_json', MagicMock(return_value={'expires': '3000-01-01', 'func': 'df_func', 'args': [1, 2], 'kwargs': {'val1': 'a'}, 'dataframe': 'cachefile.csv'}))
def test_call_cache_enabled_load... |
class TestBasicTuningStrategy(unittest.TestCase):
def setUpClass(self):
self.constant_graph = build_fake_model()
self.workspace = os.path.abspath(options.workspace)
def tearDownClass(self):
shutil.rmtree('saved', ignore_errors=True)
shutil.rmtree(self.workspace)
def test_run_... |
def save_pil(I, out_dir, pair_id, img_id):
I.save(os.path.join(out_dir, '{}_{}.jpg'.format(pair_id, img_id))) |
def val():
epoch_error = 0
valid_iteration = 0
three_px_acc_all = 0
model.eval()
for (iteration, batch) in enumerate(testing_data_loader):
(input1, input2, target) = (Variable(batch[0], requires_grad=False), Variable(batch[1], requires_grad=False), Variable(batch[2], requires_grad=False))
... |
def resolve_schubert_conditions(ndim, kdim, brackets, verbose=True):
from phcpy.phcpy2c3 import py2c_schubert_resolve_conditions as resolve
nbc = len(brackets)
cds = ''
for bracket in brackets:
for num in bracket:
cds = ((cds + ' ') + str(num))
roco = resolve(ndim, kdim, nbc, len... |
def replace_unk_e2e_(beam_lst, lst_src, int_order):
result = []
for (idx, num) in enumerate(int_order):
fields = get_e2e_poswrds(lst_src[num])
fields = [wrd for ((k, idx), wrd) in fields.items()]
result.append(fields)
result_2 = []
x_idx = 0
for ii in range(len(beam_lst)):
... |
class TFRobertaPreLayerNormForMaskedLM(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
class DriveValue():
MAX = 1.0
MIN = (- 1.0)
DELTA = 0.05
value = 0.0
def reset(self):
self.value = 0.0
return self.value
def incr(self, by_value=0):
self.value = min(self.MAX, (self.value + (by_value if (by_value != 0) else self.DELTA)))
return round(self.value, 3... |
def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, cls_token_at_end=False, cls_token='[CLS]', cls_token_segment_id=1, sep_token='[SEP]', sep_token_extra=False, pad_on_left=False, pad_token=0, pad_token_segment_id=0, pad_token_label_id=(- 100), sequence_a_segment_id=0, mask_padding_with_ze... |
class JpegNoise(ImageAugmentor):
def __init__(self, quality_range=(40, 100)):
super(JpegNoise, self).__init__()
self._init(locals())
def _get_augment_params(self, img):
return self.rng.randint(*self.quality_range)
def _augment(self, img, q):
enc = cv2.imencode('.jpg', img, [c... |
def check_train_all(raw_data, directions, all_test_data):
mess_up_train = {}
data_sizes = {}
print(f'checking training data againsts # {len(all_test_data)} sentences')
print(f'example test data: ', [s for (i, s) in enumerate(all_test_data.keys()) if (i < 10)])
for direction in directions:
(s... |
class ResNet(nn.Module):
def __init__(self, cfg):
super(ResNet, self).__init__()
stem_module = _STEM_MODULES[cfg.MODEL.RESNETS.STEM_FUNC]
stage_specs = _STAGE_SPECS[cfg.MODEL.BACKBONE.CONV_BODY]
transformation_module = _TRANSFORMATION_MODULES[cfg.MODEL.RESNETS.TRANS_FUNC]
sel... |
class L2Norm(ssd_neck.L2Norm):
def __init__(self, **kwargs):
super(L2Norm, self).__init__(**kwargs)
warnings.warn('DeprecationWarning: L2Norm in ssd_vgg.py is deprecated, please use L2Norm in mmdet/models/necks/ssd_neck.py instead') |
def test_mse():
model_input = np.asarray([0.5, 0.75])
model_output = np.asarray([0.2, 0.5])
expected = (((0.3 ** 2) + (0.25 ** 2)) / 2)
actual = mse(model_input, model_output)
assert np.isclose(actual, expected)
actual = np.square(np.subtract(model_input, model_output)).mean(axis=0)
assert n... |
class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
... |
class TerminalGraphics(Graphics):
def __init__(self):
self.stdscr = curses.initscr()
curses.start_color()
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
self.bottom_row = 0
def wait(self):
self.stdscr.addstr((self.bottom_row + 2), 0, 'Press any key...')
... |
def parse_einsum_input(args, shapes=False, tuples=False, constants=None):
if (not isinstance(args[0], str)):
(eq, arrays) = convert_from_interleaved(args)
else:
(eq, *arrays) = args
if shapes:
if (constants is not None):
_shapes = tuple(((ar.shape(s) if (i in constants) e... |
class GNMTGlobalScorer(object):
def __init__(self, alpha, beta, cov_penalty, length_penalty):
self.alpha = alpha
self.beta = beta
penalty_builder = penalties.PenaltyBuilder(cov_penalty, length_penalty)
self.cov_penalty = penalty_builder.coverage_penalty()
self.length_penalty ... |
def set_seed(seed):
random.seed(seed)
np.random.seed(seed)
tf.compat.v1.set_random_seed(seed)
try:
os.environ['PYTHONHASHSEED'] = str(seed)
except:
pass |
def get_config_updates(updates):
config_updates = {}
named_configs = []
if (not updates):
return (config_updates, named_configs)
for upd in updates:
if (upd == ''):
continue
(path, sep, value) = upd.partition('=')
if (sep == '='):
path = path.strip... |
class OptimizationParams(ParamGroup):
def __init__(self, parser):
self.dataloader = False
coefficient = 4
self.coarse_iterations = 0
self.position_lr_init = (0.00016 * coefficient)
self.position_lr_final = (1.6e-06 * coefficient)
self.position_lr_delay_mult = 0.01
... |
def get_driving_stereo_images(base_path, start_sample=0):
left_images = glob.glob(f'{base_path}/left/*.png')
left_images.sort()
right_images = glob.glob(f'{base_path}/right/*.png')
right_images.sort()
depth_images = glob.glob(f'{base_path}/depth/*.png')
depth_images.sort()
return (left_image... |
def run():
logging_GOCD.init_logging(log_file_path=param_log_file_path, log_file_mode=param_log_mode)
logging.info('Preparing before training.')
sys.path.append('..')
from symbol_farm import symbol_10_320_20L_5scales_v2 as net
(net_symbol, data_names, label_names) = net.get_net_symbol()
net_init... |
def create_model(bert_config, is_training, input_ids, input_mask, segment_ids, labels, num_labels, use_one_hot_embeddings):
model = modeling.BertModel(config=bert_config, is_training=is_training, input_ids=input_ids, input_mask=input_mask, token_type_ids=segment_ids, use_one_hot_embeddings=use_one_hot_embeddings)
... |
def _interpolate(img, class_info, magnitude):
m = float_parameter(magnitude, 1)
x = img
p = class_info['weights']
if (len(p) < 1):
return (img, [])
k = max(1, int((len(class_info['pool']) * 0.05)))
idxs = np.random.choice(len(class_info['pool']), k, p=p)
distances = cosine((class_inf... |
class QConv2d(nn.Conv2d):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, num_bits=8, num_bits_weight=8, num_bits_grad=None, perC=True, biprecision=False, measure=False, cal_qparams=False):
super(QConv2d, self).__init__(in_channels, out_channe... |
def convert_all_sentencepiece_models(model_list=None, repo_path=None):
save_dir = Path('marian_ckpt')
dest_dir = Path('marian_converted')
dest_dir.mkdir(exist_ok=True)
if (model_list is None):
model_list: list = make_registry(repo_path=repo_path)
for (k, prepro, download, test_set_url) in tq... |
def _mean_update(vals, m_vals, t):
outputs = []
if (not isinstance(vals, list)):
vals = [vals]
if (not isinstance(m_vals, list)):
m_vals = [m_vals]
for (val, m_val) in zip(vals, m_vals):
output = (((t / float((t + 1))) * m_val) + ((1 / float((t + 1))) * val))
outputs.appe... |
_criterion('nat_seq_loss')
class SeqCriterion(LabelSmoothedDualImitationCriterion):
def add_args(parser):
parser.add_argument('--label-smoothing', default=0.0, type=float, metavar='D', help='epsilon for label smoothing, 0 means no label smoothing')
parser.add_argument('--use-ngram', action='store_tr... |
def convolutional_model_simple(input_shape=(NUM_FRAMES, 64, 1), batch_size=(BATCH_SIZE * TRIPLET_PER_BATCH), num_frames=NUM_FRAMES):
def conv_and_res_block(inp, filters, stage):
conv_name = 'conv{}-s'.format(filters)
o = Conv2D(filters, kernel_size=5, strides=2, padding='same', kernel_initializer='g... |
def get_history(episode_stats, reward_function):
jerk_history = episode_stats['jerk_history']
state_history = episode_stats['state_history']
control_history = episode_stats['control_history']
crashed = episode_stats['crashed']
merged = episode_stats['merged']
episode_history = []
episode_len... |
class TFRecordsConverter(object):
def __init__(self, midi_path, output_dir, num_shards_train=3, num_shards_test=1):
self.output_dir = output_dir
self.num_shards_train = num_shards_train
self.num_shards_test = num_shards_test
if (not os.path.exists(self.output_dir)):
os.ma... |
def reverse_transform(inp):
inp = inp.numpy().transpose((1, 2, 0))
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
inp = ((std * inp) + mean)
inp = np.clip(inp, 0, 1)
inp = (inp * 255).astype(np.uint8)
return inp |
def test_dict():
cfg_dict = dict(item1=[1, 2], item2=dict(a=0), item3=True, item4='test')
for filename in ['a.py', 'b.json', 'c.yaml']:
cfg_file = osp.join(data_path, 'config', filename)
cfg = Config.fromfile(cfg_file)
assert (len(cfg) == 4)
assert (set(cfg.keys()) == set(cfg_dic... |
class TimeSeriesTransformerPreTrainedModel(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class TestChainInterDataset(Dataset):
def __init__(self, triples, test_ans, test_ans_hard, nentity, nrelation, mode):
self.len = len(triples)
self.triples = triples
self.nentity = nentity
self.nrelation = nrelation
self.mode = mode
self.test_ans = test_ans
sel... |
class RandomDirectionEmitter():
def __init__(self, mutation_power, population_size, feature_map):
self.population_size = population_size
self.sigma = mutation_power
self.individuals_disbatched = 0
self.individuals_evaluated = 0
self.parents = []
self.population = []
... |
def keep_doc_examples_only(content: str) -> str:
splits = content.split('```')
content = (('```' + '```'.join(splits[1::2])) + '```')
lines_to_keep = []
for line in content.split('\n'):
line = re.sub('#.*$', '', line)
if ((len(line) != 0) and (not line.isspace())):
lines_to_k... |
class RobotMock():
def __init__(self, *args, **kwargs):
self.camera = CameraMock()
self.base = BaseMock() |
class TomOrangesState(AbstractState):
def __init__(self, world):
self.predicates = []
self.world = world
self.grasped_name = None
self.grasped_state = None
self.grasped = False
self.orange_is_good = None |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.