code stringlengths 101 5.91M |
|---|
class Generator(abc.ABC):
def __init__(self, cube_size: int):
if (cube_size < 2):
raise ValueError(f'Cannot meaningfully construct a cube smaller than 2x2x2, but received cube_size={cube_size}')
self.cube_size = cube_size
def generate_cube(self, key: chex.PRNGKey) -> Cube:
def __... |
def wide_resnet50_2(in_channels=3, pretrained=False, progress=True, **kwargs):
kwargs['width_per_group'] = (64 * 2)
return _resnet(in_channels, 'wide_resnet50_2', Bottleneck, [3, 4, 6, 3], pretrained, progress, **kwargs) |
class ResNet18_torch(nn.Module):
def __init__(self, pretrained=False, device=None):
super().__init__()
self.resnet = models.resnet18(pretrained=pretrained)
num_ftrs = self.resnet.fc.in_features
self.resnet.fc = nn.Linear(num_ftrs, 10)
self.resnet.conv1 = torch.nn.Conv2d(3, 64... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model_path', type=str, default='experiments/pretrained_models/BasicVSR_REDS4.pth')
parser.add_argument('--input_path', type=str, default='datasets/REDS4/sharp_bicubic/000', help='input test image folder')
parser.add_argument('--save_p... |
def nnsmith_and(left, right):
if (isinstance(left, bool) and isinstance(right, bool)):
return (left and right)
return z3.And(left, right) |
def supervised_finetuning(encoder, episode, device='cpu', proto_init=True, freeze_backbone=False, finetune_batch_norm=False, inner_lr=0.001, total_epoch=15, n_way=5):
x_support = episode['train'][0][0]
x_support = x_support.to(device)
x_support_var = Variable(x_support)
x_query = episode['test'][0][0]
... |
def load_transformer_encoder(bert_model, layer_index, checkpoint_path):
bert_model.transformer_layers[layer_index].multihead_attention.qkv.set_weights([np.concatenate([tf.train.load_variable(checkpoint_path, f'bert/encoder/layer_{layer_index}/attention/self/query/kernel'), tf.train.load_variable(checkpoint_path, f'... |
def hm(inputs, inputs_norm, indexes, features, features_norm, momentum=0.5):
return HM.apply(inputs, inputs_norm, indexes, features, features_norm, torch.Tensor([momentum]).to(inputs.device)) |
class CacheDataset():
def __init__(self, filename, dataset):
self.filename = filename
self.dataset = dataset
self.save_filename = dataset.return_filename
(self.original_shape, self.__size) = self.__set_ImageHeader_and_get_item_size()
if (not self.__use_existing_cache()):
... |
_model('model_parallel_transformer_lm')
class ModelParallelTransformerLanguageModel(TransformerLanguageModel):
def build_model(cls, args, task):
if (not has_megatron_submodule):
raise ImportError('\n\nPlease install the megatron submodule:\n\n git submodule update --init fairseq/model_parallel/... |
def squeezeresnet_v1_1(**kwargs):
return get_squeezenet(version='1.1', residual=True, model_name='squeezeresnet_v1_1', **kwargs) |
def test_osipkovmerritt_hernquist_dens_massprofile():
pot = potential.HernquistPotential(amp=2.3, a=1.3)
ras = [0.3, 2.3, 5.7]
for ra in ras:
dfh = osipkovmerrittHernquistdf(pot=pot, ra=ra)
numpy.random.seed(10)
samp = dfh.sample(n=100000)
tol = (5 * 0.001)
check_sphe... |
def load_and_cache_examples(args, task, tokenizer, evaluate=False):
if ((args.local_rank not in [(- 1), 0]) and (not evaluate)):
torch.distributed.barrier()
processor = processors[task](task=task, train_suffix=args.train_suffix, test_suffix=args.test_suffix)
output_mode = output_modes[task]
trai... |
def parse_training_args(args=None, ignore_unknown=False):
arg_populate_funcs = [training_args, custom_mlp_args]
arg_check_funcs = [process_training_args]
return parse_various_args(args, arg_populate_funcs, arg_check_funcs, ignore_unknown) |
def _create_inception_v3(variant, pretrained=False, **kwargs):
default_cfg = default_cfgs[variant]
aux_logits = kwargs.pop('aux_logits', False)
if aux_logits:
assert (not kwargs.pop('features_only', False))
model_cls = InceptionV3Aux
load_strict = default_cfg['has_aux']
else:
... |
def compare_mtcnn(pt_mdl, tf_fun, sess, ind, test_data):
tf_mdls = tf_fun(sess)
tf_mdl = tf_mdls[ind]
print('\nPassing test data through TF model\n')
tf_output = tf_mdl(test_data.numpy())
tf_output = [torch.tensor(out) for out in tf_output]
print('\n'.join([str(o.view((- 1))[:10]) for o in tf_ou... |
_model
def resmlp_12_distilled_224(pretrained=False, **kwargs):
model_args = dict(patch_size=16, num_blocks=12, embed_dim=384, mlp_ratio=4, block_layer=ResBlock, norm_layer=Affine, **kwargs)
model = _create_mixer('resmlp_12_distilled_224', pretrained=pretrained, **model_args)
return model |
def sample_generator(dataset, tokenizer):
sample_ordering = np.random.permutation(len(dataset))
for sample_idx in sample_ordering:
example = dataset[int(sample_idx)]
example = {key: tf.convert_to_tensor(arr, dtype_hint=tf.int64) for (key, arr) in example.items()}
(yield (example, example... |
class NestingState(object):
def __init__(self):
self.stack = []
self.previous_stack_top = []
self.pp_stack = []
def SeenOpenBrace(self):
return ((not self.stack) or self.stack[(- 1)].seen_open_brace)
def InNamespaceBody(self):
return (self.stack and isinstance(self.st... |
class WarmupExpLR(WarmupLR):
def __init__(self, optimizer, gamma, interval=1, warmup_iter=500, warmup_ratio=0.0005, warmup='exp', last_epoch=(- 1)) -> None:
self.gamma = gamma
self.interval = interval
super().__init__(optimizer, warmup_iter, warmup_ratio, warmup, last_epoch)
def get_main... |
def q_to_mtx_tf(q):
r0 = tf.stack([((1.0 - (2.0 * (q[1] ** 2))) - (2.0 * (q[2] ** 2))), (((2.0 * q[0]) * q[1]) - ((2.0 * q[2]) * q[3])), (((2.0 * q[0]) * q[2]) + ((2.0 * q[1]) * q[3]))])
r1 = tf.stack([(((2.0 * q[0]) * q[1]) + ((2.0 * q[2]) * q[3])), ((1.0 - (2.0 * (q[0] ** 2))) - (2.0 * (q[2] ** 2))), (((2.0 *... |
def convert_examples_to_features(examples, tokenizer, max_seq1_length=256, max_seq2_length=128, verbose=True):
features = []
iter = (tqdm(examples, desc='Converting Examples') if verbose else examples)
for (ex_index, example) in enumerate(iter):
encoded_outputs = {'guid': example.guid, 'label': exam... |
def get_sinc_impulse(sample_rate, duration):
n = np.arange(((- duration) / 2), (duration / 2), (1 / sample_rate))
samples = ((2 * 0.25) * np.sinc((((2 * sample_rate) / 4) * n)))
return samples.astype(np.float32) |
class Framework():
def __init__(self, Scheduler, Recovery, ContainerLimit, IntervalTime, hostinit, database, env, logger):
self.hostlimit = len(hostinit)
self.scheduler = Scheduler
self.scheduler.setEnvironment(self)
self.recovery = Recovery
self.recovery.setEnvironment(self)... |
class CacheFlowWorker():
def __init__(self, controller_addr, worker_addr, worker_id, no_register, model_path, model_name, block_size, seed, swap_space, max_num_batched_tokens, distributed_init_method, all_stage_devices):
self.controller_addr = controller_addr
self.worker_addr = worker_addr
s... |
def main():
parser = argparse.ArgumentParser(description='Convert YOLO cfg to Caffe prototxt')
parser.add_argument('cfg', type=str, help='YOLO cfg')
parser.add_argument('prototxt', type=str, help='Caffe prototxt')
parser.add_argument('--approx', help='flag whether to approximate leaky relu or not (for T... |
def train(train_loader, model, criterion, optimizer, epoch, args, log, tf_writer):
batch_time = AverageMeter('Time', ':6.3f')
data_time = AverageMeter('Data', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
top1 = AverageMeter('', ':6.2f')
top5 = AverageMeter('', ':6.2f')
model.train()
end = ... |
def pyramidnet110_a270_svhn(num_classes=10, **kwargs):
return get_pyramidnet_cifar(num_classes=num_classes, blocks=110, alpha=270, bottleneck=False, model_name='pyramidnet110_a270_svhn', **kwargs) |
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_64_512_16L_3scales_v1_small as net
(net_symbol, data_names, label_names) = net.get_net_symbol()
ne... |
def yolo_config():
head_cfg = dict(anchor_generator=dict(type='YOLOAnchorGenerator', base_sizes=[[(116, 90), (156, 198), (373, 326)], [(30, 61), (62, 45), (59, 119)], [(10, 13), (16, 30), (33, 23)]], strides=[32, 16, 8]), bbox_coder=dict(type='YOLOBBoxCoder'))
test_cfg = mmcv.Config(dict(deploy_nms_pre=1000, mi... |
def read_annotations():
anno_df = pd.read_csv(anno_csv_path)
anno_df = anno_df[anno_df.apply((lambda row: (bool(row[VALID_LABEL]) and bool(row[VALID_REASONING]) and (len(str(row[EVIDENCE_COL_NAME])) > 0) and (row[LABEL] != 'invalid prompt'))), axis=1)]
return anno_df |
class RNN_ENCODER(nn.Module):
def __init__(self, ntoken, ninput=300, drop_prob=0.5, nhidden=128, nlayers=1, bidirectional=True):
super(RNN_ENCODER, self).__init__()
self.n_steps = 25
self.rnn_type = 'LSTM'
self.ntoken = ntoken
self.ninput = ninput
self.drop_prob = dro... |
def download_full_dataset(dataset: str, path_out: Union[(str, os.PathLike, None)]=None):
if (dataset not in ['co2', 'elec', 'raw']):
raise ValueError(f'Unsupported argument {dataset}')
fname = f'EBA_{dataset}.csv.gz'
if (path_out is None):
path_out = (gridemissions.config['DATA_PATH'] / fnam... |
def get_fresh_case_data_from_ts_rl():
log.info('fetch RL/TS/CS data from gsheets')
for attempt in (1, 2):
try:
resp = requests.get(os.environ['RL_TS_CSV_URL'], timeout=(1.0, 5.0))
resp.raise_for_status()
except Exception as err:
log.info('attempt %s: failed ge... |
def main():
parser = ArgumentParser('Transformers CLI tool', usage='transformers-cli <command> [<args>]')
commands_parser = parser.add_subparsers(help='transformers-cli command helpers')
ConvertCommand.register_subcommand(commands_parser)
DownloadCommand.register_subcommand(commands_parser)
Environm... |
class TFOPTPreTrainedModel(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def kahypar_subgraph_find_membership(inputs, output, size_dict, weight_nodes='const', weight_edges='log', fix_output_nodes=False, parts=2, imbalance=0.01, compress=0, seed=None, profile=None, mode='direct', objective='cut', quiet=True):
import kahypar as kahypar
if (seed is None):
seed = random.randint(... |
class PseGru(nn.Module):
def __init__(self, input_dim=10, mlp1=[10, 32, 64], pooling='mean_std', mlp2=[128, 128], with_extra=True, extra_size=4, hidden_dim=128, mlp4=[128, 64, 32], num_classes=20, max_temporal_shift=100, max_position=365):
super(PseGru, self).__init__()
if with_extra:
ml... |
class UnilmConfig(PretrainedConfig):
pretrained_config_archive_map = UNILM_PRETRAINED_CONFIG_ARCHIVE_MAP
def __init__(self, vocab_size=28996, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act='gelu', hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_p... |
def get_available_segmentation_models():
return [k for (k, v) in models.segmentation.__dict__.items() if (callable(v) and (k[0].lower() == k[0]) and (k[0] != '_'))] |
def get_up_block(up_block_type: str, num_layers: int, in_channels: int, out_channels: int, prev_output_channel: int, temb_channels: int, add_upsample: bool, resnet_eps: float, resnet_act_fn: str, resolution_idx: Optional[int]=None, transformer_layers_per_block: int=1, num_attention_heads: Optional[int]=None, resnet_gro... |
('mnli')
class MNLIModel(Model):
def __init__(self, vocab: Vocabulary, text_field_embedder: TextFieldEmbedder, encoder: Union[(Seq2VecEncoder, Seq2SeqEncoder)], box_factory: BoxFactory, intersection: _Intersection, volume: _Volume, premise_feedforward: FeedForward, hypothesis_feedforward: FeedForward, dropout: Opti... |
def create_oracles(dataname, path_read, path_wt_distributed):
files = [i.split('.')[0] for i in os.listdir(path_read) if i.endswith('.doc.json')]
total_num = len(files)
cnt = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processes=cnt)
pool.starmap(process_one_example, zip(([path_read] * t... |
.parametrize('device', ['cpu', 'cuda'])
def test_gaussian_encoding_no_unfreeze(device):
check_cuda(device)
b = rff.functional.sample_b(1.0, (256, 2)).to(device)
layer = rff.layers.GaussianEncoding(b=b).to(device)
layer.requires_grad = True
assert (layer.b.requires_grad != True) |
def train_printer(data, targets, epoch, counter, iter_counter, loss_hist, test_loss_hist, test_data, test_targets):
print(f'Epoch {epoch}, Iteration {iter_counter}')
print(f'Train Set Loss: {loss_hist[counter]:.2f}')
print(f'Test Set Loss: {test_loss_hist[counter]:.2f}')
print_batch_accuracy(data, targe... |
class Defects4J():
def __init__(self, d4j_home: Path, d4j_checkout_root: Path, java8_home: Path) -> None:
self.d4j_home = d4j_home
self.d4j_checkout_root = d4j_checkout_root
self.java8_home = java8_home
assert d4j_home.exists()
assert self.d4j_executable.exists()
asse... |
.skipif((digit_version(torch.__version__) < digit_version('1.6.0')), reason='torch.jit.is_tracing is not available before 1.6.0')
def test_is_jit_tracing():
def foo(x):
if is_jit_tracing():
return x
else:
return x.tolist()
x = torch.rand(3)
assert isinstance(foo(x), l... |
def build_onnx_model_with_zero_weight():
A = helper.make_tensor_value_info('A', TensorProto.FLOAT, [1, 5, 5])
C = helper.make_tensor_value_info('C', TensorProto.FLOAT, [1, 5, 2])
H = helper.make_tensor_value_info('H', TensorProto.FLOAT, [1, 5, 2])
g_value = np.zeros(25).astype(np.float32)
G_init = h... |
def load_model(model_id):
model_type = next((x for x in MODEL_CLASSES.keys() if (x in model_id.lower())), 'auto')
model_class = MODEL_CLASSES[model_type]
print('Load model via', model_class)
model = model_class[0].from_pretrained(model_id, low_cpu_mem_usage=True, torch_dtype=amp_dtype)
print('Model ... |
def parse_args():
parser = argparse.ArgumentParser(description='mmseg test (and eval) a model')
parser.add_argument('config', help='test config file path')
parser.add_argument('checkpoint', help='checkpoint file')
parser.add_argument('--work-dir', help='if specified, the evaluation metric results will b... |
_measure
class Coverage(Measure):
cls_uuid: str = 'coverage'
def __init__(self, sim, config, **kwargs: Any):
self._sim = sim
self._config = config
self._visited = None
self._mini_visited = None
self._step = None
self._reached_count = None
self._mini_reache... |
def load_checkpoint(filename, model=None, logger=None):
if logger:
logger.info(('load checkpoint from ' + filename))
statistics = torch.load(filename)
if model:
model.load_state_dict(statistics['state_dict'])
return statistics |
class MSEMeter(meter.Meter):
def __init__(self, root=False):
super(MSEMeter, self).__init__()
self.reset()
self.root = root
def reset(self):
self.n = 0
self.sesum = 0.0
def add(self, output, target):
if ((not torch.is_tensor(output)) and (not torch.is_tensor(t... |
def _test_handler(file_format, test_obj, str_checker, mode='r+'):
dump_str = mmcv.dump(test_obj, file_format=file_format)
str_checker(dump_str)
tmp_filename = osp.join(tempfile.gettempdir(), 'mmcv_test_dump')
mmcv.dump(test_obj, tmp_filename, file_format=file_format)
assert osp.isfile(tmp_filename)
... |
def preprocess(sources: Sequence[str], tokenizer: transformers.PreTrainedTokenizer) -> Dict:
if (conversation_lib.default_conversation.version == 'v1'):
return preprocess_v1(sources, tokenizer)
if (conversation_lib.default_conversation.version == 'mpt'):
return preprocess_mpt(sources, tokenizer)... |
class MagicWords(object):
names = ['!', 'currentmonth', 'currentmonth1', 'currentmonthname', 'currentmonthnamegen', 'currentmonthabbrev', 'currentday', 'currentday2', 'currentdayname', 'currentyear', 'currenttime', 'currenthour', 'localmonth', 'localmonth1', 'localmonthname', 'localmonthnamegen', 'localmonthabbrev'... |
def gen_k_centers(k, dim):
delta = abs(np.random.normal(0.0, 5.0))
eps = 0.001
centers = []
for i in range(k):
c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))
if len(centers):
c1 = centers[0]
x = (np.random.multivariate_normal(c1, np.identity(c1... |
class ptb_fs_goru_config(object):
cell = 'fs-goru'
init_scale = 0.01
learning_rate = 0.002
max_grad_norm = 1.0
num_layers = 2
num_steps = 150
cell_size = 700
hyper_size = 200
embed_size = 128
max_epoch = 200
max_max_epoch = max_epoch
keep_prob = 0.65
zoneout_h = 0.9
... |
class UAVVideo(Video):
def __init__(self, name, root, video_dir, init_rect, img_names, gt_rect, attr, load_img=False):
super(UAVVideo, self).__init__(name, root, video_dir, init_rect, img_names, gt_rect, attr, load_img) |
def _to_cpu(state):
if isinstance(state, torch.Tensor):
ret = state.cpu()
if ('Float' in state.type()):
ret = ret.half()
return ret
elif isinstance(state, list):
new_state = [_to_cpu(t) for t in state]
elif isinstance(state, tuple):
new_state = tuple((_to_... |
def convert_bdd(root_dir, ann_dir):
count = 0
for img_loc in tqdm(os.listdir((root_dir + ann_dir))):
img = imread(((root_dir + ann_dir) + img_loc))
if (img.ndim <= 1):
continue
loc = (img == 255)
img[loc] = (- 1)
loc = (img == 16)
img[loc] = 19
... |
def get_self_bleu2_arithmetic(utterances):
weights = (0.5, 0.5)
return get_self_bleu(utterances, averaging_mode='arithmetic', weights=weights) |
def test_cast_as_tensor_torch_bool_2d():
_test_cast(torch.tensor([[True, False, True], [True, True, False]]), torch.bool, 2)
_test_cast(torch.tensor([[True, True, True]]), torch.bool, 2)
_test_cast(torch.tensor([[False]]), torch.bool, 2) |
class StripTokenDataset(BaseWrapperDataset):
def __init__(self, dataset, id_to_strip):
super().__init__(dataset)
self.id_to_strip = id_to_strip
def __getitem__(self, index):
item = self.dataset[index]
while ((len(item) > 0) and (item[(- 1)] == self.id_to_strip)):
item... |
def run_watch():
command = (['python', 'train_q.py', '--steps-per-epoch', '0', '--test-length', '100000', '--nn-file', sys.argv[1], '--display-screen', '--max-history', '10', '--testing'] + sys.argv[2:])
p1 = subprocess.Popen(command)
p1.wait() |
class FocusLiteNNMinMax(nn.Module):
def __init__(self, num_channel=1):
super(FocusLiteNNMinMax, self).__init__()
self.num_channel = num_channel
self.conv = nn.Conv2d(3, self.num_channel, 7, stride=5, padding=1)
self.fc = nn.Conv2d((self.num_channel * 2), 1, 1, stride=1, padding=0)
... |
def get_rd_data_dict(pkl_path, train_path, n_aug, alpha):
if (not pkl_path.exists()):
print(f'creating {pkl_path}')
(sentences, _) = common.get_sentences_and_labels_from_txt(train_path)
sentence_to_augmented_sentences = {}
for sentence in tqdm(sentences):
rd_sentences = [... |
class RandomHorizontalFlip(object):
def __init__(self, p=0.5):
self.p = p
def __call__(self, img):
if (random.random() < self.p):
return F.hflip(img)
return img
def __repr__(self):
return (self.__class__.__name__ + '(p={})'.format(self.p)) |
_REGISTRY.register()
class CIFAR100C(CIFAR10C):
dataset_dir = ''
domains = ['cifar100', 'cifar100_c']
def __init__(self, cfg):
super().__init__(cfg) |
def parse_args():
parser = argparse.ArgumentParser(description='Convert benchmark model json to script')
parser.add_argument('txt_path', type=str, help='txt path output by benchmark_filter')
parser.add_argument('--partition', type=str, default='openmmlab', help='slurm partition name')
parser.add_argumen... |
def game_loop(args):
try:
pygame.init()
display = pygame.display.set_mode((args.width, args.height), (pygame.HWSURFACE | pygame.DOUBLEBUF))
pygame.display.set_caption(args.description)
font = pygame.font.Font(pygame.font.get_default_font(), 20)
text_surface = font.render('Ren... |
def get_abs_min_max(var, ctx):
abs_var = var.abs()
return f'{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}' |
def run_deeplab(args):
args.cuda = ((not args.no_cuda) and torch.cuda.is_available())
if args.cuda:
try:
args.gpu_ids = [int(s) for s in args.gpu_ids.split(',')]
except ValueError:
raise ValueError('Argument --gpu_ids must be a comma-separated list of integers only')
... |
class Transformer(nn.Module):
def __init__(self, num_tokens, dim, depth, heads, dim_head, attn_dropout, ff_dropout):
super().__init__()
self.embeds = nn.Embedding(num_tokens, dim)
self.layers = nn.ModuleList([])
for _ in range(depth):
self.layers.append(nn.ModuleList([Res... |
def deconv(in_planes, out_planes):
return nn.Sequential(nn.ConvTranspose2d(in_planes, out_planes, kernel_size=4, stride=2, padding=1, bias=True), nn.LeakyReLU(0.1, inplace=True)) |
def test_lazy_class_scope_resolution():
run_cell('\n class Foo:\n shared = 99\n def __init__(self, x):\n self.x = x\n ')
run_cell('foo = Foo(10)')
run_cell('y = 11')
run_cell('Foo.shared = y + 42')
run_cell('y = 12')
run_cell('logging.info(foo.s... |
def test_pretrained_resnet3d_backbone():
try:
from torch.hub import load_state_dict_from_url
except ImportError:
from torch.utils.model_zoo import load_url as load_state_dict_from_url
state_dict_2d = load_state_dict_from_url(' progress=True)
data = torch.randn(1, 3, 1, 224, 224)
mode... |
class Normalize(object):
def __init__(self, mean, std, to_bgr255=True):
self.mean = mean
self.std = std
self.to_bgr255 = to_bgr255
def __call__(self, image, target=None, rois=None):
if self.to_bgr255:
image = (image[[2, 1, 0]] * 255)
image = F.normalize(image,... |
def parse_fasta(fasta_string: str) -> Tuple[(Sequence[str], Sequence[str])]:
sequences = []
descriptions = []
index = (- 1)
for line in fasta_string.splitlines():
line = line.strip()
if line.startswith('>'):
index += 1
descriptions.append(line[1:])
seq... |
class DeviceManager():
def list_adb_device(cls):
devices = []
adb_list = sh_commands.adb_devices()
for adb in adb_list:
prop = sh_commands.adb_getprop_by_serialno(adb)
android = {YAMLKeyword.device_name: prop['ro.product.model'].replace(' ', ''), YAMLKeyword.target_ab... |
def setup_router(api_list, chatbot=None, enable_llm=True, use_deepspeed=False, world_size=1, host='0.0.0.0', port=80):
for api_name in api_list:
lower_api_name = api_name.lower()
if (lower_api_name in api_router_mapping):
api_router = api_router_mapping[lower_api_name]
if ena... |
def get_args():
parser = argparse.ArgumentParser(description='This script creates a\n position-dependent subword lexicon from a position-independent subword lexicon\n by adding suffixes ("_B", "_I", "_E", "_S") to the related phones.\n It assumes that the input lexicon does not contain disambig... |
def get_emd_average(model_id, pre_sampled=True, **kwargs):
import os
manager = get_emd_manager(model_id, pre_sampled, **kwargs)
values = None
if os.path.isfile(manager.path):
with manager.get_saving_dataset('r') as ds:
values = np.array(tuple(ds.values()))
if (values is None):
... |
_registry('AdamW', 'tensorflow')
class TensorFlowAdamW(object):
def __init__(self, param_dict):
assert isinstance(param_dict, dict), 'This optimizer constructor parameter must be a dict'
self._param_dict = param_dict
def _mapping(self):
_param_map = {'learning_rate': 'learning_rate', 'we... |
class GPRGNN(torch.nn.Module):
def __init__(self, dataset, args):
super(GPRGNN, self).__init__()
self.lin1 = Linear(dataset.num_features, args.hidden)
self.lin2 = Linear(args.hidden, dataset.num_classes)
if (args.ppnp == 'PPNP'):
self.prop1 = APPNP(args.K, args.alpha)
... |
class SetAbstraction(nn.Module):
def __init__(self, in_channels, out_channels, layers=1, stride=1, group_args={'NAME': 'ballquery', 'radius': 0.1, 'nsample': 16}, norm_args={'norm': 'bn1d'}, act_args={'act': 'relu'}, conv_args=None, sampler='fps', feature_type='dp_fj', use_res=False, is_head=False, **kwargs):
... |
_module()
class LLavaConvProcessV1(BaseConvProcessFunc):
def __call__(self, raw_conv: List[Dict[(str, Any)]], preprocessor: Dict[(str, Any)], conv_template: Conversation) -> List[Dict[(str, Any)]]:
conv_processor_cfg = preprocessor['conv']
image_token_len = conv_processor_cfg['image_token_len']
... |
def registerSceneProperties():
bpy.types.Scene.zpy_sim_name = bpy.props.StringProperty(name='Sim Name', description='Name of the scene, must match data portal.', default='default')
bpy.types.Scene.zpy_sim_version = bpy.props.StringProperty(name='Sim Version', description='Version of the scene, must match data p... |
def test_robot_warehouse_utils__calculate_num_observation_features() -> None:
sensor_range = 1
num_obs_features = calculate_num_observation_features(sensor_range)
assert (num_obs_features == 66)
sensor_range = 2
num_obs_features = calculate_num_observation_features(sensor_range)
assert (num_obs_... |
def eval_base_model_mean_rank(pred_fn, target_events):
pred_data = file_uri_reader_processor(pred_fn)
pred_target_data = []
pred_type_score = []
label_type = []
for event in target_events:
(seq_idx, original_idx) = eval(event[0])
pred_event = search_pred_data(pred_data, seq_idx, orig... |
class PlatformType(object):
KUBERNETES = 'k8s'
RAY = 'ray'
PY_KUBERNETES = 'pyk8s'
LOCAL = 'local' |
class Adam(OptimMethod, ZooKerasCreator):
def __init__(self, lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0, schedule=None, weight_decay=0.0, bigdl_type='float'):
self.value = callZooFunc(bigdl_type, ZooKerasCreator.jvm_class_constructor(self), lr, beta_1, beta_2, epsilon, decay, weight_decay,... |
def run_save_and_load(rank, world_size, pipe_config=dict(), amp_config=None, loss_func=None):
from atorch.auto.opt_lib.pipeline_parallel_optimization import PipelineParallelOptimization
pipe_config['use_c10d'] = True
init_pipe_distributed(rank, world_size)
model_context = create_model_context(loss_func=... |
def _main():
opts = _parse_main()
count = 0
goal2count = dict()
with open(opts.target_file, 'r') as f:
for l in f:
if (count > opts.limit):
print('[check_multiple_goals] LIMIT HIT')
break
if pred(l):
count += 1
... |
def simxGetStringParameter(clientID, paramIdentifier, operationMode):
paramValue = ct.POINTER(ct.c_char)()
ret = c_GetStringParameter(clientID, paramIdentifier, ct.byref(paramValue), operationMode)
a = bytearray()
if (ret == 0):
i = 0
while (paramValue[i] != b'\x00'):
if (sys... |
class SEBottleneck(Bottleneck):
def __init__(self, in_channels, out_channels, se_ratio=16, **kwargs):
super().__init__(in_channels, out_channels, **kwargs)
self.se_layer = SELayer(out_channels, ratio=se_ratio)
def forward(self, x):
def _inner_forward(x):
identity = x
... |
class ParamGroup():
def __init__(self, parser: ArgumentParser, name: str, fill_none=False):
group = parser.add_argument_group(name)
for (key, value) in vars(self).items():
shorthand = False
if key.startswith('_'):
shorthand = True
key = key[1:]... |
def learn_and_test(solver_file):
caffe.set_mode_cpu()
solver = caffe.get_solver(solver_file)
solver.solve()
accuracy = 0
test_iters = int((len(Xt) / solver.test_nets[0].blobs['data'].num))
for i in range(test_iters):
solver.test_nets[0].forward()
accuracy += solver.test_nets[0].b... |
def targets_rate(targets, num_classes, num_steps=False, first_spike_time=0, correct_rate=1, incorrect_rate=0, on_target=1, off_target=0, firing_pattern='regular', interpolate=False, epsilon=1e-07):
if ((not (0 <= correct_rate <= 1)) or (not (0 <= incorrect_rate <= 1))):
raise Exception(f'``correct_rate``{co... |
class MultiEdgeGraphFormatter(BaseGraphFormatter):
def __init__(self, config, name='MultiEdgeGraphFormatter'):
self.name = name
self.disable_tqdm = config.disable_tqdm
self.config = config
self.t3_parser = CodeTokenizer(data=[], lang='C', tlevel='t3')
BaseFormatter.__init__(s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.