code stringlengths 17 6.64M |
|---|
def beamsearch_hp(datapath, benchmark, backbone, thres, alpha, logpath, candidate_base, candidate_layers, beamsize, maxdepth):
'Implementation of beam search for hyperpixel layers'
device = torch.device(('cuda:0' if torch.cuda.is_available() else 'cpu'))
model = hpflow.HyperpixelFlow(backbone, '0', benchm... |
class CorrespondenceDataset(Dataset):
'Parent class of PFPascal, PFWillow, Caltech, and SPair'
def __init__(self, benchmark, datapath, thres, device, split):
'CorrespondenceDataset constructor'
super(CorrespondenceDataset, self).__init__()
self.metadata = {'pfwillow': ('PF-WILLOW', 't... |
class UnNormalize():
'Image unnormalization'
def __init__(self):
self.mean = [0.485, 0.456, 0.406]
self.std = [0.229, 0.224, 0.225]
def __call__(self, image):
img = image.clone()
for (im_channel, mean, std) in zip(img, self.mean, self.std):
im_channel.mul_(std... |
class Normalize():
'Image normalization'
def __init__(self, image_keys, norm_range=True):
self.image_keys = image_keys
self.norm_range = norm_range
self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
def __call__(self, sample):
for... |
def load_dataset(benchmark, datapath, thres, device, split='test'):
'Instantiate desired correspondence dataset'
correspondence_benchmark = {'pfpascal': pfpascal.PFPascalDataset, 'pfwillow': pfwillow.PFWillowDataset, 'caltech': caltech.CaltechDataset, 'spair': spair.SPairDataset}
dataset = correspondence_... |
def download_from_google(token_id, filename):
'Download desired filename from Google drive'
print(('Downloading %s ...' % os.path.basename(filename)))
url = 'https://docs.google.com/uc?export=download'
destination = (filename + '.tar.gz')
session = requests.Session()
response = session.get(url... |
def get_confirm_token(response):
'Retrieve confirm token'
for (key, value) in response.cookies.items():
if key.startswith('download_warning'):
return value
return None
|
def save_response_content(response, destination):
'Save the response to the destination'
chunk_size = 32768
with open(destination, 'wb') as file:
for chunk in response.iter_content(chunk_size):
if chunk:
file.write(chunk)
|
def download_dataset(datapath, benchmark):
'Download desired semantic correspondence benchmark dataset from Google drive'
if (not os.path.isdir(datapath)):
os.mkdir(datapath)
file_data = {'pfwillow': ('1tDP0y8RO5s45L-vqnortRaieiWENQco_', 'PF-WILLOW'), 'pfpascal': ('1OOwpGzJnTsFXYh-YffMQ9XKM_Kl_zdz... |
class SPairDataset(CorrespondenceDataset):
'Inherits CorrespondenceDataset'
def __init__(self, benchmark, datapath, thres, device, split):
'SPair-71k dataset constructor'
super(SPairDataset, self).__init__(benchmark, datapath, thres, device, split)
self.train_data = open(self.spt_path... |
def run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, beamsearch, model=None, dataloader=None, visualize=False):
'Runs Hyperpixel Flow framework'
if (not os.path.isdir('logs')):
os.mkdir('logs')
if (not beamsearch):
cur_datetime = datetime.datetime.now().__format__('_%m... |
class Evaluator():
'To evaluate and log evaluation metrics: PCK, LT-ACC, IoU'
def __init__(self, benchmark, device):
'Constructor for Evaluator'
self.eval_buf = {'pfwillow': {'pck': [], 'cls_pck': dict()}, 'pfpascal': {'pck': [], 'cls_pck': dict()}, 'spair': {'pck': [], 'cls_pck': dict()}, 'c... |
def correct_kps(trg_kps, prd_kps, pckthres, alpha=0.1):
'Compute the number of correctly transferred key-points'
l2dist = torch.pow(torch.sum(torch.pow((trg_kps - prd_kps), 2), 0), 0.5)
thres = pckthres.expand_as(l2dist).float()
correct_pts = torch.le(l2dist, (thres * alpha))
return torch.sum(corr... |
def pts2ptstr(pts):
'Convert tensor of points to string'
x_str = str(list(pts[0].cpu().numpy()))
x_str = x_str[1:(len(x_str) - 1)]
y_str = str(list(pts[1].cpu().numpy()))
y_str = y_str[1:(len(y_str) - 1)]
return (x_str, y_str)
|
def pts2mask(x_pts, y_pts, shape):
'Build a binary mask tensor base on given xy-points'
(x_idx, y_idx) = draw.polygon(x_pts, y_pts, shape)
mask = np.zeros(shape, dtype=np.bool)
mask[(x_idx, y_idx)] = True
return mask
|
def ptstr2mask(x_str, y_str, out_h, out_w):
'Convert xy-point mask (string) to tensor mask'
x_pts = np.fromstring(x_str, sep=',')
y_pts = np.fromstring(y_str, sep=',')
mask_np = pts2mask(y_pts, x_pts, [out_h, out_w])
mask = torch.tensor(mask_np.astype(np.float32)).unsqueeze(0).unsqueeze(0).float()... |
def intersection_over_union(mask1, mask2):
'Computes IoU between two masks'
rel_part_weight = (torch.sum(torch.sum(mask2.gt(0.5).float(), 2, True), 3, True) / torch.sum(mask2.gt(0.5).float()))
part_iou = (torch.sum(torch.sum((mask1.gt(0.5) & mask2.gt(0.5)).float(), 2, True), 3, True) / torch.sum(torch.sum... |
def label_transfer_accuracy(mask1, mask2):
'LT-ACC measures the overlap with emphasis on the background class'
return torch.mean((mask1.gt(0.5) == mask2.gt(0.5)).double()).item()
|
def init_logger(logfile):
'Initialize logging settings'
logging.basicConfig(filemode='w', filename=logfile, level=logging.INFO, format='%(message)s', datefmt='%m-%d %H:%M:%S')
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(message)s')
console.... |
def log_args(args):
'Log program arguments'
logging.info('\n+========== Hyperpixel Flow Arguments ===========+')
for arg_key in args.__dict__:
logging.info(('| %20s: %-24s |' % (arg_key, str(args.__dict__[arg_key]))))
logging.info('+================================================+\n')
|
def resize(img, kps, side_thres=300):
'Resize given image with imsize: (1, 3, H, W)'
imsize = torch.tensor(img.size()).float()
kps = kps.float()
side_max = torch.max(imsize)
inter_ratio = 1.0
if (side_max > side_thres):
inter_ratio = (side_thres / side_max)
img = F.interpolate(... |
def where(predicate):
'Returns indices which match given predicate'
matching_idx = predicate.nonzero()
n_match = len(matching_idx)
if (n_match != 0):
matching_idx = matching_idx.t().squeeze(0)
return matching_idx
|
def intersect1d(tensor1, tensor2):
'Takes two 1D tensor and returns tensor of common values'
aux = torch.cat((tensor1, tensor2), dim=0)
aux = aux.sort()[0]
return aux[:(- 1)][(aux[1:] == aux[:(- 1)]).data]
|
def parse_hyperpixel(hyperpixel_ids):
'Parse given hyperpixel list (string -> int)'
return list(map(int, re.findall('\\d+', hyperpixel_ids)))
|
def visualize_prediction(src_kps, prd_kps, src_img, trg_img, vispath, relaxation=2000):
'TPS transform source image using predicted correspondences'
src_imsize = src_img.size()[1:][::(- 1)]
trg_imsize = trg_img.size()[1:][::(- 1)]
img_tps = geometry.ImageTPS(src_kps, prd_kps, src_imsize, trg_imsize, r... |
class GroundTruthDatasetFactory(Dataset):
'\n Factory to create projection datasets from any 2D image-data.\n\n This is essentially a simple version of dival[1] without any noise contribution.\n\n References:\n [1] Johannes Leuschner, Maximilian Schmidt, Daniel Otero Baguer, and Peter Maaß.\n ... |
class SResFourierCoefficientDataset(Dataset):
def __init__(self, ds, amp_min, amp_max):
self.ds = ds
if ((amp_min == None) and (amp_max == None)):
tmp_imgs = []
for i in np.random.permutation(len(self.ds))[:200]:
img = self.ds[i]
tmp_imgs.ap... |
class TRecFourierCoefficientDataset(Dataset):
def __init__(self, ds, angles, mag_min, mag_max, img_shape=42, inner_circle=True):
self.ds = ds
self.img_shape = img_shape
self.inner_circle = inner_circle
self.angles = angles
if ((mag_min == None) and (mag_max == None)):
... |
def _fc_prod_loss(pred_fc, target_fc, amp_min, amp_max):
pred_amp = denormalize_amp(pred_fc[(..., 0)], amp_min=amp_min, amp_max=amp_max)
target_amp = denormalize_amp(target_fc[(..., 0)], amp_min=amp_min, amp_max=amp_max)
pred_phi = denormalize_phi(pred_fc[(..., 1)])
target_phi = denormalize_phi(target... |
def _fc_sum_loss(pred_fc, target_fc, amp_min, amp_max):
pred_amp = denormalize_amp(pred_fc[(..., 0)], amp_min=amp_min, amp_max=amp_max)
target_amp = denormalize_amp(target_fc[(..., 0)], amp_min=amp_min, amp_max=amp_max)
pred_phi = denormalize_phi(pred_fc[(..., 1)])
target_phi = denormalize_phi(target_... |
class SResTransformerTrain(torch.nn.Module):
def __init__(self, d_model, coords, flatten_order, attention_type='linear', n_layers=4, n_heads=4, d_query=32, dropout=0.1, attention_dropout=0.1):
super(SResTransformerTrain, self).__init__()
self.fourier_coefficient_embedding = torch.nn.Linear(2, (d_... |
class SResTransformerPredict(torch.nn.Module):
def __init__(self, d_model, coords, flatten_order, attention_type='full', n_layers=4, n_heads=4, d_query=32, dropout=0.1, attention_dropout=0.1):
super(SResTransformerPredict, self).__init__()
self.fourier_coefficient_embedding = torch.nn.Linear(2, (... |
class RAdam(Optimizer):
def __init__(self, params, lr=0.001, max_grad_norm=1.0, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, degenerated_to_sgd=True):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
raise ValueError('... |
class PlainRAdam(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, degenerated_to_sgd=True):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
raise ValueError('Invalid epsilo... |
class AdamW(Optimizer):
def __init__(self, params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, warmup=0):
if (not (0.0 <= lr)):
raise ValueError('Invalid learning rate: {}'.format(lr))
if (not (0.0 <= eps)):
raise ValueError('Invalid epsilon value: {}'.format(... |
class TestTomoUtils(unittest.TestCase):
def setUp(self) -> None:
self.img_shape = 27
self.angles = np.array([0, (np.pi / 2), np.pi])
def test_cartesian_rfft_2D(self):
(x, y, flatten_indices, order) = get_cartesian_rfft_coords_2D(self.img_shape)
x_ordered = torch.zeros_like(x)... |
class TestUtils(unittest.TestCase):
def test_cart2pol2cart(self):
x = torch.arange(1, 6, dtype=torch.float32)
y = torch.arange((- 2), 3, dtype=torch.float32)
(r, phi) = cart2pol(x, y)
(x_, y_) = pol2cart(r, phi)
self.assertTrue((torch.allclose(x, x_) and torch.allclose(y, ... |
def has_file_allowed_extension(filename: str, extensions: Tuple[(str, ...)]) -> bool:
return filename.lower().endswith(extensions)
|
def make_subsampled_dataset(directory, class_to_idx, extensions=None, is_valid_file=None, sampling_ratio=1.0, nb_classes=None):
instances = []
directory = os.path.expanduser(directory)
both_none = ((extensions is None) and (is_valid_file is None))
both_something = ((extensions is not None) and (is_val... |
class INatDataset(ImageFolder):
def __init__(self, root, train=True, year=2018, transform=None, target_transform=None, category='name', loader=default_loader):
self.transform = transform
self.loader = loader
self.target_transform = target_transform
self.year = year
path_js... |
class SubsampledDatasetFolder(DatasetFolder):
def __init__(self, root, loader, extensions=None, transform=None, target_transform=None, is_valid_file=None, sampling_ratio=1.0, nb_classes=None):
super(DatasetFolder, self).__init__(root, transform=transform, target_transform=target_transform)
(class... |
class ImageNetDataset(SubsampledDatasetFolder):
def __init__(self, root, loader=default_loader, is_valid_file=None, **kwargs):
super(ImageNetDataset, self).__init__(root, loader, (IMG_EXTENSIONS if (is_valid_file is None) else None), is_valid_file=is_valid_file, **kwargs)
self.imgs = self.samples... |
def build_dataset(is_train, args):
transform = build_transform(is_train, args)
if (args.data_set == 'CIFAR10'):
dataset = datasets.CIFAR10(args.data_path, train=is_train, transform=transform, download=True)
nb_classes = 10
if (args.data_set == 'CIFAR100'):
dataset = datasets.CIFAR1... |
def build_transform(is_train, args):
resize_im = (args.input_size > 32)
if is_train:
transform = create_transform(input_size=args.input_size, is_training=True, color_jitter=args.color_jitter, auto_augment=args.aa, interpolation=args.train_interpolation, re_prob=args.reprob, re_mode=args.remode, re_cou... |
def train_one_epoch(model: torch.nn.Module, criterion: torch.nn.Module, data_loader: Iterable, optimizer: torch.optim.Optimizer, device: torch.device, epoch: int, loss_scaler, max_norm: float=0, model_ema: Optional[ModelEma]=None, mixup_fn: Optional[Mixup]=None):
model.train()
criterion.train()
metric_log... |
@torch.no_grad()
def evaluate(data_loader, model, device):
criterion = torch.nn.CrossEntropyLoss()
metric_logger = utils.MetricLogger(delimiter=' ')
header = 'Test:'
model.eval()
for (images, target) in metric_logger.log_every(data_loader, 10, header):
images = images.to(device, non_block... |
def get_args_parser():
parser = argparse.ArgumentParser('PerViT training and evaluation script', add_help=False)
parser.add_argument('--batch-size', default=256, type=int)
parser.add_argument('--epochs', default=300, type=int)
parser.add_argument('--model', default='pervit_tiny', type=str, metavar='MO... |
def main(args):
utils.init_distributed_mode(args)
if utils.is_main_process():
tbd_writer = SummaryWriter(os.path.join(args.output_dir, 'tbd/runs'))
print(args)
device = torch.device(args.device)
seed = (args.seed + utils.get_rank())
print('seed: ', seed)
np.random.seed(seed)
to... |
@register_model
def pervit_tiny(pretrained=False, **kwargs):
num_heads = 4
kwargs['emb_dims'] = [128, 192, 224, 280]
kwargs['convstem_dims'] = [3, 48, 64, 96, 128]
model = VisionTransformer(num_heads=num_heads, norm_layer=partial(nn.LayerNorm, eps=1e-06), **kwargs)
model.default_cfg = _cfg()
r... |
@register_model
def pervit_small(pretrained=False, **kwargs):
num_heads = 8
kwargs['emb_dims'] = [272, 320, 368, 464]
kwargs['convstem_dims'] = [3, 64, 128, 192, 272]
model = VisionTransformer(num_heads=num_heads, norm_layer=partial(nn.LayerNorm, eps=1e-06), **kwargs)
model.default_cfg = _cfg()
... |
@register_model
def pervit_medium(pretrained=False, **kwargs):
num_heads = 12
kwargs['emb_dims'] = [312, 468, 540, 684]
kwargs['convstem_dims'] = [3, 64, 192, 256, 312]
model = VisionTransformer(num_heads=num_heads, norm_layer=partial(nn.LayerNorm, eps=1e-06), **kwargs)
model.default_cfg = _cfg()
... |
class OffsetGenerator():
@classmethod
def initialize(cls, n_patch_side, pad_size):
grid_1d = torch.linspace((- 1), 1, n_patch_side).to('cuda')
if (pad_size > 0):
pad_dist = torch.cumsum((grid_1d[(- 1)] - grid_1d[(- 2)]).repeat(pad_size), dim=0)
grid_1d = torch.cat([((-... |
class RASampler(torch.utils.data.Sampler):
'Sampler that restricts data loading to a subset of the dataset for distributed,\n with repeated augmentation.\n It ensures that different each augmented version of a sample will be visible to a\n different process (GPU)\n Heavily based on torch.utils.data.Di... |
class SmoothedValue(object):
'Track a series of values and provide access to smoothed values over a\n window or the global series average.\n '
def __init__(self, window_size=20, fmt=None):
if (fmt is None):
fmt = '{median:.4f} ({global_avg:.4f})'
self.deque = deque(maxlen=wi... |
class MetricLogger(object):
def __init__(self, delimiter='\t'):
self.meters = defaultdict(SmoothedValue)
self.delimiter = delimiter
def update(self, **kwargs):
for (k, v) in kwargs.items():
if isinstance(v, torch.Tensor):
v = v.item()
assert is... |
def _load_checkpoint_for_ema(model_ema, checkpoint):
'\n Workaround for ModelEma._load_checkpoint to accept an already-loaded object\n '
mem_file = io.BytesIO()
torch.save(checkpoint, mem_file)
mem_file.seek(0)
model_ema._load_checkpoint(mem_file)
|
def setup_for_distributed(is_master):
'\n This function disables printing when not in master process\n '
import builtins as __builtin__
builtin_print = __builtin__.print
def print(*args, **kwargs):
force = kwargs.pop('force', False)
if (is_master or force):
builtin_p... |
def is_dist_avail_and_initialized():
if (not dist.is_available()):
return False
if (not dist.is_initialized()):
return False
return True
|
def get_world_size():
if (not is_dist_avail_and_initialized()):
return 1
return dist.get_world_size()
|
def get_rank():
if (not is_dist_avail_and_initialized()):
return 0
return dist.get_rank()
|
def is_main_process():
return (get_rank() == 0)
|
def save_on_master(*args, **kwargs):
if is_main_process():
torch.save(*args, **kwargs)
|
def init_distributed_mode(args):
if (('RANK' in os.environ) and ('WORLD_SIZE' in os.environ)):
args.rank = int(os.environ['RANK'])
args.world_size = int(os.environ['WORLD_SIZE'])
args.gpu = int(os.environ['LOCAL_RANK'])
elif ('SLURM_PROCID' in os.environ):
args.rank = int(os.en... |
@torch.no_grad()
def compute_throughput(model, batch_size=128, resolution=224):
torch.cuda.empty_cache()
warmup_iters = 3
num_iters = 30
model.eval()
model.to('cuda')
timing = []
inputs = torch.randn(batch_size, 3, resolution, resolution, device='cuda')
for _ in range(warmup_iters):
... |
def download_from_google_drive(file_id, output_dir):
url = ('https://drive.google.com/uc?id=%s' % 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)... |
def get_data(params, dataset_name, subset=None):
load_test = (('train_all' in params) and params['train_all'])
test_dataset = None
transform = transforms.Compose([transforms.ToTensor()])
if (dataset_name == 'mnist'):
dataset = datasets.mnist.MNIST(root=config.DATASETS_DIR, download=True, trans... |
def attach_handlers(run, model, optimizer, learning_rule, trainer, evaluator, train_loader, val_loader, params):
UnitConvergence(model[0], learning_rule.norm).attach(trainer.engine, 'unit_conv')
pbar = ProgressBar(persist=True, bar_format=config.IGNITE_BAR_FORMAT)
pbar.attach(trainer.engine, metric_names=... |
def main(args: Namespace, params: dict, dataset_name, run_postfix=''):
identifier = time.strftime('%Y%m%d-%H%M%S')
run = '{}/heb/{}'.format(dataset_name, identifier)
if run_postfix:
run += ('-' + run_postfix)
print("Starting run '{}'".format(run))
model = models.create_conv1_model(28, 1, n... |
def main():
model = models.create_fc1_model([(28 ** 2), 2000])
transform = transforms.Compose([transforms.ToTensor()])
dataset = datasets.mnist.MNIST(root=config.DATASETS_DIR, download=True, transform=transform)
train_loader = DataLoader(dataset, batch_size=1024, shuffle=True)
learning_rule = Krot... |
def create_fc1_model(hu: List, n: float=1.0, batch_norm=False):
modules = [('flatten', Flatten()), ('linear1', nn.Linear(hu[0], hu[1], bias=False))]
if batch_norm:
modules.append(('batch_norm', nn.BatchNorm1d(num_features=hu[1])))
modules.append(('repu', RePU(n)))
linear2 = nn.Linear(hu[1], 10... |
def create_fc2_model(hu: List, n: float=1.0, batch_norm=False):
modules = [('flatten', Flatten()), ('linear1', nn.Linear(hu[0], hu[1], bias=False))]
if batch_norm:
modules.append(('batch_norm', nn.BatchNorm1d(num_features=hu[1])))
modules.append(('repu1', RePU(n)))
modules.append(('linear2', n... |
def create_conv1_model(input_dim, input_channels=1, num_kernels=8, kernel_size=5, pool_size=2, n=1, batch_norm=False, dropout=None):
modules = [('conv1', nn.Conv2d(input_channels, num_kernels, kernel_size, bias=False))]
if batch_norm:
modules.append(('batch_norm', nn.BatchNorm2d(num_features=num_kerne... |
def create_conv2_model(input_dim, input_channels=1, num_kernels=None, kernel_size=4, pool_size=2, n=1):
if (num_kernels is None):
num_kernels = [8, 16]
modules = [('conv1', nn.Conv2d(input_channels, num_kernels[0], kernel_size, bias=False)), ('repu1', RePU(n)), ('pool1', nn.MaxPool2d(pool_size)), ('co... |
def attach_handlers(run, model, optimizer, trainer, train_evaluator, evaluator, train_loader, val_loader, params):
pbar = ProgressBar(persist=True, bar_format=config.IGNITE_BAR_FORMAT)
pbar.attach(trainer.engine, metric_names='all')
tqdm_logger = TqdmLogger(pbar=pbar)
tqdm_logger.attach_output_handler... |
def main(params, dataset_name, transfer_learning=False):
identifier = time.strftime('%Y%m%d-%H%M%S')
run = '{}/sup/{}'.format(dataset_name, identifier)
if transfer_learning:
run += '-tl'
if (('train_all' in params) and params['train_all']):
run += '-test'
print("Starting run '{}'".... |
def main(params):
model = models.create_fc1_model([(28 ** 2), 2000], n=1, batch_norm=True)
weights_path = '../output/models/heb-mnist-fashion-20200426-101420_m_500_acc=0.852.pth'
state_dict_path = os.path.join(PATH, weights_path)
model = load_weights(model, state_dict_path)
run = os.path.splitext(... |
class SimpleEngine(Engine):
'Custom engine with custom run function.\n\n This engine has only metrics in its state and only fires 2 events.\n '
def __init__(self, run_function: Callable):
super().__init__(process_function=(lambda x, y: None))
self._allowed_events = [Events.STARTED, Even... |
class Evaluator(ABC):
def __init__(self):
self.engine = None
self.logger = logging.getLogger(((__name__ + '.') + self.__class__.__name__))
def attach(self, engine, event_name, *args, **kwargs):
if (event_name not in State.event_to_attr):
raise RuntimeError("Unknown event ... |
class HebbianEvaluator(Evaluator):
def __init__(self, model: torch.nn.Module, score_name: str, score_function: Callable, init_function: Callable[([torch.nn.Module], tuple)]=None, epochs: int=100, supervised_from: int=None):
super().__init__()
self.model = model
self.score_name = score_nam... |
class SupervisedEvaluator(Evaluator):
def __init__(self, model, criterion, metrics=None, device=None):
super().__init__()
self.device = utils.get_device(device)
if (metrics is None):
metrics = {'accuracy': Accuracy(), 'loss': Loss(criterion)}
self.engine = create_super... |
class OutputHandler(BaseOutputHandler):
'Helper handler to log engine\'s output and/or metrics.\n\n Args:\n tag (str): common title for all produced plots. For example, \'training\'\n metric_names (list of str, optional): list of metric names to plot or a string "all" to plot all available\n ... |
class TqdmLogger(BaseLogger):
'Tqdm logger to log messages using the progress bar.'
def __init__(self, pbar):
self.pbar = pbar
def close(self):
if self.pbar:
self.pbar.close()
self.pbar = None
def _create_output_handler(self, *args, **kwargs):
return Outp... |
class HebbsRule(LearningRule):
def __init__(self, c=0.1):
super().__init__()
self.c = c
def update(self, inputs, w):
d_ws = torch.zeros(inputs.size(0))
for (idx, x) in enumerate(inputs):
y = torch.dot(w, x)
d_w = torch.zeros(w.shape)
for i ... |
class KrotovsRule(LearningRule):
'Krotov-Hopfield Hebbian learning rule fast implementation.\n\n Original source: https://github.com/DimaKrotov/Biological_Learning\n\n Args:\n precision: Numerical precision of the weight updates.\n delta: Anti-hebbian learning strength.\n norm: Lebesgue... |
class LearningRule(ABC):
def __init__(self):
self.logger = logging.getLogger(((__name__ + '.') + self.__class__.__name__))
def init_layers(self, model):
pass
@abstractmethod
def update(self, x, w):
pass
|
class OjasRule(LearningRule):
def __init__(self, c=0.1):
super().__init__()
self.c = c
def update(self, inputs, w):
d_ws = torch.zeros(inputs.size(0), *w.shape)
for (idx, x) in enumerate(inputs):
y = torch.mm(w, x.unsqueeze(1))
d_w = torch.zeros(w.shap... |
class UnitConvergence(Metric):
def __init__(self, layer: torch.nn.Module, norm: int, tolerance: int=0.1, output_transform=(lambda x: x), device=None):
self.layer = layer
self.norm = norm
self.tolerance = tolerance
super(UnitConvergence, self).__init__(output_transform=output_trans... |
class Flatten(nn.Module):
def forward(self, x: torch.Tensor):
return x.view(x.size(0), (- 1))
|
class RePU(nn.ReLU):
def __init__(self, n):
super(RePU, self).__init__()
self.n = n
def forward(self, x: torch.Tensor):
return (torch.relu(x) ** self.n)
|
class SPELoss(Module):
def __init__(self, m=1, beta=0.1):
super(SPELoss, self).__init__()
self.m = m
self.beta = beta
def forward(self, output, target):
output = torch.tanh((self.beta * output))
target = ((torch.nn.functional.one_hot(target, num_classes=output.shape[1... |
class Local(Optimizer):
def __init__(self, named_params, lr=required):
(self.param_names, params) = zip(*named_params)
if ((lr is not required) and (lr < 0.0)):
raise ValueError('Invalid learning rate: {}'.format(lr))
defaults = dict(lr=lr)
super(Local, self).__init__(... |
class Trainer(ABC):
'Abstract base trainer class.\n\n Supports (optional) evaluating and visualizing by default.\n '
def __init__(self, engine, model: torch.nn.Module, device: Optional[Union[(str, torch.device)]]=None):
self.engine = engine
self.model = model
self.device = utils... |
class SupervisedTrainer(Trainer):
'Trains a model using classical supervised backpropagation.\n\n Args:\n model: The model to be trained.\n optimizer: The optimizer used to train the model.\n criterion: The criterion used for calculating the loss.\n device: The device to be used.\n ... |
class HebbianTrainer(Trainer):
'Trains a model using unsupervised local learning rules also known as Hebbian learning.\n\n The specified learning rule is used to perform local weight updates after each batch of data. Per batch all\n trainable layers are updated in sequence.\n\n Args:\n model (torc... |
def plot_to_img(fig):
'Takes a matplotlib figure handle and converts it using canvas and string-casts to a numpy array that can be\n visualized in TensorBoard using the add_image function\n '
fig.canvas.draw()
img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
img = img.resha... |
def extract_image_patches(x, kernel_size, stride=(1, 1), dilation=1, padding=0):
(b, c, h, w) = x.shape
patches = x.unfold(2, kernel_size[0], stride[0]).unfold(3, kernel_size[1], stride[1])
patches = patches.permute(0, 4, 5, 1, 2, 3).contiguous()
return patches.view((- 1), kernel_size[0], kernel_size[... |
def split_dataset(dataset, val_split):
val_size = int((val_split * len(dataset)))
train_size = (len(dataset) - val_size)
(train_dataset, val_dataset) = random_split(dataset, [train_size, val_size])
return (train_dataset, val_dataset)
|
def prepare_batch(batch, device=None, non_blocking=False):
'Prepare batch for training: pass to a device with options.'
(x, y) = batch
return (convert_tensor(x, device=device, non_blocking=non_blocking), convert_tensor(y, device=device, non_blocking=non_blocking))
|
def load_weights(model: torch.nn.Module, state_dict_path, layer_names: List=None, freeze=False):
'Load model weights from a stored state dict. Optionally only load weights for the specified layer.\n\n Args:\n model: The model acquiring the weights.\n state_dict_path: The path of the source state ... |
def extract_layers_from_state_dict(state_dict: dict, layer_names: List[str]):
'Extract layers from a state dict.'
new_state_dict = {}
for layer_name in layer_names:
if (type(layer_name) == tuple):
old_layer_name = layer_name[0]
new_layer_name = layer_name[1]
else:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.