code stringlengths 101 5.91M |
|---|
def is_atoms_in_same_ring(i, j, ssr):
for s in ssr:
if ((i in s) and (j in s)):
return True
return False |
def get_versions():
cfg = get_config()
verbose = cfg.verbose
try:
return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose)
except NotThisMethod:
pass
try:
root = os.path.realpath(__file__)
for _ in cfg.versionfile_source.split('/'):
root ... |
class ComplementationModulationModule(nn.Module):
def __init__(self, c_img=3, norm='batch', act_en='leaky_relu', act_de='relu', cnum=64):
super().__init__()
c_in = c_img
self.en_1_1 = nn.Conv2d(c_in, cnum, 3, 1, padding=1)
self.en_2_1 = EncodeBlock(cnum, (cnum * 2), normalization=nor... |
def build_model(column_info, hidden_units=[100, 50, 25]):
wide_base_input_layers = []
wide_base_layers = []
for i in range(len(column_info.wide_base_cols)):
wide_base_input_layers.append(tf.keras.layers.Input(shape=[], dtype='int32'))
wide_base_layers.append(tf.keras.backend.one_hot(wide_bas... |
class FlaxDiffusionPipeline(ConfigMixin, PushToHubMixin):
config_name = 'model_index.json'
def register_modules(self, **kwargs):
from diffusers import pipelines
for (name, module) in kwargs.items():
if (module is None):
register_dict = {name: (None, None)}
... |
def run(config):
print('making fragments from RGBD sequence.')
make_clean_folder(join(config['path_dataset'], config['folder_fragment']))
[color_files, depth_files] = get_rgbd_file_lists(config['path_dataset'])
n_files = len(color_files)
n_fragments = int(math.ceil((float(n_files) / config['n_frames... |
class ASPResBlock(torch.nn.Module):
def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
super(ASPResBlock, self).__init__()
self.h = h
self.convs1 = nn.ModuleList([weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0], padding=get_padding(kernel_size, di... |
def main():
parser = argparse.ArgumentParser(description='Tool to average the params of input checkpoints to produce a new checkpoint')
parser.add_argument('--inputs', required=True, nargs='+', help='Input checkpoint file paths.')
parser.add_argument('--output', required=True, metavar='FILE', help='Write th... |
def AddBLstmLayer(config_lines, name, input, cell_dim, recurrent_projection_dim=0, non_recurrent_projection_dim=0, clipping_threshold=1.0, zeroing_threshold=3.0, zeroing_interval=20, ng_per_element_scale_options='', ng_affine_options='', lstm_delay=[(- 1), 1], self_repair_scale_nonlinearity=None, max_change_per_compone... |
class ContrastiveLoss(nn.Module):
def __init__(self, margin=0):
super(ContrastiveLoss, self).__init__()
self.margin = margin
self.ranking_loss = nn.MarginRankingLoss(margin=margin)
def forward(self, inputs, targets):
n = inputs.size(0)
dist = torch.pow(inputs, 2).sum(dim=... |
def _generate_subtokens(token_counts, alphabet, min_count, num_iterations=4, reserved_tokens=None):
if (reserved_tokens is None):
reserved_tokens = RESERVED_TOKENS
subtoken_list = (reserved_tokens + list(alphabet))
max_subtoken_length = 1
for i in xrange(num_iterations):
tf.compat.v1.log... |
def main():
parser = argparse.ArgumentParser(description='PyTorch Transformer Language Model')
parser.add_argument('--model_name', type=str, default='transfo-xl-wt103', help='pretrained model name')
parser.add_argument('--split', type=str, default='test', choices=['all', 'valid', 'test'], help='which split ... |
def generate_cpp_module(fname='pau_cuda.cpp', coefficients=coefficients):
file_content = airspeed.Template('\n\\#include <torch/extension.h>\n\\#include <vector>\n\\#include <iostream>\n\n#define CHECK_CUDA(x) AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor")\n#define CHECK_CONTIGUOUS(x) AT_ASSERTM(x.is_c... |
def cli_main():
parser = options.get_eval_lm_parser()
args = options.parse_args_and_arch(parser)
distributed_utils.call_main(args, main) |
def create_atoms(mol):
atoms = [a.GetSymbol() for a in mol.GetAtoms()]
for a in mol.GetAromaticAtoms():
i = a.GetIdx()
atoms[i] = (atoms[i], 'aromatic')
atoms = [atom_dict[a] for a in atoms]
return np.array(atoms) |
class TestAutoResetWrapper():
def fake_auto_reset_environment(self, fake_environment: Environment) -> AutoResetWrapper:
return AutoResetWrapper(fake_environment)
def fake_state_and_timestep(self, fake_auto_reset_environment: AutoResetWrapper, key: chex.PRNGKey) -> Tuple[(State, TimeStep[Observation])]:
... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--source-dir', required=True, type=Path, help='source audio directory')
parser.add_argument('--target-dir', required=True, type=Path, help='target audio directory')
parser.add_argument('--data-split', default=['train', 'valid', 'test'],... |
def sparse_tensor(indices, values, shape):
return torch.sparse_coo_tensor(list(zip(*indices)), values, shape, requires_grad=True) |
def create_feedforward_Q_function(observation_shape, action_shape, *args, observation_preprocessor=None, name='feedforward_Q', **kwargs):
input_shapes = (observation_shape, action_shape)
preprocessors = (observation_preprocessor, None)
return feedforward_model(input_shapes, *args, output_size=1, preprocesso... |
class StableDropoutTestCase(TestCase):
('torch 2.0.0 gives `torch.onnx.errors.OnnxExporterError: Module onnx is not installed!`.')
_torch
.filterwarnings('ignore:.*Dropout.*:UserWarning:torch.onnx.*')
def test_training(self):
devnull = open(os.devnull, 'wb')
sd = modeling_deberta.StableD... |
def groups(stream, size):
batch = []
for item in stream:
batch += [item]
if ((len(batch) % size) == 0):
(yield batch)
batch = []
if (len(batch) > 0):
(yield batch) |
def pa(X, Y):
XY = np.dot(X, Y.T)
XX = np.sum(np.square(X), axis=1)
XX = np.transpose([XX])
YY = np.sum(np.square(Y), axis=1)
dist = ((XX + YY) - (2 * XY))
return dist |
class NormalTanhPolicy(nn.Module):
hidden_dims: Sequence[int]
action_dim: int
state_dependent_std: bool = True
dropout_rate: Optional[float] = None
log_std_scale: float = 1.0
log_std_min: Optional[float] = None
log_std_max: Optional[float] = None
tanh_squash_distribution: bool = True
... |
def read_bleu_output():
params = [('all-cat', 93), ('old-cat', 48), ('new-cat', 44)]
for team in teams:
for param in params:
filelines = []
out = ''
for block_id in range(1, (param[1] + 1)):
with open((((((('eval/metric_per_block/bleu3ref-' + team) + '... |
()
('--input-path', '-i')
('--start-predictions-path', '-s')
('--model-path', '-m')
('--output-path', '-o')
('--batch-size', '-bs', default=16)
('--device', '-dv', default='cpu')
def main(input_path: str, start_predictions_path: str, model_path: str, output_path: str, batch_size: int, device: str) -> None:
logger =... |
def dict_deep_overlay(*data, list_replace=False):
if (len(data) == 1):
return data[0]
elif (len(data) != 2):
head = dict_deep_overlay(data[0], data[1], list_replace=list_replace)
return dict_deep_overlay(head, *data[2:], list_replace=list_replace)
(original, overlay) = data
if (i... |
def _define_hparam(hparams, hparam_name, default_val, random_val_fn):
hparams[hparam_name] = (hparams, hparam_name, default_val, random_val_fn) |
def _get_component_dropout(dropout_schedule, data_fraction):
if (data_fraction == 0):
assert (dropout_schedule[(- 1)][0] == 0)
return dropout_schedule[(- 1)][1]
try:
(dropout_schedule_index, initial_data_fraction, initial_dropout) = next(((i, tup[0], tup[1]) for (i, tup) in enumerate(dro... |
class KeyphraseDataset(torch.utils.data.Dataset):
def __init__(self, examples, word2idx, idx2word, device, load_train=True, fix_kp_num_len=False, max_kp_len=6, max_kp_num=20, seperate_pre_ab=False):
keys = ['src', 'src_oov', 'oov_dict', 'oov_list', 'src_str', 'trg_str', 'trg', 'trg_copy']
filtered_e... |
def format_train():
qrels = defaultdict(set)
f = open(os.path.join(input_dir, f'train_candidates.txt'))
f.readline()
for line in f:
(qid, ansid, _) = line.split(',')
qrels[qid].add(ansid)
f = open(os.path.join(input_dir, f'question.csv'))
f.readline()
with open(os.path.join(o... |
def test_experiment_run_access_subingredient():
somemod = Ingredient('somemod')
def cfg():
a = 5
b = 'foo'
ex = Experiment('some_experiment', ingredients=[somemod])
def main(somemod):
return somemod
r = ex.run().result
assert (r['a'] == 5)
assert (r['b'] == 'foo') |
class ExperimentTemplate():
def __init__(self, *, function, log_dir, name, prefix, snapshot_mode, snapshot_gap, archive_launch_repo, name_parameters, use_existing_dir):
self.function = function
self.log_dir = log_dir
self.name = name
self.prefix = prefix
self.snapshot_mode = ... |
def test():
current_file = os.path.dirname(__file__)
print('Picasso has been successfully imported!')
print(('Version: ' + open(os.path.join(current_file, './VERSION')).read().strip())) |
def get_model_parallel_src_rank():
global_rank = torch.distributed.get_rank()
local_world_size = get_model_parallel_world_size()
return ((global_rank // local_world_size) * local_world_size) |
class MoverScoreMetric(Metric):
def __init__(self, version=2, stop_wordsf=os.path.join(dirname, 'examples/stopwords.txt'), n_gram=1, remove_subwords=True, batch_size=48):
self.version = version
if (self.version == 1):
from moverscore import get_idf_dict, word_mover_score
else:
... |
class GPyGP(BaseModel):
def __init__(self, num_cont, num_enum, num_out, **conf):
super().__init__(num_cont, num_enum, num_out, **conf)
total_dim = num_cont
if (num_enum > 0):
self.one_hot = OneHotTransform(self.conf['num_uniqs'])
total_dim += self.one_hot.num_out
... |
def patch_embed_forward(self, x):
x = self.proj(x)
if self.flatten:
x = x.flatten(2).transpose(1, 2)
x = self.norm(x)
return x |
def load_model(model, checkpoint, args, mode='exact', train_mode='finetune', verbose=True, DEBUG=False):
n_gpu = args.n_gpu
device = args.device
local_rank = (- 1)
if (checkpoint in [None, 'None']):
if verbose:
logger.info(('no checkpoint provided for %s!' % model._get_name()))
e... |
class SpatialBatchNormalization(Layer):
def __init__(self, n_output, eps=1e-05, momentum=0.1, affine=True, init_weight=None, init_bias=None, init_grad_weight=None, init_grad_bias=None, data_format='NCHW', bigdl_type='float'):
super(SpatialBatchNormalization, self).__init__(None, bigdl_type, n_output, eps, m... |
class Conf(object):
def __init__(self, cfg_fname):
assert (cfg_fname is not None)
self.usr_cfg = DotDict(self._read_cfg(cfg_fname))
def _read_cfg(self, cfg_fname):
try:
with open(cfg_fname, 'r') as f:
content = f.read()
cfg = yaml.safe_load(con... |
def test_from_spark_xshards(orca_context_fixture):
(ray_xshards, ndarray_dict) = get_ray_xshards()
data_parts = ray_xshards.collect()
verify_collect_results(data_parts, ndarray_dict) |
def get_plot_color(ind, ncolors=10):
colorlist = [hsv_to_rgb((h, 1, 0.7)) for h in jnp.linspace(0, 0.8, ncolors)]
return colorlist[(ind % ncolors)] |
def main(args):
try:
(opts, args) = getopt.getopt(args, '', ['sleep-for-animation=', ''])
except getopt.GetoptError as err:
print(str(err))
sys.exit(2)
sleep_for_animation = True
for (o, a) in opts:
if (o in '--sleep-for-animation'):
sleep_for_animation = str2... |
_model
def vit_tiny_r_s16_p8_224(pretrained=False, **kwargs):
backbone = _resnetv2(layers=(), **kwargs)
model_kwargs = dict(patch_size=8, embed_dim=192, depth=12, num_heads=3, **kwargs)
model = _create_vision_transformer_hybrid('vit_tiny_r_s16_p8_224', backbone=backbone, pretrained=pretrained, **model_kwarg... |
def get_stories(f, only_supporting=False):
with open(f) as f:
return parse_stories(f.readlines(), only_supporting=only_supporting) |
class RayTuneReporter(Callback):
def on_epoch_end(self, epoch: int, logs: Optional[Dict]=None, metric: Optional[float]=None):
report_dict = {}
for (k, v) in self.trainer.history.items():
report_dict.update({k: v[(- 1)]})
if hasattr(self.trainer, 'lr_history'):
for (k,... |
def predict(model, data):
return features.predict_voted(exsettings, model, data, loader=load_sample, method=exsettings['voting'], overlap=exsettings['voting_overlap']) |
class CLIPScore(nn.Module):
def __init__(self, clipscore_w=2.5, image_size=224, mode='clip_s', use_grammar=False, joint_out=False):
super(CLIPScore, self).__init__()
self.clip_model = CLIPModel.from_pretrained('openai/clip-vit-base-patch32')
self.tokenizer = CLIPTokenizer.from_pretrained('op... |
class CosineAnnealingWarmUpRestarts(lr_scheduler._LRScheduler):
def __init__(self, optimizer, T_0, T_mult=1, eta_max=0.1, T_warmup=10000, gamma=1.0, last_epoch=(- 1)):
self.T_0 = T_0
self.T_mult = T_mult
self.eta_max = eta_max
self.T_warmup = T_warmup
self.gamma = gamma
... |
class AttnBasicBlock(nn.Module):
expansion: int = 1
def __init__(self, inplanes: int, planes: int, stride: int=1, downsample: Optional[nn.Module]=None, groups: int=1, base_width: int=64, dilation: int=1, norm_layer: Optional[Callable[(..., nn.Module)]]=None, attention: bool=True) -> None:
super(AttnBasi... |
def test_cuda_rng_tracker(model_parallel_size):
if (torch.distributed.get_rank() == 0):
print('> testing cuda rng tracker with size {} ...'.format(model_parallel_size))
mpu.initialize_model_parallel(model_parallel_size)
model_parallel_size = mpu.get_model_parallel_world_size()
seed_1 = 1234
... |
def _do_python_eval(json_dataset, salt, output_dir='output'):
info = voc_info(json_dataset)
year = info['year']
anno_path = info['anno_path']
image_set_path = info['image_set_path']
devkit_path = info['devkit_path']
cachedir = os.path.join(devkit_path, 'annotations_cache')
aps = []
use_0... |
def test_set(capture, doc):
s = m.get_set()
assert isinstance(s, set)
assert (s == {'key1', 'key2', 'key3'})
s.add('key4')
with capture:
m.print_anyset(s)
assert (capture.unordered == '\n key: key1\n key: key2\n key: key3\n key: key4\n ')
m.set_add(s, '... |
class TerminalOutput(Widget):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.out_put = widgets.Output(layout={'border': '1px solid black', 'min_width': '300px', 'min_height': '300px', 'max_height': '600px', 'width': 'auto', 'height': 'auto', 'overflow': 'scroll'})
self.title =... |
def train(train_loader, device, net, criterion, optimizer):
psnr_iter_train = []
loss_iter_train = []
ssim_iter_train = []
args.temperature = 1.0
for (idx_iter, (data, label)) in tqdm(enumerate(train_loader), total=len(train_loader), ncols=70):
data = data.to(device)
label = label.to... |
def construct_path(proj_root: str, exp_name: str, xlsx_name: str) -> dict:
ckpt_path = os.path.join(proj_root, 'output')
pth_log_path = os.path.join(ckpt_path, exp_name)
tb_path = os.path.join(pth_log_path, 'tb')
save_path = os.path.join(pth_log_path, 'pre')
pth_path = os.path.join(pth_log_path, 'pt... |
def rvad(speechproc, path):
(winlen, ovrlen, pre_coef, nfilter, nftt) = (0.025, 0.01, 0.97, 20, 512)
ftThres = 0.5
vadThres = 0.4
opts = 1
(data, fs) = sf.read(path)
assert (fs == 16000), 'sample rate must be 16khz'
(ft, flen, fsh10, nfr10) = speechproc.sflux(data, fs, winlen, ovrlen, nftt)
... |
def initialise_halo_sim():
M_pos = 1.0
M_neg = (- 3.0)
a_scale = 1.0
gauss_vel_comp = 0.3
cube_neg_width = 200
sim_name = 'halo'
return (M_pos, M_neg, a_scale, gauss_vel_comp, cube_neg_width, sim_name) |
_model('s2t_transformer')
class S2TTransformerModel(FairseqEncoderDecoderModel):
def __init__(self, encoder, decoder):
super().__init__(encoder, decoder)
def add_args(parser):
parser.add_argument('--conv-kernel-sizes', type=str, metavar='N', help='kernel sizes of Conv1d subsampling layers')
... |
def get_parser():
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--source-lang', default=None, metavar='SRC', help='source language')
parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET', help='target language')
parser.add_argument('--trainpref', metavar='FP', default... |
def register_point_cloud_pair(ply_file_names, s, t, transformation_init, config):
print(('reading %s ...' % ply_file_names[s]))
source = o3d.io.read_point_cloud(ply_file_names[s])
print(('reading %s ...' % ply_file_names[t]))
target = o3d.io.read_point_cloud(ply_file_names[t])
(transformation, infor... |
_HEADS_REGISTRY.register()
class TextHead(nn.Module):
def __init__(self, cfg, input_shape: Dict[(str, ShapeSpec)]):
super(TextHead, self).__init__()
pooler_resolution = cfg.MODEL.BATEXT.POOLER_RESOLUTION
pooler_scales = cfg.MODEL.BATEXT.POOLER_SCALES
sampling_ratio = cfg.MODEL.BATEXT... |
class TestDatasets(unittest.TestCase):
def testListDataset(self):
h = [0, 1, 2]
d = dataset.ListDataset(elem_list=h, load=(lambda x: x))
self.assertEqual(len(d), 3)
self.assertEqual(d[0], 0)
t = torch.LongTensor([0, 1, 2])
d = dataset.ListDataset(elem_list=t, load=(la... |
def scanLineForExceptionHandling(line):
global options
if ((not options.haveExceptionHandling) and exception_re.search(line)):
if (not options.noExceptionHandling):
options.haveExceptionHandling = 1 |
class LayerNorm(nn.Module):
def __init__(self, features, center=True, scale=False, eps=1e-06):
super().__init__()
self.center = center
self.scale = scale
self.eps = eps
if self.scale:
self.scale_param = nn.Parameter(torch.ones(features))
else:
... |
def label_prop(C, nt, Dct, lp='linear'):
Dct = abs(Dct)
model = pulp.LpProblem('Cost minimising problem', pulp.LpMinimize)
Mcj = pulp.LpVariable.dicts('Probability', ((i, j) for i in range(C) for j in range(nt)), lowBound=0, upBound=1, cat='Continuous')
model += pulp.lpSum([(Dct[(j, i)] * Mcj[(i, j)]) f... |
def main():
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--dir', default='/tmp/data', metavar='N', help='the folder store mnist data')
parser.add_argument('--batch-size', type=int, default=256, metavar='N', help='input batch size for training per executor(defaul... |
class ResNet9(Base):
def __init__(self, in_channels, num_classes):
super().__init__()
self.prep = conv_bn_relu_pool(in_channels, 64)
self.layer1_head = conv_bn_relu_pool(64, 128, pool=True)
self.layer1_residual = nn.Sequential(conv_bn_relu_pool(128, 128), conv_bn_relu_pool(128, 128))... |
_builder('msvd_qa')
class MSVDQABuilder(VideoQABuilder):
DATASET_CONFIG_DICT = {'default': 'configs/datasets/msvd/defaults_qa.yaml'} |
def check_service_status(port_lst, service_address):
count = 0
msg = 'Neural Solution is running.'
for port in port_lst:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((service_address, port))
sock.send(serialize({'ping': 'test'}))
... |
def create_dataloaders(args):
ds_kwargs = {'streaming': True}
train_data = load_dataset(args.dataset_name_train, split='train', **ds_kwargs)
train_data = train_data.shuffle(buffer_size=args.shuffle_buffer, seed=args.seed)
valid_data = load_dataset(args.dataset_name_valid, split='train', **ds_kwargs)
... |
def resnet110_svhn(num_classes=10, **kwargs):
return get_resnet_cifar(num_classes=num_classes, blocks=110, bottleneck=False, model_name='resnet110_svhn', **kwargs) |
class ONNX(MXNet):
def __init__(self, graph_optimization_level=None, precisions=None):
super().__init__(precisions)
self._graph_optimization_level = graph_optimization_level
def graph_optimization_level(self):
return self._graph_optimization_level
_optimization_level.setter
def g... |
def _parse_fail(name, var_type, value, values):
raise ValueError(("Could not parse hparam '%s' of type '%s' with value '%s' in %s" % (name, var_type.__name__, value, values))) |
def batch_norm_for_conv3d(inputs, is_training, bn_decay, scope):
return batch_norm_template(inputs, is_training, scope, [0, 1, 2, 3], bn_decay) |
def expand_span(span):
if (',' in span):
spans = span.split(',')
new_span = []
for sp in spans:
if ('..' in sp):
(off1, off2) = sp.split('..')
off1 = int(off1.split('_')[(- 1)])
off2 = int(off2.split('_')[(- 1)])
r =... |
class If(Node):
def __init__(self, children):
super().__init__('if', children, None)
def qasm(self, prec=15):
return ((((('if(' + self.children[0].qasm(prec)) + '==') + str(self.children[1].value)) + ') ') + self.children[2].qasm(prec)) |
def plot_basics(data, data_inst, fig, units):
from powerlaw import plot_pdf, Fit, pdf
annotate_coord = ((- 0.4), 0.95)
ax1 = fig.add_subplot(n_graphs, n_data, data_inst)
(x, y) = pdf(data, linear_bins=True)
ind = (y > 0)
y = y[ind]
x = x[:(- 1)]
x = x[ind]
ax1.scatter(x, y, color='r'... |
def getBlas():
file_ = open('npConfg_file.txt', 'w')
with contextlib.redirect_stdout(file_):
numpy.show_config()
file_.close()
np_confg = open('npConfg_file.txt', 'r')
lib = ''
for line in np_confg:
if ('libraries' in line):
lib = line
break
np_confg.c... |
def check_na(df, column):
n = df.shape[0]
num_of_na = df[column].isna().sum()
frac_of_na = int((100.0 * (num_of_na / n)))
print((((((('# of NA values ' + column) + ': ') + str(num_of_na)) + ', ') + str(frac_of_na)) + '%'))
print(df[df[column].isna()].head()) |
def main():
args = parse_args()
if ('SLURM_NNODES' in os.environ):
slurm(args)
else:
distributed(args) |
def update_new_configs(ckpt_opts, new_opts):
for (k, v) in new_opts.items():
if (k not in ckpt_opts):
ckpt_opts[k] = v
if new_opts['update_param_list']:
for param in new_opts['update_param_list']:
ckpt_opts[param] = new_opts[param] |
def train(agent, train_result, config):
for day in train_days:
environment = init_env(day, config)
train_a_day(environment, agent, train_result) |
class BaseDataModule(LightningDataModule, ABC):
def __init__(self, datadir: str, train: Optional[DictConfig]=None, val: Optional[DictConfig]=None, test: Optional[DictConfig]=None) -> None:
super().__init__()
self.datadir = Path(datadir)
train = self._validate_train_config(train)
val ... |
def resnet_v1_152(inputs, num_classes=None, is_training=True, global_pool=True, output_stride=None, reuse=None, scope='resnet_v1_152'):
blocks = [resnet_utils.Block('block1', bottleneck, (([(256, 64, 1)] * 2) + [(256, 64, 2)])), resnet_utils.Block('block2', bottleneck, (([(512, 128, 1)] * 7) + [(512, 128, 2)])), re... |
def tiny_resnet18(pretrained: bool=False, class_num=10, progress: bool=True) -> ResNet:
res18 = tiny_ResNet(BasicBlock, [2, 2, 2, 2], class_num=class_num)
res18.bn1 = nn.GroupNorm(num_groups=32, num_channels=64)
res18.layer1[0].bn1 = nn.GroupNorm(num_groups=32, num_channels=64)
res18.layer1[0].bn2 = nn.... |
def generate_pattern(state, rule, MAX_TIME):
for time in range(MAX_TIME):
print(state)
patterns = window(state)
state = ''.join((rule[pat] for pat in patterns))
state = '0{}0'.format(state)
print(state) |
class ActionPredictor():
def __init__(self):
pass
def predict(self, state: State, actions) -> dict:
raise NotImplementedError |
def get_norm(name, out_channels):
if (name == 'batch'):
norm = nn.BatchNorm2d(out_channels)
elif (name == 'instance'):
norm = nn.InstanceNorm2d(out_channels)
else:
norm = None
return norm |
class TestOptions(BaseOptions):
def initialize(self):
BaseOptions.initialize(self)
self.parser.add_argument('--eval_id', type=str, help='evaluation id')
self.parser.add_argument('--eval_results_dir', type=str, default=None, help='dir to save results, if not set, fall back to training results... |
def _get_empty_running_paths_dict():
return dict(observations=[], actions=[], rewards=[], env_infos=[], agent_infos=[]) |
def convert_json_to_pkl_local(root, _data_name):
convert_json_file_to_pkl_dump(path=(root + '/2merge-{}'.format(_data_name)), txt_fname='test', part=_data_name)
print('Test done. Training start.')
convert_json_file_to_pkl_dump(path=(root + '/2merge-{}'.format(_data_name)), txt_fname='train', part=_data_name... |
def find_path(map, start, end, alg=AStarFinder):
grid = Grid(matrix=map)
g_start = grid.node(*start)
g_end = grid.node(*end)
finder = alg()
(path, runs) = finder.find_path(g_start, g_end, grid)
return path |
class Possessive_Rate(object):
def __init__(self, sentence_objs):
self.sentence_objs = sentence_objs
def handle(self):
(tot_num_adjs, tot_num_pron, tot_num_words) = (0, 0, 0)
for so in self.sentence_objs:
tot_num_adjs += so.pos_tag_counter.get_pos_tag_count(ADJECTIVE)
... |
def empty_param(mod, prefix_name='', ignore_save=False):
for name in mod._parameters:
if (mod._parameters[name] is not None):
param_cls = type(mod._parameters[name])
param_kwargs = mod._parameters[name].__dict__
if (not hasattr(mod._parameters[name], 'checkpoint_name')):
... |
class XLMRobertaForTokenClassification():
def __init__(self, *args, **kwargs):
requires_pytorch(self)
def from_pretrained(self, *args, **kwargs):
requires_pytorch(self) |
_module()
class IterBasedRunnerAmp(IterBasedRunner):
def save_checkpoint(self, out_dir, filename_tmpl='iter_{}.pth', meta=None, save_optimizer=True, create_symlink=False):
if (meta is None):
meta = dict(iter=(self.iter + 1), epoch=(self.epoch + 1))
elif isinstance(meta, dict):
... |
class LLaMABot():
def __init__(self, device, model_path: str=None, peft_model: str=None, quantization: bool=False, max_new_tokens=256, min_new_tokens: int=0, seed: int=None, do_sample: bool=True, use_cache: bool=True, top_p: float=1.0, temperature: float=1.0, top_k: int=50, repetition_penalty: float=1.0, length_pen... |
class SubsampleGroup(nn.Module):
def __init__(self, num_groups=256, group_size=32, subsample='fps', group='ballquery', radius=0.1, **kwargs):
super().__init__()
self.num_groups = num_groups
self.group_size = group_size
self.subsample = subsample
self.group = group
if ... |
def main():
args = parse_args()
assert (args.out or args.eval or args.format_only or args.show or args.show_dir), 'Please specify at least one operation (save/eval/format/show the results / save the results) with the argument "--out", "--eval", "--format-only", "--show" or "--show-dir"'
if (args.eval and ar... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.