code stringlengths 101 5.91M |
|---|
class igEnv():
def __init__(self, args):
self.args = args
self.config_filename = self.args.ig_config
self.env = iGibsonEnv(config_file=self.config_filename, mode=self.args.ig_render_mode)
p.resetBasePositionAndOrientation(self.env.robots[0].robot_ids[0], [(- 0.75), (- 0.4), 1.1], qua... |
def imtext(image, text, space=(3, 3), color=(0, 0, 0), thickness=1, fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=1.0):
assert isinstance(text, str), type(text)
size = cv2.getTextSize(text, fontFace, fontScale, thickness)
image = cv2.putText(image, text, (space[0], (size[1] + space[1])), fontFace, fontScale,... |
def get_policy_class(config: TrainerConfigDict) -> Optional[Type[Policy]]:
if (config['framework'] == 'torch'):
return NFSPTorchAveragePolicy
else:
raise NotImplementedError(f"NFSP average policy for framework: {config['framework']} not implemented.") |
def load_scene_flow_disp(img_path):
assert img_path.endswith('.pfm'), 'scene flow disparity image must end with .pfmbut got {}'.format(img_path)
(disp_img, __) = load_pfm(img_path)
return disp_img |
class ConfigManager(ConfigBase):
def __init__(self, *args):
super().__init__(config, *args) |
def act(flags, gym_env, actor_index: int, free_queue: mp.SimpleQueue, full_queue: mp.SimpleQueue, buffers: Buffers, actor_buffers: Buffers, actor_model_queues: List[mp.SimpleQueue], actor_env_queues: List[mp.SimpleQueue]):
try:
logging.info('Actor %i started.', actor_index)
timings = prof.Timings()
... |
def load_vocab(vocab_file):
unit2idx = {}
with open(os.path.join(vocab_file), 'r', encoding='utf-8') as v:
for line in v:
(unit, idx) = line.strip().split()
unit2idx[unit] = int(idx)
return unit2idx |
class Likelihood(FunctionWrapper):
def __add__(self, other):
assert isinstance(other, Likelihood)
if isinstance(other, SumLikelihood):
if isinstance(self, SumLikelihood):
new_f = self.copy()
new_f.operands = (self.operands + other.operands)
... |
def get_iterations_required(xs, c=4.3):
num_iters = (xs + (c * (xs ** (1.0 / 3))))
num_iters = (num_iters.astype(int) + 2)
return num_iters |
def build_dbsampler(cfg, logger=None):
logger = logging.getLogger('build_dbsampler')
prepors = [build_db_preprocess(c, logger=logger) for c in cfg.db_prep_steps]
db_prepor = DataBasePreprocessor(prepors)
rate = cfg.rate
grot_range = cfg.global_random_rotation_range_per_object
groups = cfg.sample... |
_model
def resnet101d(pretrained=False, **kwargs):
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True, **kwargs)
return _create_resnet('resnet101d', pretrained, **model_args) |
class ThreadServerTrainer(AbstractTrainer):
def __init__(self, name, env_kwargs, model_kwargs, **kwargs):
super().__init__(env_kwargs=env_kwargs, model_kwargs=model_kwargs, **kwargs)
self.name = name
self._report_queue = Queue(maxsize=16)
self._shared_global_t = Value('i', 0)
... |
def progress_bar(iterator, log_format: Optional[str]=None, log_interval: int=100, log_file: Optional[str]=None, epoch: Optional[int]=None, prefix: Optional[str]=None, aim_repo: Optional[str]=None, aim_run_hash: Optional[str]=None, aim_param_checkpoint_dir: Optional[str]=None, tensorboard_logdir: Optional[str]=None, def... |
def _get_interpolate_attributes(g, mode, args):
if (mode == 'nearest'):
align_corners = None
scales = args[0:]
else:
align_corners = args[0]
scales = args[1:]
scales = _interpolate_get_scales_if_available(g, scales)
return (scales, align_corners) |
class TestAlgo(unittest.TestCase):
cfg = config_factory('detection_cvpr_2019')
def _mock_results(nsamples, ngt, npred, detection_name):
def random_attr():
rel_attributes = detection_name_to_rel_attributes(detection_name)
if (len(rel_attributes) == 0):
return ''
... |
def mkdir(path):
path = path.strip()
path = path.rstrip('\\')
isExists = os.path.exists(path)
if (not isExists):
os.makedirs(path)
return True
else:
return False |
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
if (args.work_dir is not None):
cfg.work_dir = args.work_dir
if (args.resume_from is not None):
cfg.resume_from = args.resume_from
... |
class GeneralHead3D(nn.Module, ABC):
def __init__(self, feature_dims=2048, dropout_rate=0.0, num_classes=1000):
super(GeneralHead3D, self).__init__()
self.pool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.dropout = nn.Dropout(p=dropout_rate)
self.fc = nn.Linear(feature_dims, num_classes)
... |
def build_deptree_features(df):
with timer('Extracting deptree features'):
deptree = get_deptree_features(df)
columns = ['A_off', 'B_off', 'P_off', 'A_sent', 'B_sent', 'P_sent', 'A_rank', 'B_rank', 'P_rank']
deptree_df = pd.DataFrame(deptree, columns=columns)
return deptree_df |
def reporthook(count, block_size, total_size):
global start_time
if (count == 0):
start_time = time.time()
return
duration = (time.time() - start_time)
progress_size = int((count * block_size))
speed = int((progress_size / (1024 * duration)))
percent = int((((count * block_size) ... |
def resnet_arg_scope(weight_decay=0.0001, batch_norm_decay=0.997, batch_norm_epsilon=1e-05, batch_norm_scale=True, activation_fn=tf.nn.relu, use_batch_norm=True):
batch_norm_params = {'decay': batch_norm_decay, 'epsilon': batch_norm_epsilon, 'scale': batch_norm_scale, 'updates_collections': tf.GraphKeys.UPDATE_OPS}... |
class ModelArguments():
model_name_or_path: str = field(metadata={'help': 'Path to dense encoder'})
MCQ_M: int = field(metadata={'help': 'Number of sub-vectors per text.'})
similarity_metric: str = field(default=None, metadata={'help': 'If None, use the original value.', 'choices': ['METRIC_CENTROID_COS', '... |
class _PointnetSAModuleBase(nn.Module):
def __init__(self):
super().__init__()
self.npoint = None
self.groupers = None
self.mlps = None
self.pool_method = 'max_pool'
def forward(self, xyz: torch.Tensor, features: torch.Tensor=None, new_xyz=None) -> (torch.Tensor, torch.Te... |
def example_generator(data_path, single_pass):
while True:
filelist = glob.glob(data_path)
assert filelist, ('Error: Empty filelist at %s' % data_path)
if single_pass:
filelist = sorted(filelist)
else:
random.shuffle(filelist)
for f in filelist:
... |
(signature, parallel=False, cache=True, nogil=False)
def weighted_average_C(config, weights, q):
B = config.shape[0]
N = config.shape[1]
out = np.zeros((N, q), dtype=curr_float)
for b in prange(B):
for n in prange(N):
out[(n, config[(b, n)])] += weights[b]
out /= weights.sum()
... |
def _create_wr_eet(filename, port, fps, user):
w = _writer()
w.open(filename)
w.put(_create_header(port, user))
w.put(hl2ss._create_configuration_for_eet(fps))
return w |
def initialize_logging(experiment, scaffolding):
if (experiment.logger is None):
root_logger = create_basic_stream_logger()
else:
root_logger = experiment.logger
for (sc_path, scaffold) in scaffolding.items():
if sc_path:
scaffold.logger = root_logger.getChild(sc_path)
... |
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--report-to', type=str, default=None, help='Where to report the results, you can choose e.g., WANDB')
parser.add_argument('-e', '--epochs', type=int, default=4, help='Number of epochs of fine-tuning/training')
parser.add_argument(... |
def sample_discretized_normal(mean, logvar, inverse_bin_width):
y = torch.randn_like(mean)
x = ((torch.exp((0.5 * logvar)) * y) + mean)
x = (torch.round((x * inverse_bin_width)) / inverse_bin_width)
return x |
_registry(pattern_type='Transformer2Dmodel_EncoderHiddenStatesReshape')
class Transformer2Dmodel_EncoderHiddenStatesReshape(Pattern):
def __call__(self, model):
pattern_mapping_config = {'Transformer2Dmodel_EncoderHiddenStatesReshape': [{'patterns': {'in': [[(0, 'Input'), (1, 'MatMulWithBias')]]}}, {'patter... |
def write_file(filename: str, data: torch.Tensor) -> None:
torch.ops.image.write_file(filename, data) |
def load_tf_weights_in_mobilenet_v2(*args, **kwargs):
requires_backends(load_tf_weights_in_mobilenet_v2, ['torch']) |
def ProcessFile(filename, vlevel, extra_check_functions=[]):
_SetVerboseLevel(vlevel)
try:
if (filename == '-'):
lines = codecs.StreamReaderWriter(sys.stdin, codecs.getreader('utf8'), codecs.getwriter('utf8'), 'replace').read().split('\n')
else:
lines = codecs.open(filena... |
_task(name='EQA-v0')
class EQATask(NavigationTask):
def _check_episode_is_active(self, *args, action, episode, action_args=None, **kwargs) -> bool:
return (self.is_valid and (self.answer is None)) |
def update_perf_log(epoch_perf, perf_log_path):
now = time.strftime('%c')
line = 't: {}, '.format(now)
for key in epoch_perf:
line += '{}: {}, '.format(key, epoch_perf[key])
line += '\n'
with open(perf_log_path, 'a') as file:
file.write(line) |
class BenchmarkConfig():
def __init__(self, inputs=[], outputs=[], backend='default', device='cpu', warmup=5, iteration=(- 1), model_name='', cores_per_instance=None, num_of_instance=1, inter_num_of_threads=None, intra_num_of_threads=None, diagnosis=False, ni_workload_name='profiling'):
self.inputs = inputs... |
class FlaxRobertaModel():
def __init__(self, *args, **kwargs):
requires_flax(self)
def from_pretrained(self, *args, **kwargs):
requires_flax(self) |
class JTensor(object):
def __init__(self, storage, shape, bigdl_type='float', indices=None):
if (isinstance(storage, bytes) and isinstance(shape, bytes)):
self.storage = np.frombuffer(storage, dtype=get_dtype(bigdl_type))
self.shape = np.frombuffer(shape, dtype=np.int32)
else... |
def weight_constrain(loss1, mal_loss1, agent_model, constrain_weights, t):
args = gv.args
loss2 = tf.constant(0.0)
layer_count = 0
if (('dist_oth' in args.mal_strat) and (t < 1)):
rho = 0.0
else:
rho = 0.0001
for layer in agent_model.layers:
counter = 0
for weight... |
def compute_mAPs(truth: dict, pred: dict, tolerances: list[int]=[0, 1, 2, 4]):
assert ({v['video'] for v in truth} == {v['video'] for v in pred}), 'Video set mismatch!'
truth_by_label = parse_ground_truth(truth)
(fig, axes) = (None, None)
class_aps_for_tol = []
mAPs = []
for (i, tol) in enumerat... |
def singular_locus_set():
syst = jacobian(3, 2)
for pol in syst:
print(pol)
(embsyst, embsols) = witset(syst, False)
print('the polynomials in the witness set :')
for pol in embsyst:
print(pol)
input('hit enter to continue')
print('the solutions :')
for sol in embsols:
... |
def text_pruning(text, ref):
new_text = []
for i in range(len(text)):
if ((not text[i]) or (text[i] == '.')):
continue
try:
cur_score = rouge(text[i], ref)
except:
print(text[i])
if (cur_score > test_pruning_thresh):
new_text.append... |
class Root(nn.Module):
def __init__(self, cfg, in_channels, out_channels, kernel_size, residual):
super(Root, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, bias=False, padding=((kernel_size - 1) // 2))
self.bn = get_norm(cfg.MODEL.DLA.NORM, out_chan... |
class ConvNet(Backbone):
def __init__(self, c_hidden=64):
super().__init__()
self.conv1 = Convolution(3, c_hidden)
self.conv2 = Convolution(c_hidden, c_hidden)
self.conv3 = Convolution(c_hidden, c_hidden)
self.conv4 = Convolution(c_hidden, c_hidden)
self._out_features... |
def standard_newton_power_series(pols, lser, idx=1, maxdeg=4, nbr=4, checkin=True, verbose=True):
from phcpy.solver import number_of_symbols
from phcpy.interface import store_standard_system, load_standard_system
from phcpy.phcpy2c3 import py2c_standard_Newton_power_series as newton
from phcpy.phcpy2c3 ... |
def compute_metrics(p: EvalPrediction):
return metric.compute(predictions=p.predictions, references=p.label_ids) |
def _add_categories_metadata(dataset_name: str, categories: List[Dict[(str, Any)]]):
meta = MetadataCatalog.get(dataset_name)
meta.categories = {c['id']: c['name'] for c in categories}
logger = logging.getLogger(__name__)
logger.info('Dataset {} categories: {}'.format(dataset_name, meta.categories)) |
def load_df_wbm_with_preds(models: Sequence[str]=(*PRED_FILES,), pbar: bool=True, id_col: str=default_id_col, **kwargs: Any) -> pd.DataFrame:
if (mismatch := ', '.join((set(models) - set(PRED_FILES)))):
raise ValueError(f'Unknown models: {mismatch}, expected subset of {set(PRED_FILES)}')
dfs: dict[(str,... |
def get_bilateral_grid(input, r_sigma, s_sigma):
x = Var('x')
y = Var('y')
z = Var('z')
c = Var('c')
xi = Var('xi')
yi = Var('yi')
zi = Var('zi')
clamped = Func('clamped')
clamped[(x, y)] = input[(clamp(x, 0, (input.width() - 1)), clamp(y, 0, (input.height() - 1)))]
r = RDom(0, s... |
class CamembertForQuestionAnswering(metaclass=DummyObject):
_backends = ['torch']
def __init__(self, *args, **kwargs):
requires_backends(self, ['torch']) |
class LoopPad(object):
def __init__(self, max_len):
self.max_len = max_len
def __call__(self, tensor):
length = tensor.size(0)
if (length == self.max_len):
return tensor
n_pad = (self.max_len - length)
pad = ([tensor] * (n_pad // length))
if ((n_pad % ... |
def test_revert_sync_batchnorm():
conv_syncbn = ConvModule(3, 8, 2, norm_cfg=dict(type='SyncBN')).to('cpu')
conv_syncbn.train()
x = torch.randn(1, 3, 10, 10)
with pytest.raises(ValueError):
y = conv_syncbn(x)
conv_bn = revert_sync_batchnorm(conv_syncbn)
y = conv_bn(x)
assert (y.shape... |
class SynPASS13Segmentation(SegmentationDataset):
NUM_CLASS = 13
def __init__(self, root='datasets/SynPASS', split='val', mode=None, transform=None, weather='all', **kwargs):
super(SynPASS13Segmentation, self).__init__(root, split, mode, transform, **kwargs)
assert os.path.exists(self.root), 'Pl... |
def load_training_config(config_name: str) -> TrainingConfig:
with hydra.initialize_config_module(config_module='tbv.training_configs'):
cfg = hydra.compose(config_name=config_name)
config: TrainingConfig = instantiate(cfg.TrainingConfig)
return config |
def test_cast_as_tensor_check_wrong():
assert_raises(AssertionError, _test_cast, True, torch.int64, 0)
assert_raises(AssertionError, _test_cast, True, torch.bool, 1)
assert_raises(AssertionError, _test_cast, 1, torch.int32, 0)
assert_raises(AssertionError, _test_cast, 1, torch.int64, 1)
assert_raise... |
class GlobalNode(Module):
def __init__(self):
super().__init__()
att_mask = Linear(config.emb_size, 1)
att_feat = Sequential(Linear(config.emb_size, config.emb_size), LeakyReLU())
self.glob = GlobalAttention(att_mask, att_feat)
self.tranform = Sequential(Linear((config.emb_si... |
def data_parallel(batch_group: List[TensorDict], model: Model, cuda_devices: List) -> Dict[(str, torch.Tensor)]:
assert (len(batch_group) <= len(cuda_devices))
moved = [nn_util.move_to_device(batch, device) for (batch, device) in zip(batch_group, cuda_devices)]
used_device_ids = cuda_devices[:len(moved)]
... |
def train(cfg, observer):
model = get_model(cfg.mode)(cfg)
if (cfg.mode == 'geom'):
if (cfg.flow_pretrained_model and (not cfg.resume)):
data = torch.load(cfg.flow_pretrained_model)['model_state_dict']
(missing_keys, unexp_keys) = model.load_state_dict(data, strict=False)
... |
class GolemTrainer():
_logger = logging.getLogger(__name__)
def __init__(self, learning_rate=0.001):
self.learning_rate = learning_rate
def train(self, model, X, num_iter, checkpoint_iter=None, output_dir=None):
model.sess.run(tf.compat.v1.global_variables_initializer())
self._logger... |
def load_syn(dataset_dir, split='train'):
data_dir = osp.join(dataset_dir, SYN[split])
n_max = (25000 if (split == 'train') else 9000)
return read_image_list(data_dir, n_max=n_max) |
class XnliProcessor(DataProcessor):
def __init__(self, language, train_language=None):
self.language = language
self.train_language = train_language
def get_train_examples(self, data_dir):
lg = (self.language if (self.train_language is None) else self.train_language)
lines = self... |
def run():
parser = argparse.ArgumentParser()
parser.add_argument('--data_root', type=str)
parser.add_argument('--mask_root', type=str)
parser.add_argument('--model_save_path', type=str, default='checkpoint')
parser.add_argument('--result_save_path', type=str, default='results')
parser.add_argum... |
class FlaxViTForImageClassification(metaclass=DummyObject):
_backends = ['flax']
def __init__(self, *args, **kwargs):
requires_backends(self, ['flax']) |
def write_e2e_src(prompt_lst, corr_path):
with open(corr_path, 'w') as f:
for x in prompt_lst:
print(x, file=f)
return |
def with_progress(collection, length=None, title=None, pbar=NoProgressBar()):
if (length is None):
length = len(collection)
if (title is not None):
pbar.set_title(title)
pbar.start(length)
for elem in collection:
(yield elem)
pbar.update() |
def _flatten_to_tuple(outputs):
result = []
if isinstance(outputs, torch.Tensor):
result.append(outputs)
elif isinstance(outputs, (list, tuple)):
for v in outputs:
result.extend(_flatten_to_tuple(v))
elif isinstance(outputs, dict):
for (_, v) in outputs.items():
... |
class ToyDataset(Dataset):
def __init__(self, size):
self.size = size
def __len__(self):
return self.size
def __getitem__(self, idx):
return (torch.ones((4, 8)), torch.zeros((4, 8))) |
class CorefDataset(Dataset):
def __init__(self, input_data, tokenizer, model_name_or_path, max_seq_length=(- 1)):
self.tokenizer = tokenizer
(examples, self.max_mention_num, self.max_cluster_size, self.max_num_clusters, dockey2eems_tokenspan, dockey2pems_tokenspan) = self._parse_jsonlines(input_data... |
class SemiSupervisedSampler(torch.utils.data.Sampler):
def __init__(self, sup_inds, unsup_inds, batch_size, unsup_fraction=0.5, num_batches=None):
if ((unsup_fraction is None) or (unsup_fraction < 0)):
self.sup_inds = (sup_inds + unsup_inds)
unsup_fraction = 0.0
else:
... |
def func_mod(in_file, list_param):
with open(in_file) as f:
data = f.read()
data = data.split('\n')
dict_param = {}
for i in data:
tmp = i.split()
if (len(tmp) > 0):
for i in list_param:
if (i == tmp[0]):
dict_param[i] = tmp[1]
... |
def _Graph_fromMOLStringMulti(s: str, options: MDLOptions=MDLOptions(), add: bool=True) -> List[Graph]:
return _graphsLoad(_Graph_fromMOLStringMulti_orig(s, options), add) |
def resample_bounding_box(metadata, transform):
for (idx, transfo) in enumerate(transform.transform['im'].transforms):
if ('Resample' == transfo.__class__.__name__):
(hspace, wspace, dspace) = (transfo.hspace, transfo.wspace, transfo.dspace)
hfactor = (metadata[MetadataKW.INPUT_METAD... |
def get_peft_state_maybe_zero_3(state_dict, bias):
if (bias == 'none'):
to_return = {k: state_dict[k].cpu().clone().detach() for k in state_dict if ('lora_' in k)}
elif (bias == 'all'):
to_return = {k: state_dict[k] for k in state_dict if (('lora_' in k) or ('bias' in k))}
elif (bias == 'lor... |
def resnet50(num_classes=1000, pretrained='imagenet'):
model = models.resnet50(pretrained=False)
if (pretrained is not None):
settings = pretrained_settings['resnet50'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model |
class TrainerBase(object):
def __init__(self, args, train_loader=None, val_loader=None, test_loader=None, train=True):
self.args = args
self.train_loader = train_loader
self.val_loader = val_loader
self.test_loader = test_loader
self.verbose = True
if self.args.distri... |
def tiny_oshi_zumo_nfsp_avg_policy_params(env: MultiAgentEnv) -> Dict[(str, Any)]:
return {'framework': 'torch', 'num_gpus': float(os.getenv('WORKER_GPU_NUM', 0.0)), 'num_workers': 0, 'num_gpus_per_worker': float(os.getenv('WORKER_GPU_NUM', 0.0)), 'num_envs_per_worker': 1, 'learning_starts': 16000, 'train_batch_siz... |
def make_atom14_masks_np(batch: Dict[(str, torch.Tensor)]) -> Dict[(str, np.ndarray)]:
batch = tree_map((lambda n: torch.tensor(n, device=batch['aatype'].device)), batch, np.ndarray)
out = tensor_tree_map((lambda t: np.array(t)), make_atom14_masks(batch))
return out |
class BrainReporter(StatsReporter):
def __init__(self, job_meta: JobMeta) -> None:
self._job_meta = job_meta
self._brain_client = GlobalBrainClient.BRAIN_CLIENT
def report_dataset_metric(self, dataset: DatasetMetric):
self._brain_client.report_training_set_metric(self._job_meta, dataset)... |
def make_sup_data_loaders(path, batch_size, num_workers, transform_train, transform_test, use_validation=True, val_size=5000, shuffle_train=True, dataset='cifar10'):
if (dataset == 'notmnist'):
test_set = torchvision.datasets.ImageFolder(root=path, transform=transform_test)
test_loader = torch.utils... |
def logging(s, log_path, print_=True, log_=True):
if print_:
print(s, flush=True)
if log_:
with open(log_path, 'a+') as f_log:
f_log.write((s + '\n')) |
class TFConvBertForMaskedLM(metaclass=DummyObject):
_backends = ['tf']
def __init__(self, *args, **kwargs):
requires_backends(self, ['tf']) |
def test_shapely_polygon_intersection1():
poly1 = np.array([[0, 0], [3, 0], [3, 3], [0, 3]])
poly2 = np.array([[2, 1], [5, 1], [5, 4], [2, 4]])
inter_area = shapely_polygon_intersection(poly1, poly2)
assert (inter_area == 2)
assert (shapely_polygon_area(poly1) == 9)
assert (shapely_polygon_area(... |
def load_data(dest_dir='/tmp/.zoo/dataset', nb_words=None, oov_char=2, test_split=0.2):
path = download_reuters(dest_dir)
with open(path, 'rb') as f:
(x, y) = cPickle.load(f)
shuffle_by_seed([x, y])
if (not nb_words):
nb_words = max([max(s) for s in x])
if (oov_char is not None):
... |
def old_resnet101(pretrained=False, **kwargs):
model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
return model |
class XnliProcessor(DataProcessor):
'Processor for the XNLI dataset.\n Adapted from
def __init__(self, language, train_language=None):
self.language = language
self.train_language = train_language
def get_train_examples(self, data_dir):
lg = (self.language if (self.train_language... |
def init_weights(net, init_type='kaiming', scale=1, std=0.02):
logger.info('Initialization method [{:s}]'.format(init_type))
if (init_type == 'normal'):
weights_init_normal_ = functools.partial(weights_init_normal, std=std)
net.apply(weights_init_normal_)
elif (init_type == 'kaiming'):
... |
class EuroSATDataModule(pl.LightningDataModule):
def __init__(self, data_root, train_batch_size, test_batch_size, num_workers, scale_lower_bound, jitter_prob, greyscale_prob, solarize_prob, **kwargs):
super().__init__()
self.data_root = data_root
self.train_batch_size = train_batch_size
... |
def simxGetDialogInput(clientID, dialogHandle, operationMode):
inputText = ct.POINTER(ct.c_char)()
ret = c_GetDialogInput(clientID, dialogHandle, ct.byref(inputText), operationMode)
a = bytearray()
if (ret == 0):
i = 0
while (inputText[i] != b'\x00'):
if (sys.version_info[0] ... |
class SimpleRecurrentSurrogate(nn.Module):
def __init__(self, num_hidden=100, number_input_feats=3, size_ebedding=100):
super(SimpleRecurrentSurrogate, self).__init__()
self.num_hidden = num_hidden
self.embedding = nn.Sequential(nn.Linear(number_input_feats, size_ebedding), nn.Sigmoid())
... |
_config
def model_lifelong_sidetune_double_open_fcn5s_taskonomy():
cfg = {'learner': {'model': 'LifelongSidetuneNetwork', 'model_kwargs': {'base_class': 'FCN5', 'base_weights_path': '/mnt/models/curvature_encoder_student.dat', 'base_kwargs': {'eval_only': False, 'train': True, 'normalize_outputs': False}, 'use_bake... |
def setup_logger(name, save_dir, if_train):
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler(stream=sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
ch.setFormatter(formatter)
log... |
def execute():
path = '/mnt/data/datasets/patents/patent_matching'
positives = pd.read_csv((path + '/positives_satellite.csv'), header=0, dtype={'application_claim_text': str, 'patent_searchReport_paragraph': str})
negatives = pd.read_csv((path + '/negatives_satellite.csv'), header=0, dtype={'application_cl... |
def build_dataloader(dataset, vocab, batch_size, max_decode, is_train, num_workers):
shuffle = (True if is_train else False)
data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, collate_fn=(lambda data, v=vocab, t=max_decode: Batch(data=data, vocab=v, max_decode=t)), num_workers=num_workers... |
def cents_to_bins(cents, quantize_fn=torch.floor):
bins = quantize_fn((cents / penn.CENTS_PER_BIN)).long()
bins[(bins < 0)] = 0
bins[(bins >= penn.PITCH_BINS)] = (penn.PITCH_BINS - 1)
return bins |
def _concat_dataset(cfg, default_args=None):
ann_files = cfg['ann_file']
img_prefixes = cfg.get('img_prefix', None)
seg_prefixes = cfg.get('seg_prefix', None)
proposal_files = cfg.get('proposal_file', None)
datasets = []
num_dset = len(ann_files)
for i in range(num_dset):
data_cfg = ... |
def raw_transform(box: Box, R: Array) -> Array:
if (jnp.isscalar(box) or (box.size == 1)):
return (R * box)
elif (box.ndim == 1):
indices = (_get_free_indices((R.ndim - 1)) + 'i')
return jnp.einsum(f'i,{indices}->{indices}', box, R)
elif (box.ndim == 2):
free_indices = _get_f... |
def save_checkpoint_modified(state, epoch, output_directory, is_best=True, curr_step=None):
if (not os.path.exists(output_directory)):
os.makedirs(output_directory)
checkpoint_filename = os.path.join(output_directory, (((('checkpoint-' + str(epoch)) + '_') + str(curr_step)) + '.pth.tar'))
torch.save... |
def test_double_syspool(vrblvl=0):
initialize_double_syspool(3, vrblvl)
dim = size_double_syspool(vrblvl)
print('The size of the systems pool :', dim)
pol1 = ['t - 1;']
set_double_system(1, pol1, vrblvl)
copy_to_double_syspool(1)
pol2 = ['t - 2;']
set_double_system(1, pol2, vrblvl)
c... |
def data_split_evaluator(opt):
if (opt.dataset == 'imagenet_bboxes'):
model = build_model(opt)
model = torch.nn.DataParallel(model)
if (opt.model_type == ModelType.DROPOUT_FN_OF_XSTAR):
model = load_pretrained_dlupi_model(model, opt)
if (opt.model_type == ModelType.EVAL_D... |
class ErnieConfig(PretrainedConfig):
model_type = 'ernie'
def __init__(self, vocab_size=30522, 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_position_embeddings=512, type_vocab_size=2, task... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.