code stringlengths 17 6.64M |
|---|
def mkdirs(*paths: Path, exist_ok: bool=True, parents: bool=True, **kwargs) -> None:
'Create all input directories with laxer defaults.'
for p in paths:
p.mkdir(exist_ok=exist_ok, parents=parents, **kwargs)
|
def pil2np(img: Image, /) -> ty.A:
'Convert PIL image [0, 255] into numpy [0, 1].'
return (np.array(img, dtype=np.float32) / 255.0)
|
def np2pil(arr: ty.A, /) -> Image:
'Convert numpy image [0, 1] into PIL [0, 255].'
if (arr.dtype == np.uint8):
return Image.fromarray(arr)
assert (arr.max() <= 1)
return Image.fromarray((arr * 255).astype(np.uint8))
|
def write_yaml(file: Path, data: dict, mkdir: bool=False, sort_keys: bool=False) -> None:
'Write data to a yaml file.'
file = Path(file).with_suffix('.yaml')
if mkdir:
mkdirs(file.parent)
with open(file, 'w') as f:
yaml.dump(data, f, sort_keys=sort_keys)
|
def load_yaml(file: Path, loader: ty.N[yaml.Loader]=yaml.FullLoader) -> dict:
'Load a single yaml file.'
with open(file) as f:
return yaml.load(f, Loader=loader)
|
def load_merge_yaml(*files: Path) -> dict:
'Load a list of YAML configs and recursively merge into a single config.\n\n Following dictionary merging rules, the first file is the "base" config, which gets updated by the second file.\n We chain this rule for however many cfg we have, i.e. ((((1 <- 2) <- 3) <-... |
def _merge_yaml(old: dict, new: dict) -> dict:
'Recursively merge two YAML cfg.\n Dictionaries are recursively merged. All other types simply update the current value.\n\n NOTE: This means that a "list of dicts" will simply be updated to whatever the new value is,\n not appended to or recursively checked... |
class ConcatDataLoader():
"Concatenate multiple DataLoaders in a round-robin manner.\n Example:\n dl1 = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n dl2 = ['a', 'b', 'c']\n dl3 = [0.1, 0.2, 0.3, 0.4. 0.5]\n\n [0, 'a', 0.1, 1, 'b', 0.2, 3, 'c', 0.3, 4, 0.4, 5, 0.5, 6, 7, 8]\n\n :param dls: (Sequ... |
class BaseMetric(Metric):
'Base class for depth estimation metrics.'
higher_is_better = False
full_state_update = False
def __init__(self, mode: str='raw', **kwargs):
super().__init__(**kwargs)
if (mode not in _MODES):
raise ValueError(f'Invalid mode! ({mode} vs. {_MODES})... |
class MAE(BaseMetric):
'Compute the mean absolute error.'
def _compute(self, pred: ty.T, target: ty.T) -> ty.T:
return (pred - target).abs().nanmean(dim=1)
|
class RMSE(BaseMetric):
'Compute the root mean squared error.'
def _compute(self, pred: ty.T, target: ty.T) -> ty.T:
return (pred - target).pow(2).nanmean(dim=1).sqrt()
|
class ScaleInvariant(BaseMetric):
'Compute the scale invariant error.'
def _compute(self, pred: ty.T, target: ty.T) -> ty.T:
err = (pred - target)
return (err.pow(2).nanmean(dim=1) - err.nanmean(dim=1).pow(2)).sqrt()
|
class AbsRel(BaseMetric):
'Compute the absolute relative error.'
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sf = 100
def _compute(self, pred: ty.T, target: ty.T) -> ty.T:
return ((pred - target).abs() / target).nanmean(dim=1)
|
class SqRel(BaseMetric):
'Compute the absolute relative squared error.'
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sf = 100
def _compute(self, pred: ty.T, target: ty.T) -> ty.T:
return ((pred - target).pow(2) / target.pow(2)).nanmean(dim=1)
|
class DeltaAcc(BaseMetric):
'Compute the accuracy for a given error threshold.'
higher_is_better = True
def __init__(self, delta: float, **kwargs):
super().__init__(**kwargs)
if (self.mode != 'raw'):
raise ValueError('DeltaAcc should only be computed using raw depths.')
... |
class Timer():
"Context manager for timing a block of code.\n\n Attributes:\n :param name: (str) Timer label when printing.\n :param as_ms: (bool) If `True`, store time as `milliseconds`, otherwise `seconds`.\n :param sync_gpu: (bool) If `True`, ensure that GPU is synced on Timer enter and exit.\n ... |
class MultiLevelTimer():
"Context manager Timer capable of being nested across multiple levels.\n\n NOTE: We use the *instance* of this class as a context manager, not the class itself (see examples).\n\n Timers are stored as a dict, mapping labels to (depth, start, end, elapsed).\n In order to allow for... |
def iter_graph(root, callback):
queue = [root]
seen = set()
while queue:
fn = queue.pop()
if (fn in seen):
continue
seen.add(fn)
for (next_fn, _) in fn.next_functions:
if (next_fn is not None):
queue.append(next_fn)
callback(f... |
def register_hooks(var):
fn_dict = {}
def hook_cb(fn):
def register_grad(grad_input, grad_output):
fn_dict[fn] = grad_input
fn.register_hook(register_grad)
iter_graph(var.grad_fn, hook_cb)
def is_bad_grad(grad_output):
grad_output = grad_output.data
retur... |
class Checkpoints():
def __init__(self, args):
self.dir_save = args.save
self.dir_load = args.resume
if (os.path.isdir(self.dir_save) == False):
os.makedirs(self.dir_save)
def latest(self, name):
if (name == 'resume'):
if (self.dir_load == None):
... |
class Dataloader():
def __init__(self, args):
self.args = args
self.loader_input = args.loader_input
self.loader_label = args.loader_label
self.split_test = args.split_test
self.split_train = args.split_train
self.dataset_test_name = args.dataset_test
self.... |
class FileList(data.Dataset):
def __init__(self, ifile, lfile=None, split_train=1.0, split_test=0.0, train=True, transform_train=None, transform_test=None, loader_input=loaders.loader_image, loader_label=loaders.loader_torch):
self.ifile = ifile
self.lfile = lfile
self.train = train
... |
def is_image_file(filename):
return any((filename.endswith(extension) for extension in IMG_EXTENSIONS))
|
def make_dataset(classlist, labellist=None):
images = []
labels = []
classes = utils.readtextfile(ifile)
classes = [x.rstrip('\n') for x in classes]
classes.sort()
for i in len(classes):
for fname in os.listdir(classes[i]):
if is_image_file(fname):
label = {... |
class FolderList(data.Dataset):
def __init__(self, ifile, lfile=None, split_train=1.0, split_test=0.0, train=True, transform_train=None, transform_test=None, loader_input=loaders.loader_image, loader_label=loaders.loader_torch):
(imagelist, labellist) = make_dataset(ifile, lfile)
if (len(imagelis... |
def loader_image(path):
return Image.open(path).convert('RGB')
|
def loader_torch(path):
return torch.load(path)
|
def loader_numpy(path):
return np.load(path)
|
class Classification():
def __init__(self, topk=(1,)):
self.topk = topk
def forward(self, output, target):
'Computes the precision@k for the specified values of k'
maxk = max(self.topk)
batch_size = target.size(0)
(_, pred) = output.topk(maxk, 1, True, True)
p... |
class Classification(nn.Module):
def __init__(self):
super(Classification, self).__init__()
self.loss = nn.CrossEntropyLoss()
def forward(self, input, target):
loss = self.loss(input, target)
return loss
|
class Regression(nn.Module):
def __init__(self):
super(Regression, self).__init__()
self.loss = nn.MSELoss()
def forward(self, input, target):
loss = self.loss.forward(input, target)
return loss
|
def weights_init(m):
if isinstance(m, nn.Conv2d):
n = ((m.kernel_size[0] * m.kernel_size[1]) * m.out_channels)
m.weight.data.normal_(0, math.sqrt((2.0 / n)))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
|
class Model():
def __init__(self, args):
self.cuda = args.cuda
self.nfilters = args.nfilters
self.nclasses = args.nclasses
self.nchannels = args.nchannels
self.nblocks = args.nblocks
self.nlayers = args.nlayers
self.level = args.level
self.nchannels... |
class NoiseLayer(nn.Module):
def __init__(self, in_planes, out_planes, level):
super(NoiseLayer, self).__init__()
self.noise = torch.randn(1, in_planes, 1, 1)
self.level = level
self.layers = nn.Sequential(nn.ReLU(True), nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=1), n... |
class NoiseModel(nn.Module):
def __init__(self, nblocks, nlayers, nchannels, nfilters, nclasses, level):
super(NoiseModel, self).__init__()
self.num = nfilters
self.level = level
layers = []
layers.append(NoiseLayer(3, nfilters, self.level))
for i in range(1, nlaye... |
def conv3x3(in_planes, out_planes, stride=1):
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
|
class NoiseLayer(nn.Module):
def __init__(self, in_planes, out_planes, level):
super(NoiseLayer, self).__init__()
self.noise = nn.Parameter(torch.Tensor(0), requires_grad=False).to(device)
self.level = level
self.layers = nn.Sequential(nn.ReLU(True), nn.BatchNorm2d(in_planes), nn.... |
class NoiseBasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1, shortcut=None, level=0.2):
super(NoiseBasicBlock, self).__init__()
self.layers = nn.Sequential(NoiseLayer(in_planes, planes, level), nn.MaxPool2d(stride, stride), nn.BatchNorm2d(planes), nn.ReLU(Tr... |
class NoiseBottleneck(nn.Module):
expansion = 4
def __init__(self, in_planes, planes, stride=1, shortcut=None, level=0.2):
super(NoiseBottleneck, self).__init__()
self.layers = nn.Sequential(nn.Conv2d(in_planes, planes, kernel_size=1, bias=False), nn.BatchNorm2d(planes), nn.ReLU(True), NoiseL... |
class NoiseResNet(nn.Module):
def __init__(self, block, nblocks, nchannels, nfilters, nclasses, pool, level):
super(NoiseResNet, self).__init__()
self.in_planes = nfilters
self.pre_layers = nn.Sequential(nn.Conv2d(nchannels, nfilters, kernel_size=7, stride=2, padding=3, bias=False), nn.Ba... |
def noiseresnet18(nchannels, nfilters, nclasses, pool=7, level=0.1):
return NoiseResNet(NoiseBasicBlock, [2, 2, 2, 2], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses, pool=pool, level=level)
|
def noiseresnet34(nchannels, nfilters, nclasses, pool=7, level=0.1):
return NoiseResNet(NoiseBasicBlock, [3, 4, 6, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses, pool=pool, level=level)
|
def noiseresnet50(nchannels, nfilters, nclasses, pool=7, level=0.1):
return NoiseResNet(NoiseBottleneck, [3, 4, 6, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses, pool=pool, level=level)
|
def noiseresnet101(nchannels, nfilters, nclasses, pool=7, level=0.1):
return NoiseResNet(NoiseBottleneck, [3, 4, 23, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses, pool=pool, level=level)
|
def noiseresnet152(nchannels, nfilters, nclasses, pool=7, level=0.1):
return NoiseResNet(NoiseBottleneck, [3, 8, 36, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses, pool=pool, level=level)
|
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(((16 * 5) * 5), 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linea... |
def conv3x3(in_planes, out_planes, stride=1):
'3x3 convolution with padding'
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
|
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 ... |
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, p... |
class ResNet(nn.Module):
def __init__(self, block, layers, nchannels, nfilters, nclasses=1000):
self.inplanes = nfilters
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(nchannels, nfilters, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(nfilters)
... |
def resnet18(nchannels, nfilters, nclasses):
return ResNet(BasicBlock, [2, 2, 2, 2], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses)
|
def resnet34(nchannels, nfilters, nclasses):
return ResNet(BasicBlock, [3, 4, 6, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses)
|
def resnet50(nchannels, nfilters, nclasses):
return ResNet(Bottleneck, [3, 4, 6, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses)
|
def resnet101(nchannels, nfilters, nclasses):
return ResNet(Bottleneck, [3, 4, 23, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses)
|
def resnet152(nchannels, nfilters, nclasses):
return ResNet(Bottleneck, [3, 8, 36, 3], nchannels=nchannels, nfilters=nfilters, nclasses=nclasses)
|
class Image():
def __init__(self, path, ext='png'):
if (os.path.isdir(path) == False):
os.makedirs(path)
self.path = path
self.names = []
self.ext = ext
self.iteration = 1
self.num = 0
def register(self, modules):
self.num = (self.num + len... |
class Logger():
def __init__(self, path, filename):
self.num = 0
if (os.path.isdir(path) == False):
os.makedirs(path)
self.filename = os.path.join(path, filename)
self.fid = open(self.filename, 'w')
self.fid.close()
def register(self, modules):
sel... |
class Monitor():
def __init__(self, smoothing=True, smoothness=0.7):
self.keys = []
self.losses = {}
self.smoothing = smoothing
self.smoothness = smoothness
self.num = 0
def register(self, modules):
for m in modules:
self.keys.append(m)
... |
class Visualizer():
def __init__(self, port, title):
self.keys = []
self.values = {}
self.viz = visdom.Visdom(port=port)
self.iteration = 0
self.title = title
def register(self, modules):
for key in modules:
self.keys.append(key)
self.v... |
class Trainer():
def __init__(self, args, model, criterion):
self.args = args
self.model = model
self.criterion = criterion
self.port = args.port
self.dir_save = args.save
self.cuda = args.cuda
self.nepochs = args.nepochs
self.nclasses = args.nclass... |
def readtextfile(filename):
with open(filename) as f:
content = f.readlines()
f.close()
return content
|
def writetextfile(data, filename):
with open(filename, 'w') as f:
f.writelines(data)
f.close()
|
def delete_file(filename):
if (os.path.isfile(filename) == True):
os.remove(filename)
|
def eformat(f, prec, exp_digits):
s = ('%.*e' % (prec, f))
(mantissa, exp) = s.split('e')
return ('%se%+0*d' % (mantissa, (exp_digits + 1), int(exp)))
|
def saveargs(args):
path = args.logs
if (os.path.isdir(path) == False):
os.makedirs(path)
with open(os.path.join(path, 'args.txt'), 'w') as f:
for arg in vars(args):
f.write((((arg + ' ') + str(getattr(args, arg))) + '\n'))
|
class Dataloader():
def __init__(self, args, input_size):
self.args = args
self.dataset_test_name = args.dataset_test
self.dataset_train_name = args.dataset_train
self.input_size = input_size
if (self.dataset_train_name == 'LSUN'):
self.dataset_train = getattr(... |
class FileList(data.Dataset):
def __init__(self, ifile, lfile=None, split_train=1.0, split_test=0.0, train=True, transform_train=None, transform_test=None, loader_input=loaders.loader_image, loader_label=loaders.loader_torch):
self.ifile = ifile
self.lfile = lfile
self.train = train
... |
def is_image_file(filename):
return any((filename.endswith(extension) for extension in IMG_EXTENSIONS))
|
def make_dataset(classlist, labellist=None):
images = []
labels = []
classes = utils.readtextfile(ifile)
classes = [x.rstrip('\n') for x in classes]
classes.sort()
for i in len(classes):
for fname in os.listdir(classes[i]):
if is_image_file(fname):
label = {... |
class FolderList(data.Dataset):
def __init__(self, ifile, lfile=None, split_train=1.0, split_test=0.0, train=True, transform_train=None, transform_test=None, loader_input=loaders.loader_image, loader_label=loaders.loader_torch):
(imagelist, labellist) = make_dataset(ifile, lfile)
if (len(imagelis... |
def loader_image(path):
return Image.open(path).convert('RGB')
|
def loader_torch(path):
return torch.load(path)
|
def loader_numpy(path):
return np.load(path)
|
class Model():
def __init__(self, args):
self.cuda = torch.cuda.is_available()
self.lr = args.learning_rate
self.dataset_train_name = args.dataset_train
self.nfilters = args.nfilters
self.batch_size = args.batch_size
self.level = args.level
self.net_type = ... |
class PerturbLayerFirst(nn.Module):
def __init__(self, in_channels=None, out_channels=None, nmasks=None, level=None, filter_size=None, debug=False, use_act=False, stride=1, act=None, unique_masks=False, mix_maps=None, train_masks=False, noise_type='uniform', input_size=None):
super(PerturbLayerFirst, sel... |
class PerturbLayer(nn.Module):
def __init__(self, in_channels=None, out_channels=None, nmasks=None, level=None, filter_size=None, debug=False, use_act=False, stride=1, act=None, unique_masks=False, mix_maps=None, train_masks=False, noise_type='uniform', input_size=None):
super(PerturbLayer, self).__init_... |
class PerturbBasicBlock(nn.Module):
expansion = 1
def __init__(self, in_channels=None, out_channels=None, stride=1, shortcut=None, nmasks=None, train_masks=False, level=None, use_act=False, filter_size=None, act=None, unique_masks=False, noise_type=None, input_size=None, pool_type=None, mix_maps=None):
... |
class PerturbResNet(nn.Module):
def __init__(self, block, nblocks=None, avgpool=None, nfilters=None, nclasses=None, nmasks=None, input_size=32, level=None, filter_size=None, first_filter_size=None, use_act=False, train_masks=False, mix_maps=None, act=None, scale_noise=1, unique_masks=False, debug=False, noise_ty... |
class LeNet(nn.Module):
def __init__(self, nfilters=None, nclasses=None, nmasks=None, level=None, filter_size=None, linear=128, input_size=28, debug=False, scale_noise=1, act='relu', use_act=False, first_filter_size=None, pool_type=None, dropout=None, unique_masks=False, train_masks=False, noise_type='uniform', ... |
class CifarNet(nn.Module):
def __init__(self, nfilters=None, nclasses=None, nmasks=None, level=None, filter_size=None, input_size=32, linear=256, scale_noise=1, act='relu', use_act=False, first_filter_size=None, pool_type=None, dropout=None, unique_masks=False, debug=False, train_masks=False, noise_type='uniform... |
class NoiseLayer(nn.Module):
def __init__(self, in_planes, out_planes, level):
super(NoiseLayer, self).__init__()
self.noise = nn.Parameter(torch.Tensor(0), requires_grad=False).to(device)
self.level = level
self.layers = nn.Sequential(nn.ReLU(True), nn.BatchNorm2d(in_planes), nn.... |
class NoiseBasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1, shortcut=None, level=0.2):
super(NoiseBasicBlock, self).__init__()
self.layers = nn.Sequential(NoiseLayer(in_planes, planes, level), nn.MaxPool2d(stride, stride), nn.BatchNorm2d(planes), nn.ReLU(Tr... |
class NoiseResNet(nn.Module):
def __init__(self, block, nblocks, nfilters, nclasses, pool, level, first_filter_size=3):
super(NoiseResNet, self).__init__()
self.in_planes = nfilters
if (first_filter_size == 7):
pool = 1
self.pre_layers = nn.Sequential(nn.Conv2d(3, ... |
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2... |
class ResNet(nn.Module):
def __init__(self, block, num_blocks, nfilters=64, avgpool=4, nclasses=10):
super(ResNet, self).__init__()
self.in_planes = nfilters
self.avgpool = avgpool
self.conv1 = nn.Conv2d(3, nfilters, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1... |
def resnet18(nfilters, avgpool=4, nclasses=10, nmasks=32, level=0.1, filter_size=0, first_filter_size=0, pool_type=None, input_size=None, scale_noise=1, act='relu', use_act=True, dropout=0.5, unique_masks=False, noise_type='uniform', train_masks=False, debug=False, mix_maps=None):
return ResNet(BasicBlock, [2, 2,... |
def noiseresnet18(nfilters, avgpool=4, nclasses=10, nmasks=32, level=0.1, filter_size=0, first_filter_size=7, pool_type=None, input_size=None, scale_noise=1, act='relu', use_act=True, dropout=0.5, unique_masks=False, debug=False, noise_type='uniform', train_masks=False, mix_maps=None):
return NoiseResNet(NoiseBas... |
def perturb_resnet18(nfilters, avgpool=4, nclasses=10, nmasks=32, level=0.1, filter_size=0, first_filter_size=0, pool_type=None, input_size=None, scale_noise=1, act='relu', use_act=True, dropout=0.5, unique_masks=False, debug=False, noise_type='uniform', train_masks=False, mix_maps=None):
return PerturbResNet(Per... |
def lenet(nfilters, avgpool=None, nclasses=10, nmasks=32, level=0.1, filter_size=3, first_filter_size=0, pool_type=None, input_size=None, scale_noise=1, act='relu', use_act=True, dropout=0.5, unique_masks=False, debug=False, noise_type='uniform', train_masks=False, mix_maps=None):
return LeNet(nfilters=nfilters, ... |
def cifarnet(nfilters, avgpool=None, nclasses=10, nmasks=32, level=0.1, filter_size=3, first_filter_size=0, pool_type=None, input_size=None, scale_noise=1, act='relu', use_act=True, dropout=0.5, unique_masks=False, debug=False, noise_type='uniform', train_masks=False, mix_maps=None):
return CifarNet(nfilters=nfil... |
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.linear = nn.Linear(((9 * 6) * 6), 10)
self.noise = nn.Parameter(torch.Tensor(1, 1, 28, 28), requires_grad=True)
self.noise.data.uniform_((- 1), 1)
self.layers = nn.Sequential(nn.Conv2d(1, 9, kernel_... |
def EmbedWord2Vec(walks, dimension):
time_start = time.time()
print('Creating embeddings.')
model = Word2Vec(walks, size=dimension, window=5, min_count=0, sg=1, workers=32, iter=1)
node_ids = model.wv.index2word
node_embeddings = model.wv.vectors
print('Embedding generation runtime: ', (time.t... |
def EmbedPoincare(relations, epochs, dimension):
model = PoincareModel(relations, size=dimension, workers=32)
model.train(epochs)
node_ids = model.index2entity
node_embeddings = model.vectors
return (node_ids, node_embeddings)
|
def TraverseAndSelect(length, num_walks, hyperedges, vertexMemberships, alpha=1.0, beta=0):
walksTAS = []
for hyperedge_index in hyperedges:
hyperedge = hyperedges[hyperedge_index]
walk_hyperedge = []
for _ in range(num_walks):
curr_vertex = random.choice(hyperedge['members... |
def SubsampleAndTraverse(length, num_walks, hyperedges, vertexMemberships, alpha=1.0, beta=0):
walksSAT = []
for hyperedge_index in hyperedges:
hyperedge = hyperedges[hyperedge_index]
walk_vertex = []
curr_vertex = random.choice(hyperedge['members'])
for _ in range(num_walks):
... |
def getFeaturesTrainingData():
i = 0
lists = []
labels = []
for vertex in G.nodes:
vertex_embedding_list = []
lists.append({'f': vertex_features[vertex].tolist()})
labels.append(vertex_labels[vertex])
X_unshuffled = []
for hlist in lists:
x = np.zeros((feature_d... |
def getTrainingData():
i = 0
lists = []
labels = []
for h in hyperedges:
vertex_embedding_list = []
hyperedge = hyperedges[h]
for vertex in hyperedge['members']:
i += 1
if ((i % 100000) == 0):
print(i)
try:
ver... |
def getMLPTrainingData():
i = 0
lists = []
labels = []
maxi = 0
for h in hyperedges:
vertex_embedding_list = []
hyperedge = hyperedges[h]
lists.append({'h': hyperedge_embeddings[hyperedge_ids.index(h)].tolist(), 'f': vertex_features[h].tolist()})
label = np.zeros((n... |
def getDSTrainingData():
i = 0
lists = []
labels = []
maxi = 0
for h in hyperedges:
vertex_embedding_list = []
hyperedge = hyperedges[h]
for vertex in hyperedge['members']:
i += 1
if ((i % 100000) == 0):
print(i)
try:
... |
def hyperedgesTrain(X_train, Y_train, num_epochs):
deephyperedges_transductive_model.load_weights((('models/' + dataset_name) + '/deephyperedges_transductive_model.h5'))
history = deephyperedges_transductive_model.fit(X_train, Y_train, epochs=num_epochs, batch_size=batch_size, shuffle=True, validation_split=0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.