xmodar

from math import log

import torch
from torch import nn

class L0Sparse(nn.Module):
    def __init__(self, layer, init_sparsity=0.5, heat=2 / 3, stretch=0.1):
        assert all(0 < x < 1 for x in [init_sparsity, heat, stretch])
        super().__init__()
        self.layer = layer

xmodar

import torch


def unravel_index(index, shape):
    out = []
    for dim in reversed(shape):
        out.append(index % dim)
        index = index // dim
    return tuple(reversed(out))

xmodar

from argparse import Namespace

import torch


def grid_search(objective, *bounds, density=10, eps=1e-5, max_steps=None):
    """Perfrom coarse-to-fine grid search for the minimum objective.

    >>> def f(x, y):
    >>>     x = x + 0.5

xmodar

import torch
from torch import nn
from torch import functional as F


class Expression:
    def __init__(self, out=None, **units):
        self.out = out
        self.terms = {}
        self.coeffs = {}

xmodar

class LARC:
    """Layer-wise Adaptive Rate Control.

    LARC is LARS that supports clipping along with scaling:
    https://arxiv.org/abs/1708.03888

    This implementation is inspired by:
    https://github.com/NVIDIA/apex/blob/master/apex/parallel/LARC.py

    See also:

xmodar

import json
import math
from argparse import ArgumentParser
from contextlib import contextmanager
from pathlib import Path

import torch
import torchvision.transforms as T
from torch import nn
from torch.optim import lr_scheduler

xmodar

import numpy as np
from PIL import Image
from skimage.color import lab2rgb, rgb2lab


class RandomColorToning:

    def __init__(self, scale_mean, scale_std, shift_mean, shift_std):
        self.scale_mean = scale_mean
        self.scale_std = scale_std

xmodar

from torch import nn


class Generator(nn.Module):

    def __init__(self, input_dim, image_shape, memory):
        super().__init__()
        self.memory = memory
        self.input_dim = input_dim
        self.image_shape = image_shape

xmodar

"""Matrix square root: https://github.com/pytorch/pytorch/issues/25481"""
import torch


def psd_matrix_sqrt(matrix, num_iterations=20):
    """Compute the square root of a PSD matrix using Newton's method.

    This implementation was adopted from code by @JonathanVacher.
    https://gist.github.com/ModarTensai/7c4aeb3d75bf1e0ab99b24cf2b3b37a3
    """

xmodar

from typing import Tuple, Optional, Union, List

import torch
import torch.nn as nn

__all__ = [
    'dot', 'get_neighbors', 'gather_features', 'point_sparsity',
    'weighted_sampling'
]