code stringlengths 101 5.91M |
|---|
class DataLoader():
def __init__(self, module_name, train_bs, eval_bs, device, log):
self.module_name = module_name
split_chars = (lambda x: list(x))
source = Field(tokenize=split_chars, init_token='<sos>', eos_token='<eos>', batch_first=True)
target = Field(tokenize=split_chars, ini... |
class TestOurQueue(unittest.TestCase):
def test_simple(self):
q = OurQueue()
q.push(0)
q.push(((0.8 * 3600) * 24))
q.push(((5 * 3600) * 24))
q.push(((40 * 3600) * 24))
self.assertEqual(q.get_counters(((40 * 3600) * 24)), [4, 1, 1, 1, 1])
def test_complex(self):
... |
def download_from_google_drive(file_id, output_dir):
url = (' % file_id)
output = os.path.join(output_dir, 'tmp.tar.gz')
gdown.download(url, output, quiet=False)
file = tarfile.open(output, 'r:gz')
file.extractall(output_dir)
file.close()
os.remove(output)
target_dir = glob.glob(('%s/*' ... |
def glue_compute_metrics(task_name, preds, labels):
warnings.warn(DEPRECATION_WARNING, FutureWarning)
requires_sklearn(glue_compute_metrics)
assert (len(preds) == len(labels)), f'Predictions and labels have mismatched lengths {len(preds)} and {len(labels)}'
if (task_name == 'cola'):
return {'mcc... |
class Gowalla(BaseData):
def __init__(self, data_root: Optional[str]=None) -> None:
super().__init__('gowalla', data_root)
self._content = {'num_users': 29858, 'num_items': 40981, 'num_interactions': 1027370, 'train_adj_list': {'upon': [{'filename': 'train.txt', 'md5': '5eec1eb2edb8dd648377d348b8e13... |
def basic_blocks(dim, index, layers, pool_size=3, mlp_ratio=4.0, act_layer=nn.GELU, norm_layer=GroupNorm, drop_rate=0.0, drop_path_rate=0.0, use_layer_scale=True, layer_scale_init_value=1e-05):
blocks = []
for block_idx in range(layers[index]):
block_dpr = ((drop_path_rate * (block_idx + sum(layers[:ind... |
def slice_data(START, END):
data = load_dataset_foreign(data_name='yelp')
data_pos = data[(data['label'] == 1)].reset_index(drop=True)
data_neg = data[(data['label'] == 0)].reset_index(drop=True)
train = pd.concat([data_pos[START:END], data_neg[START:END]]).reset_index(drop=True)
return train |
('/stylize/', methods=['POST'])
def stylize():
inputs = json.loads(request.data)
session_token = inputs['session_token']
objects = inputs['objects']
object_index = inputs['object_index']
option_index = inputs['option_index']
preview = None
if ('preview' in inputs):
preview = inputs['... |
def main(args, model=None) -> FEVERClassifierModule:
Path(args.output_dir).mkdir(parents=True, exist_ok=True)
if ((len(os.listdir(args.output_dir)) > 3) and args.do_train):
raise ValueError('Output directory ({}) already exists and is not empty.'.format(args.output_dir))
if (model is None):
... |
('kitti_lmdb')
class KittiRawLMDBDataset(KittiRawDataset):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.image_dbs = {}
self.depth_dbs = {}
self.poses_dbs = {}
self.hints_dbs = {}
self.calib_dbs = {}
self.preload()
def preload... |
def test_core_count(vrblvl=0):
cores = get_core_count(vrblvl)
if (vrblvl > 0):
print('The number of available cores :', cores)
fail = int((cores <= 0))
if (vrblvl > 0):
if (fail == 0):
print('=> Test on get core count passed.')
else:
print('Test on get cor... |
def _init_weight_goog(m, n='', fix_group_fanout=True):
if isinstance(m, CondConv2d):
fan_out = ((m.kernel_size[0] * m.kernel_size[1]) * m.out_channels)
if fix_group_fanout:
fan_out //= m.groups
init_weight_fn = get_condconv_initializer((lambda w: nn.init.normal_(w, 0, math.sqrt((... |
_metric
def fid10k_full(opts):
opts.dataset_kwargs.update(max_size=None, xflip=False)
fid = frechet_inception_distance.compute_fid(opts, max_real=None, num_gen=10000)
return dict(fid10k_full=fid) |
def get_p_coupler_config(config, flattened):
return get_coupler_config('p_mu', 'p_sigma', 'p', config, flattened) |
class LLMResult():
result: typing.Any
prompt: str
answer: str
duration: float = 0
tokens_query: int = 0
tokens_response: int = 0 |
def load_image_resized(fn, sz):
return cv2.resize(imageio.imread(str(fn)), dsize=(sz, sz), interpolation=cv2.INTER_CUBIC).astype(np.float32) |
_module
class SemanticNuscDataset(Dataset):
NumPointFeatures = 5
CLASSES = 17
def __init__(self, info_path, root_path, cfg=None, pipeline=None, class_names=None, cam_names=None, cam_chan=None, cam_attributes=None, img_resized_shape=None, test_mode=False, sample=False, nsweeps=1, load_interval=1, version='v1... |
def default_collate(batch):
elem = batch[0]
elem_type = type(elem)
if isinstance(elem, torch.Tensor):
out = None
return torch.stack(batch, 0, out=out)
elif ((elem_type.__module__ == 'numpy') and (elem_type.__name__ != 'str_') and (elem_type.__name__ != 'string_')):
elem = batch[0... |
def spCNN():
filename = sys.argv[1]
config = {}
config['jobs'] = []
job1 = {}
sp_list = [0.3, 0.2, 0.1, 0.05, 0.02, 0.01, 0.007, 0.005]
channels = np.array([32, 32, 64, 64])
factor_list = [1, 2, 4]
for factor in factor_list:
for sp in sp_list:
job = {}
job... |
_model
def cspresnext50_iabn(pretrained=False, **kwargs):
norm_layer = get_norm_act_layer('iabn')
return _create_cspnet('cspresnext50_iabn', pretrained=pretrained, norm_layer=norm_layer, **kwargs) |
_model
def tv_resnet34(pretrained=False, **kwargs):
model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], **kwargs)
return _create_resnet('tv_resnet34', pretrained, **model_args) |
class SklearnDataModule(LightningDataModule):
name = 'sklearn'
def __init__(self, X, y, x_val=None, y_val=None, x_test=None, y_test=None, val_split=0.2, test_split=0.1, num_workers=0, random_state=1234, shuffle=True, batch_size: int=16, pin_memory=True, drop_last=False, *args, **kwargs) -> None:
super()... |
((not huggingface_hub), 'Requires huggingface_hub install')
class TestHuggingFaceHub(unittest.TestCase):
_grad()
def test_hf_fastspeech2(self):
hf_model_id = 'facebook/fastspeech2-en-ljspeech'
(models, cfg, task) = load_model_ensemble_and_task_from_hf_hub(hf_model_id)
self.assertTrue((le... |
def search_absorbe_tuning_bn(model, prev=None, remove_bn=True, verbose=False):
with torch.no_grad():
for m in model.children():
if (is_fake_bn(m) and is_absorbing(prev) and need_tuning(prev)):
absorb_bn(prev, m.bn, remove_bn=remove_bn, verbose=verbose)
m.forward =... |
class CLAM_MB(_CLAM_Base):
sizes = {'small': [1024, 512, 256], 'big': [1024, 512, 384], 'multiscale': [2048, 512, 256]}
def __init__(self, size: Union[(str, List[int])]='small', dropout: bool=False, k_sample: int=8, n_classes: int=2, instance_loss_fn: Optional[Callable]=None, subtyping: bool=False, gate: bool=T... |
def resnetal50(**kwargs):
model = ResNetAL(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
return model |
def read_all_sentences(input_files):
all_sentences = []
for input_file in input_files:
with open(input_file, 'r') as reader:
for line in reader.readlines():
line = line.strip()
if (not line):
continue
else:
... |
class MassMapsDatasetResized(Dataset):
def __init__(self, root_dir, img_size=64):
dataset_zip = np.load(opj(root_dir, 'cosmo_resize_{}.npz'.format(img_size)))
self.imgs = dataset_zip['imgs']
self.params = dataset_zip['params']
def __len__(self):
return len(self.params)
def __... |
class TestWordlistDataset(TestCase):
def setUp(self):
clear_vocabs()
build_vocabs('data/test.es-fr-en.toy.cog', 'es', 'en')
def test_basic(self):
vocab = get_vocab('es')
dataset = WordlistDataset(vocab.words[1:], 'es')
ans = dataset[0].char_seq
self.assertListEqua... |
def get_model_and_tokenizer(name):
global T5_CONFIGS
if (name not in T5_CONFIGS):
T5_CONFIGS[name] = dict()
if ('model' not in T5_CONFIGS[name]):
T5_CONFIGS[name]['model'] = get_model(name)
if ('tokenizer' not in T5_CONFIGS[name]):
T5_CONFIGS[name]['tokenizer'] = get_tokenizer(na... |
def filter_manifest_df(df, is_train_split=False, extra_filters=None, min_n_frames=5, max_n_frames=3000):
filters = {'no speech': (df['audio'] == ''), f'short speech (<{min_n_frames} frames)': (df['n_frames'] < min_n_frames), 'empty sentence': (df['tgt_text'] == '')}
if is_train_split:
filters[f'long spe... |
class CPUAdam(torch.optim.Optimizer):
optimizer_id = 0
def __init__(self, params, lr=0.001, bias_correction=True, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, use_fp16_stats=False):
defaults = {'lr': lr, 'bias_correction': bias_correction, 'betas': betas, 'eps': eps, 'weight_decay': weight_decay}
... |
class DataTrainingArguments():
dataset_name: str = field(metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
dataset_config_name: str = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
train_split_na... |
class ConcatDataset(_ConcatDataset):
def __init__(self, datasets):
super(ConcatDataset, self).__init__(datasets)
self.CLASSES = datasets[0].CLASSES
if hasattr(datasets[0], 'flag'):
flags = []
for i in range(0, len(datasets)):
flags.append(datasets[i].f... |
def add_args(parser, cfg, prefix=''):
for (k, v) in cfg.items():
if isinstance(v, str):
parser.add_argument((('--' + prefix) + k))
elif isinstance(v, int):
parser.add_argument((('--' + prefix) + k), type=int)
elif isinstance(v, float):
parser.add_argument(... |
class MinibatchRlBase(BaseRunner):
_eval = False
def __init__(self, algo, agent, sampler, n_steps, seed=None, affinity=None, log_interval_steps=100000.0):
n_steps = int(n_steps)
log_interval_steps = int(log_interval_steps)
affinity = (dict() if (affinity is None) else affinity)
s... |
def plot_training(training_losses, validation_losses, learning_rate, gaussian=True, sigma=2, figsize=(8, 6)):
import matplotlib.pyplot as plt
from matplotlib import gridspec
from scipy.ndimage import gaussian_filter
list_len = len(training_losses)
x_range = list(range(1, (list_len + 1)))
fig = p... |
def main():
(args, cfg) = parse_config()
if (args.launcher == 'none'):
print('None args.launcher', args.launcher)
dist_train = False
total_gpus = 1
else:
print('args.launcher', args.launcher)
(total_gpus, cfg.LOCAL_RANK) = getattr(common_utils, ('init_dist_%s' % args.... |
def resnet50(pretrained=False, root='~/.encoding/models', **kwargs):
model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained:
from ..models.model_store import get_model_file
model.load_state_dict(torch.load(get_model_file('resnet50', root=root)), strict=False)
return model |
def get_files(root, test=False):
data_root1 = os.path.join('/tmp', root, datasetname[3])
data_root2 = os.path.join('/tmp', root, datasetname[0])
path1 = os.path.join('/tmp', data_root1, normalname[0])
(data, lab) = data_load(path1, axisname=normalname[0], label=0)
for i in tqdm(range(len(dataname1))... |
def learn_halut(l: str, C: int, data_path: str, store_path: str, K: int=16, loop_order: Literal[('im2col', 'kn2col')]='im2col', kernel_size: tuple[(int, int)]=(1, 1), stride: tuple[(int, int)]=(1, 1), padding: tuple[(int, int)]=(0, 0), niter=2, nredo=1, min_points_per_centroid=100, max_points_per_centroid=1000, codeboo... |
def test_accuracy(data_loader, net, num_steps, population_code=False, num_classes=False):
with torch.no_grad():
total = 0
acc = 0
net.eval()
data_loader = iter(data_loader)
for (data, targets) in data_loader:
data = data.to(device)
targets = targets.to... |
def remove_by_name(container, name, name_field='name'):
item = get_by_name(container, name, name_field)
if (item is not None):
container.remove(item) |
def main(args):
torch.manual_seed(3)
np.random.seed(2)
random.seed(2)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
if (args.dataset in ['ppi', 'reddit']):
data = load_data(args)
g = data.g
train_mask = g.ndata['train_mask']
val_... |
def get_sos_schema(num_density_layers, hidden_channels, num_polynomials_per_layer, polynomial_degree):
result = [{'type': 'flatten'}]
for i in range(num_density_layers):
if (i > 0):
result.append({'type': 'flip'})
result += [{'type': 'sos', 'hidden_channels': hidden_channels, 'activa... |
def build_conv_model2():
input0 = helper.make_tensor_value_info('input0', TensorProto.FLOAT, [1, 3, 1, 3])
output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 1, 3])
X1_weight = generate_input_initializer([3, 3, 1, 1], np.float32, 'X1_weight')
X1_bias = generate_input_initializer(... |
_module()
class QueryInst(SparseRCNN):
'Implementation of\n `Instances as Queries <
def __init__(self, backbone: ConfigType, rpn_head: ConfigType, roi_head: ConfigType, train_cfg: ConfigType, test_cfg: ConfigType, neck: OptConfigType=None, data_preprocessor: OptConfigType=None, init_cfg: OptMultiConfig=None)... |
class BahdanauAttention(AttentionMechanism):
def __init__(self, hidden_size=1, key_size=1, query_size=1):
super().__init__()
self.key_layer = nn.Linear(key_size, hidden_size, bias=False)
self.query_layer = nn.Linear(query_size, hidden_size, bias=False)
self.energy_layer = nn.Linear(h... |
def get_all_dir_names(dir_path):
dir_path = Path(dir_path)
if dir_path.exists():
return sorted([x.name for x in list(scandir(str(dir_path))) if x.is_dir()])
else:
return [] |
class ResidualStack(nn.Module):
def __init__(self, channels):
super().__init__()
self.channels = channels
self.res_1 = nn.Sequential(nn.LeakyReLU(), nn.Conv1d(channels, channels, 3, padding=commons.get_same_padding(3)), nn.LeakyReLU(), nn.Conv1d(channels, channels, 3, padding=commons.get_sam... |
class EventQuery():
def __init__(self, api_key, prompt_folder: str, num_prompts: int=12):
openai.api_key = api_key
self.setup_msgs = []
system_msgs = []
prompt_assistant_msgs = []
prompt_user_msgs = []
help_msgs = []
if (not os.path.exists(prompt_folder)):
... |
def revert_imagenet_normalization(sample):
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
mean_tensor = torch.Tensor(mean).view(3, 1, 1).to(sample.device)
std_tensor = torch.Tensor(std).view(3, 1, 1).to(sample.device)
non_normalized_sample = ((sample * std_tensor) + mean_tensor)
return... |
def train(model, predictor, dataset, optimizer, batch_size, device):
model.train()
losses = []
optimizer.zero_grad()
for data in tqdm.notebook.tqdm(torch_geometric.loader.dataloader.DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=16), 'train', total=(len(dataset) // batch_size)):
... |
def get_datetime(time_delta):
days_delta = (time_delta // (24 * 3600))
time_delta = (time_delta % (24 * 3600))
hour_delta = (time_delta // 3600)
time_delta = (time_delta % 3600)
mins_delta = (time_delta // 60)
time_delta = (time_delta % 60)
secs_delta = time_delta
return '{}:{}:{}:{}'.fo... |
def add_random_restarts_single_l(lik, n_rand, sd, data_shape):
lik_list = []
for dummy in range(n_rand):
l = lik.copy()
l.initialise_params(sd=sd, data_shape=data_shape)
lik_list.append(l)
return lik_list |
def test_error():
msg = 'Penalty term must be positive'
with pytest.raises(ValueError, match=msg):
LogisticRegression(lambda_1=(- 1)).fit(X, Y1)
with pytest.raises(ValueError, match=msg):
LogisticRegression(lambda_1='test').fit(X, Y1)
for LR in [LogisticRegression]:
msg = 'Tolera... |
_torch
class LxmertModelTest(ModelTesterMixin, unittest.TestCase):
all_model_classes = ((LxmertModel, LxmertForPreTraining, LxmertForQuestionAnswering) if is_torch_available() else ())
test_head_masking = False
test_pruning = False
test_torchscript = False
test_head_masking = False
test_pruning ... |
class Pattern(object):
def __call__(self, model, *args, **kwargs):
raise NotImplementedError |
def slim_eval_runner(benchmark, vec_input: bool=False, uniform: bool=True, input_dim: int=10, bond_dim: int=10, seq_len: int=100, batch: int=100):
if uniform:
core_tensor = near_eye_init((input_dim, bond_dim, bond_dim))
else:
core_tensor = near_eye_init((seq_len, input_dim, bond_dim, bond_dim))
... |
def get_logger():
logger_name = 'main-logger'
logger = logging.getLogger(logger_name)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
fmt = '[%(asctime)s %(levelname)s %(filename)s line %(lineno)d %(process)d] %(message)s'
handler.setFormatter(logging.Formatter(fmt))
logger.a... |
def try_to_load_from_cache(repo_id: str, filename: str, cache_dir: Union[(str, Path, None)]=None, revision: Optional[str]=None) -> Optional[str]:
if (revision is None):
revision = 'main'
if (cache_dir is None):
cache_dir = TRANSFORMERS_CACHE
object_id = repo_id.replace('/', '--')
repo_ca... |
def parse_args(script):
parser = argparse.ArgumentParser(description=('few-shot script %s' % script))
parser.add_argument('--dataset', default='CUB', help='CUB/miniImagenet/cross/omniglot/cross_char')
parser.add_argument('--model', default='Conv4', help='model: Conv{4|6} / ResNet{10|18|34|50|101}')
pars... |
def sample_generator(filename, batch_size=1):
index = 0
file_size = len(open(filename, 'r').readlines())
while True:
fsamples = open(filename, 'r')
fixed_list = []
moving_list = []
for (n, line) in enumerate(fsamples):
if (n < index):
continue
... |
def edit_modelfile(data_, mtype, csvfilename):
list_doc = yaml.load(open('model.yml'), Loader=yaml.Loader)
os.remove('model.yml')
project = list_doc['project']
data = list_doc['data']
print(data)
data['drop'] = ['Unnamed: 0']
data['shuffle'] = True
data['split'] = 0.4
data['target'] ... |
class MaCowInternalBlock(Flow):
def __init__(self, num_steps, in_channels, kernel_size, hidden_channels, s_channels, factor=2, scale=True, prior_scale=True, inverse=False, coupling_type='conv', slice=None, heads=1, pos_enc=True, dropout=0.0):
super(MaCowInternalBlock, self).__init__(inverse)
num_lay... |
def parse_data_format(str):
str = str.upper()
mace_check((str in [e.name for e in DataFormat]), ('unknown data format %s' % str))
return DataFormat[str] |
def linear(args, output_size, bias, bias_start=0.0, scope=None, squeeze=False, wd=0.0, input_keep_prob=1.0, is_train=None):
with tf.variable_scope((scope or 'linear')):
if ((args is None) or (nest.is_sequence(args) and (not args))):
raise ValueError('`args` must be specified')
if (not ne... |
def run_and_save_graph(predict_net, init_net, tensor_inputs, graph_save_path):
logger.info('Saving graph of ONNX exported model to {} ...'.format(graph_save_path))
save_graph(predict_net, graph_save_path, op_only=False)
logger.info('Running ONNX exported model ...')
with ScopedWS('__ws_tmp__', True) as ... |
class SPIN(nn.Module):
def __init__(self, block, layers):
self.inplanes = 64
super(SPIN, self).__init__()
npose = (24 * 6)
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)
... |
def run_minimization_while(energy_fn, R_init, shift, max_grad_thresh=1e-12, max_steps=1000000, **kwargs):
(init, apply) = minimize.fire_descent(jit(energy_fn), shift, dt_start=0.001, dt_max=0.005, **kwargs)
apply = jit(apply)
def get_maxgrad(state):
return jnp.amax(jnp.abs(state.force))
def cond... |
def train_model(datapath, output, appliance, hparams, doplot=None, reload=True):
buildings = appliance['buildings']['train']
name = appliance['name']
params = appliance['hparams']
record_err = np.inf
transform_enabled = appliance.get('normalization', False)
model_type = appliance.get('model', 'M... |
class WikipediaDataSet(Dataset):
def __init__(self, root, n_context_sent=1, train=True, high_granularity=False):
root_path = root
print(root_path)
cache_path = get_cache_path(root_path)
print(cache_path)
if (not os.path.exists(cache_path)):
print('loading names of... |
class Encoder_FC(nn.Module):
def __init__(self, modeltype, njoints, nfeats, num_frames, num_classes, translation, pose_rep, glob, glob_rot, latent_dim=256, **kargs):
super().__init__()
self.modeltype = modeltype
self.njoints = njoints
self.nfeats = nfeats
self.num_frames = nu... |
def loss(labels, logits):
return tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits) |
def testeval(fen, absolute=False) -> float:
piece_vals = {'K': 3, 'Q': 14, 'R': 5, 'B': 3.25, 'N': 3, 'P': 1}
ans = 0.0
tot = 0
for c in fen.split(' ')[0]:
if (not c.isalpha()):
continue
if c.isupper():
ans += piece_vals[c]
tot += piece_vals[c]
... |
def convert_ordinal_to_binary_preference(preferences: Union[(pd.DataFrame, list[dict[(str, Any)]])], ordinal_preference_key: str='preference', binary_preference_key: str='preference'):
if isinstance(preferences, pd.DataFrame):
is_df = True
else:
is_df = False
preferences = pd.DataFrame.f... |
_module()
class KineticsClipFolderDatasetV2MultiFrames(KineticsClipFolderDatasetV2):
def __init__(self, root, transform=None, split='train_list', sample_num=0):
super(KineticsClipFolderDatasetV2MultiFrames, self).__init__(root, split)
self.transform = transform
self.sample_num = sample_num
... |
def resnet_v1_50(inputs, num_classes=None, is_training=True, global_pool=True, output_stride=None, reuse=None, scope='resnet_v1_50'):
blocks = [resnet_utils.Block('block1', bottleneck, (([(256, 64, 1)] * 2) + [(256, 64, 2)])), resnet_utils.Block('block2', bottleneck, (([(512, 128, 1)] * 3) + [(512, 128, 2)])), resn... |
def create_and_report(model_id, edge_length_threshold, filled, overwrite=False):
import template_ffd.eval.iou as iou
print(iou.get_iou_average(model_id=model_id, edge_length_threshold=edge_length_threshold, filled=filled)) |
def _test_initialization(d, x, name, inertia, frozen, dtype):
assert (d.inertia == inertia)
assert (d.frozen == frozen)
param = getattr(d, name)
if (x is not None):
assert (param.shape[0] == len(x))
assert (param.dtype == dtype)
assert_array_almost_equal(param, x)
else:
... |
def _take_channels(*xs, ignore_channels=None):
if (ignore_channels is None):
return xs
else:
channels = [channel for channel in range(xs[0].shape[1]) if (channel not in ignore_channels)]
xs = [torch.index_select(x, dim=1, index=torch.tensor(channels).to(x.device)) for x in xs]
re... |
class FrozenDict(OrderedDict):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for (key, value) in self.items():
setattr(self, key, value)
self.__frozen = True
def __delitem__(self, *args, **kwargs):
raise Exception(f'You cannot use ``__delitem_... |
def _load_from_summary(index, config):
dataframe = pd.DataFrame.from_csv('./train_package/train_summary.csv')
history_string = dataframe.loc[int(index)]['backtest_test_history']
if (not check_input_same(config, json.loads(dataframe.loc[int(index)]['config']))):
raise ValueError('the date of this ind... |
def test_velocity_in_kpcGyr():
(vofid, rofid) = (200.0, 8.0)
assert (numpy.fabs((((2.0 * conversion.velocity_in_kpcGyr(vofid, rofid)) / conversion.velocity_in_kpcGyr((2.0 * vofid), rofid)) - 1.0)) < (10.0 ** (- 10.0))), 'velocity_in_kpcGyr did not work as expected'
assert (numpy.fabs(((conversion.velocity_i... |
def validate(args, device_id, pt, step):
device = ('cpu' if (args.visible_gpus == '-1') else 'cuda')
if (pt != ''):
test_from = pt
else:
test_from = args.test_from
logger.info(('Loading checkpoint from %s' % test_from))
checkpoint = torch.load(test_from, map_location=(lambda storage,... |
class TestOptions(BaseOptions):
def initialize(self, parser):
parser = BaseOptions.initialize(self, parser)
parser.add_argument('--phase', type=str, default='test', help='test flag')
parser.add_argument('--phase_anno', type=str, default='test', help='eigen/eigen_test, Annotations file name')... |
class bcolors():
HEADER = '\x1b[95m'
INFO = ' [INFO] | '
OKBLUE = '\x1b[94m[DOWNLOAD] | '
WARNING = '\x1b[93m [WARN] | '
FAIL = '\x1b[91m [ERROR] | '
OKGREEN = '\x1b[92m'
ENDC = '\x1b[0m' |
def tf_hard_intersection_pooler(boxes: TFBoxTensor, mask: tf.Tensor=None, dim: int=0, keepdim: bool=False) -> TFBoxTensor:
box_z = boxes.z
box_Z = boxes.Z
if (mask is not None):
box_z[mask] -= float('inf')
box_Z[mask] += float('inf')
z = tf.math.reduce_max(box_z, axis=dim, keepdims=keepd... |
def pretent_to_be_nnUNetTrainer(base, folds=(0, 1, 2, 3, 4)):
for fold in folds:
cur = join(base, ('fold_%d' % fold))
pkl_file = join(cur, 'model_best.model.pkl')
a = load_pickle(pkl_file)
a['name_old'] = deepcopy(a['name'])
a['name'] = 'nnUNetTrainer'
save_pickle(a, ... |
class UnpairedDataset(data.Dataset):
def __init__(self, opt, im_path, is_val=False):
super().__init__()
self.dir = im_path
self.paths = sorted(make_dataset(self.dir, opt.max_dataset_size))
self.size = len(self.paths)
assert (self.size > 0)
self.transform = transforms.... |
def parse_args():
parser = argparse.ArgumentParser(description=' EmbMatch Training')
parser.add_argument('--dataset-path', type=str, default=os.environ.get('SEMCO_DATA_PATH', '/home/inas0003/data'), help='the path to the data folder containing all datasets')
parser.add_argument('--word-vec-path', type=str, ... |
def prediction(dataset, model, args):
preds = []
golds = []
model.eval()
for j in range(0, len(dataset), args.batch_size):
(src, seg, label, mask_src) = Batch(dataset, j, args.batch_size, args.device).get()
preds += model.predict(src, seg, mask_src)
golds += label.cpu().data.nump... |
def generate_features(tbl, bins, cross_sizes):
tbl = tbl.cut_bins(columns=count_cols, bins=bins, out_cols=count_cols)
tbl = tbl.cross_columns(cross_cols, cross_sizes)
return tbl |
class LeakyDataset(Dataset):
def __init__(self, traindata, testdata, r, seed=2):
self.r = r
gen = torch.Generator().manual_seed(seed)
len_text = len(testdata)
nb_leak = int((r * len_text))
(testdata, _) = random_split(testdata, [nb_leak, (len_text - nb_leak)], generator=gen)
... |
def _create_grid_offsets(size: List[int], stride: int, offset: float, device: torch.device):
(grid_height, grid_width) = size
shifts_x = torch.arange((offset * stride), (grid_width * stride), step=stride, dtype=torch.float32, device=device)
shifts_y = torch.arange((offset * stride), (grid_height * stride), ... |
class SchedulerType(ExplicitEnum):
LINEAR = 'linear'
COSINE = 'cosine'
COSINE_WITH_RESTARTS = 'cosine_with_restarts'
POLYNOMIAL = 'polynomial'
CONSTANT = 'constant'
CONSTANT_WITH_WARMUP = 'constant_with_warmup'
INVERSE_SQRT = 'inverse_sqrt' |
class MotorModel(object):
def __init__(self, torque_control_enabled=False, kp=1.2, kd=0):
self._torque_control_enabled = torque_control_enabled
self._kp = kp
self._kd = kd
self._resistance = MOTOR_RESISTANCE
self._voltage = MOTOR_VOLTAGE
self._torque_constant = MOTOR_... |
class CorstemNet(nn.Module):
def __init__(self, input_nc=1, num_classes=2, ngf=32):
super().__init__()
self.in_dim = input_nc
self.out_dim = ngf
self.final_out_dim = num_classes
act_fn = nn.LeakyReLU(0.2, inplace=True)
act_fn_2 = nn.ReLU()
self.down_1 = Conv_r... |
def meshgrid(batch, height, width, is_homogeneous=True):
x_t = tf.matmul(tf.ones(shape=tf.stack([height, 1])), tf.transpose(tf.expand_dims(tf.linspace((- 1.0), 1.0, width), 1), [1, 0]))
y_t = tf.matmul(tf.expand_dims(tf.linspace((- 1.0), 1.0, height), 1), tf.ones(shape=tf.stack([1, width])))
x_t = (((x_t + ... |
def test_ST3():
orb = orbit.ST3(q_in, K_in, e_in, omega_in, P_in, T0_in, q_out, K_out, e_out, omega_out, P_out, T0_out, gamma, dates)
vels = orb.get_velocities()
(fig, ax) = plt.subplots(nrows=1)
ax.axhline(gamma, color='0.5', ls=':')
ax.plot(dates, vels[0])
ax.plot(dates, vels[1])
ax.plot(d... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.