kalfa 3.0.0.dev0__py3-none-any.whl

kalfa/std/data/transforms.py

@@ -0,0 +1,327 @@
+import inspect
+
+import numpy
+import torch
+import torch.nn.functional as functional
+from PIL import Image
+
+from kalfa.core import aliases
+from kalfa.core.aliases import register
+from kalfa.core.errors import BuildError, RunError
+from kalfa.std.data.columns import target_of
+
+
+PRESETS = {
+    "imagenet": ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    "cifar10": ([0.4914, 0.4822, 0.4465], [0.2470, 0.2435, 0.2616]),
+    "mnist": ([0.1307], [0.3081]),
+}
+
+GRAY_WEIGHTS = (0.299, 0.587, 0.114)
+PIL_MODES = ("1", "L", "LA", "RGB", "RGBA", "I", "I;16", "F")
+
+
+def built(target, params, where):
+    try:
+        made = target(**params)
+    except BuildError:
+        raise
+    except Exception as failure:
+        raise BuildError(f"{where}: {aliases.target_path(target)} could not be built: {type(failure).__name__}: "
+                         f"{failure}") from failure
+    if not callable(made):
+        raise BuildError(f"{where}: {aliases.target_path(target)} gave a {type(made).__name__}, which is not a "
+                         f"callable image -> image")
+    return made
+
+
+def transform_of(spec, where):
+    if isinstance(spec, str):
+        target = target_of(spec, where)
+        if inspect.isclass(target):
+            return built(target, {}, where)
+        if callable(target):
+            return target
+        raise BuildError(f"{where}: {spec!r} is a {type(target).__name__}, not a transform")
+    if isinstance(spec, dict):
+        if "use" not in spec:
+            raise BuildError(f"{where}: a transform call needs use, got the keys {sorted(spec)}")
+        params = {key: value for key, value in spec.items() if key != "use"}
+        return built(target_of(spec["use"], where), params, where)
+    if inspect.isclass(spec):
+        return built(spec, {}, where)
+    if callable(spec):
+        return spec
+    raise BuildError(f"{where}: a transform is a short name, an import path, a call or a callable object, got "
+                     f"{type(spec).__name__}")
+
+
+def name_of(spec):
+    if isinstance(spec, str):
+        return spec
+    if isinstance(spec, dict):
+        return str(spec.get("use"))
+    path = aliases.target_path(spec if inspect.isclass(spec) or inspect.isroutine(spec) else type(spec))
+    for name, entry in aliases.ALIASES.items():
+        if entry.slot == "value" and aliases.target_path(entry.target) == path:
+            return name
+    return path
+
+
+class Pipeline:
+    def __init__(self, steps=(), names=()):
+        self.steps = list(steps)
+        self.names = list(names)
+
+    def __call__(self, image):
+        for step in self.steps:
+            image = step(image)
+        return image
+
+
+def pipeline_of(specs, where):
+    if specs is None:
+        return Pipeline()
+    if isinstance(specs, Pipeline):
+        return specs
+    items = list(specs) if isinstance(specs, (list, tuple)) else [specs]
+    steps = [transform_of(item, f"{where}[{position}]") for position, item in enumerate(items)]
+    return Pipeline(steps, [name_of(item) for item in items])
+
+
+def pil_array(image):
+    if image.mode not in PIL_MODES:
+        image = image.convert("RGB")
+    return numpy.array(image)
+
+
+def array_tensor(array):
+    if array.dtype == numpy.uint8:
+        values = array.astype(numpy.float32) / 255.0
+    elif array.dtype == numpy.uint16:
+        values = array.astype(numpy.float32) / 65535.0
+    else:
+        values = array.astype(numpy.float32)
+    if values.ndim == 2:
+        values = values[None]
+    elif values.ndim == 3:
+        values = values.transpose(2, 0, 1)
+    else:
+        raise RunError(f"to_tensor takes an array of shape (H, W) or (H, W, C), got {array.shape}")
+    return torch.from_numpy(numpy.ascontiguousarray(values, dtype=numpy.float32))
+
+
+class ToTensor:
+    def __call__(self, image):
+        if isinstance(image, torch.Tensor):
+            return image
+        if isinstance(image, Image.Image):
+            return array_tensor(pil_array(image))
+        if isinstance(image, numpy.ndarray):
+            return array_tensor(image)
+        raise RunError(f"to_tensor takes a PIL image, an array or a tensor, got {type(image).__name__}")
+
+
+def image_tensor(value):
+    tensor = value if isinstance(value, torch.Tensor) else ToTensor()(value)
+    if tensor.dtype == torch.uint8:
+        tensor = tensor.to(torch.float32) / 255.0
+    elif tensor.dtype != torch.float32:
+        tensor = tensor.to(torch.float32)
+    if tensor.ndim == 2:
+        tensor = tensor.unsqueeze(0)
+    if tensor.ndim < 3:
+        raise RunError(f"an image tensor is (C, H, W), got the shape {tuple(tensor.shape)}")
+    return tensor
+
+
+def preset_of(name):
+    key = str(name).lower()
+    if key not in PRESETS:
+        raise BuildError(f"normalize: unknown preset {name!r}; the presets are {sorted(PRESETS)}")
+    return PRESETS[key]
+
+
+def values_of(value, what):
+    if isinstance(value, torch.Tensor):
+        value = value.flatten().tolist()
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return [float(value)]
+    if (isinstance(value, (list, tuple)) and value
+            and all(isinstance(item, (int, float)) and not isinstance(item, bool) for item in value)):
+        return [float(item) for item in value]
+    raise BuildError(f"normalize: {what} is a number, a list of numbers or a preset name ({', '.join(PRESETS)}), "
+                     f"got {value!r}")
+
+
+def per_channel(values, channels, what):
+    if len(values) == channels:
+        return values
+    if len(values) == 1:
+        return values * channels
+    raise RunError(f"normalize: {len(values)} {what} values for an image of {channels} channels")
+
+
+class Normalize:
+    def __init__(self, mean=0.5, std=None):
+        if isinstance(mean, str):
+            mean, preset_std = preset_of(mean)
+            if std is None:
+                std = preset_std
+        if std is None:
+            std = 0.5
+        if isinstance(std, str):
+            std = preset_of(std)[1]
+        self.mean = values_of(mean, "mean")
+        self.std = values_of(std, "std")
+        if any(value <= 0.0 for value in self.std):
+            raise BuildError(f"normalize: std must be positive, got {self.std}")
+        if len(self.mean) != len(self.std) and 1 not in (len(self.mean), len(self.std)):
+            raise BuildError(f"normalize: mean has {len(self.mean)} values and std {len(self.std)}")
+
+    def __call__(self, image):
+        floating = isinstance(image, torch.Tensor) and image.is_floating_point() and image.ndim >= 3
+        tensor = image if floating else image_tensor(image)
+        channels = int(tensor.shape[-3])
+        shape = (channels, 1, 1)
+        mean = torch.tensor(per_channel(self.mean, channels, "mean"), dtype=tensor.dtype, device=tensor.device)
+        std = torch.tensor(per_channel(self.std, channels, "std"), dtype=tensor.dtype, device=tensor.device)
+        return (tensor - mean.view(shape)) / std.view(shape)
+
+
+class TwoViews:
+    def __init__(self, each):
+        self.each = pipeline_of(each, "two_views.each")
+
+    def __call__(self, image):
+        return torch.stack([image_tensor(self.each(image)), image_tensor(self.each(image))])
+
+
+def size_of(size, what):
+    if isinstance(size, int) and not isinstance(size, bool) and size > 0:
+        return size, size
+    if (isinstance(size, (list, tuple)) and len(size) == 2
+            and all(isinstance(item, int) and not isinstance(item, bool) and item > 0 for item in size)):
+        return int(size[0]), int(size[1])
+    raise BuildError(f"{what}: size is a positive integer or [height, width], got {size!r}")
+
+
+def extent(image):
+    if isinstance(image, Image.Image):
+        return image.height, image.width
+    return int(image.shape[-2]), int(image.shape[-1])
+
+
+def crop(image, top, left, height, width):
+    if isinstance(image, Image.Image):
+        return image.crop((left, top, left + width, top + height))
+    out = image.new_zeros((*image.shape[:-2], height, width))
+    full_height, full_width = extent(image)
+    first_row, first_column = max(top, 0), max(left, 0)
+    last_row, last_column = min(top + height, full_height), min(left + width, full_width)
+    if last_row > first_row and last_column > first_column:
+        piece = image[..., first_row:last_row, first_column:last_column]
+        out[..., first_row - top:last_row - top, first_column - left:last_column - left] = piece
+    return out
+
+
+def planar(image):
+    return image if isinstance(image, Image.Image) else image_tensor(image)
+
+
+class Resize:
+    def __init__(self, size):
+        self.size = size_of(size, "resize")
+
+    def __call__(self, image):
+        height, width = self.size
+        image = planar(image)
+        if isinstance(image, Image.Image):
+            return image.resize((width, height), Image.Resampling.BILINEAR)
+        batched = image if image.ndim == 4 else image.unsqueeze(0)
+        out = functional.interpolate(batched, size=(height, width), mode="bilinear", align_corners=False,
+                                     antialias=True)
+        return out if image.ndim == 4 else out.squeeze(0)
+
+
+class CenterCrop:
+    def __init__(self, size):
+        self.size = size_of(size, "center_crop")
+
+    def __call__(self, image):
+        height, width = self.size
+        image = planar(image)
+        full_height, full_width = extent(image)
+        top = int(round((full_height - height) / 2.0))
+        left = int(round((full_width - width) / 2.0))
+        return crop(image, top, left, height, width)
+
+
+def offset(span):
+    if span <= 0:
+        return int(round(span / 2.0))
+    return int(torch.randint(0, span + 1, (1,)).item())
+
+
+class RandomCrop:
+    def __init__(self, size, padding=0):
+        self.size = size_of(size, "random_crop")
+        if isinstance(padding, bool) or not isinstance(padding, int) or padding < 0:
+            raise BuildError(f"random_crop: padding is a non negative integer, got {padding!r}")
+        self.padding = padding
+
+    def __call__(self, image):
+        height, width = self.size
+        image = planar(image)
+        full_height, full_width = extent(image)
+        top = offset(full_height + 2 * self.padding - height) - self.padding
+        left = offset(full_width + 2 * self.padding - width) - self.padding
+        return crop(image, top, left, height, width)
+
+
+class RandomFlip:
+    def __init__(self, p=0.5):
+        if isinstance(p, bool) or not isinstance(p, (int, float)) or not 0.0 <= float(p) <= 1.0:
+            raise BuildError(f"random_flip: p is a probability in [0, 1], got {p!r}")
+        self.p = float(p)
+
+    def __call__(self, image):
+        image = planar(image)
+        if float(torch.rand(())) >= self.p:
+            return image
+        if isinstance(image, Image.Image):
+            return image.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
+        return torch.flip(image, dims=(-1,))
+
+
+class Grayscale:
+    def __call__(self, image):
+        image = planar(image)
+        if isinstance(image, Image.Image):
+            return image if image.mode == "L" else image.convert("L")
+        channels = int(image.shape[-3])
+        if channels == 1:
+            return image
+        if channels in (3, 4):
+            weights = image.new_tensor(GRAY_WEIGHTS).view(3, 1, 1)
+            return (image[..., :3, :, :] * weights).sum(dim=-3, keepdim=True)
+        raise RunError(f"grayscale takes an image of 1, 3 or 4 channels, got {channels}")
+
+
+REGISTRATIONS = (
+    ("to_tensor", "kalfa.std.data.transforms.ToTensor",
+     "a PIL image or an array becomes a float tensor (C, H, W) in [0, 1]; a tensor passes through"),
+    ("normalize", "kalfa.std.data.transforms.Normalize",
+     "(x - mean) / std per channel; mean and std are numbers, lists or a preset name: imagenet, cifar10, mnist"),
+    ("two_views", "kalfa.std.data.transforms.TwoViews",
+     "applies the each pipeline twice with fresh randomness and stacks the two results into (2, C, H, W)"),
+    ("resize", "kalfa.std.data.transforms.Resize",
+     "resize a PIL image or a tensor to size (an int or [height, width])"),
+    ("center_crop", "kalfa.std.data.transforms.CenterCrop", "crop the center of a PIL image or a tensor to size"),
+    ("random_crop", "kalfa.std.data.transforms.RandomCrop", "crop a random window of size after padding"),
+    ("random_flip", "kalfa.std.data.transforms.RandomFlip", "flip an image horizontally with probability p"),
+    ("grayscale", "kalfa.std.data.transforms.Grayscale", "an image in one channel"),
+)
+
+for name, target, doc in REGISTRATIONS:
+    register(name, target, slot="value", doc=doc)

kalfa/std/data/weights.py

@@ -0,0 +1,113 @@
+import math
+from dataclasses import dataclass
+
+import numpy
+
+from kalfa.core.errors import BuildError
+
+
+SHAPE = ("weights maps a batch field name to a weight column or to a mapping of pandas conditions to weights, such as "
+         "{w: {\"price < 5\": 5}}")
+
+
+@dataclass
+class Weight:
+    name: str
+    column: str | None = None
+    rules: tuple = ()
+
+    def source(self):
+        if self.column is not None:
+            return self.column
+        return {text: value for text, value in self.rules}
+
+    def detail(self):
+        if self.column is not None:
+            return f"column {self.column}"
+        return "; ".join([f"{text}: {value:g}" for text, value in self.rules] + ["else 1"])
+
+    def values(self, frame):
+        where = f"weights.{self.name}"
+        if self.column is not None:
+            found = column_values(frame, self.column, where)
+        else:
+            found = numpy.ones(len(frame), dtype="float64")
+            free = numpy.ones(len(frame), dtype=bool)
+            for text, value in self.rules:
+                hit = mask_of(frame, text, where) & free
+                found[hit] = value
+                free &= ~hit
+        bad = int((~numpy.isfinite(found)).sum())
+        if bad:
+            raise BuildError(f"{where}: {bad} rows have a weight that is not a finite number")
+        return found
+
+
+def column_values(frame, column, where):
+    if column not in frame.columns:
+        raise BuildError(f"{where}: the table has no column {column!r}; the columns are {list(frame.columns)}")
+    try:
+        return numpy.asarray(frame[column].to_numpy(), dtype="float64")
+    except (TypeError, ValueError) as error:
+        raise BuildError(f"{where}: the column {column!r} is not numeric") from error
+
+
+def mask_of(frame, text, where):
+    try:
+        found = frame.eval(text)
+    except Exception as error:
+        raise BuildError(f"{where}: the condition {text!r} failed: {error}") from error
+    mask = numpy.asarray(found)
+    if mask.dtype != bool or mask.shape != (len(frame),):
+        raise BuildError(f"{where}: the condition {text!r} must give true or false for every row, like 'price < 5'")
+    return mask
+
+
+def number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+
+
+def rules_of(name, item):
+    rules = []
+    for text, value in item.items():
+        if not isinstance(text, str) or not text.strip():
+            raise BuildError(f"weights.{name}: a condition is a pandas expression in quotes such as \"price < 5\", "
+                             f"got {text!r}")
+        if not number(value):
+            raise BuildError(f"weights.{name}: the weight of {text!r} must be a finite number, got {value!r}")
+        rules.append((text, float(value)))
+    return tuple(rules)
+
+
+def weights_of(spec, targets=None, drop=None):
+    if spec is None:
+        return []
+    if not isinstance(spec, dict):
+        raise BuildError(f"{SHAPE}; got {type(spec).__name__}")
+    taken = {str(name) for name in targets or ()}
+    dropped = {str(name) for name in drop or ()} if isinstance(drop, (list, tuple, set)) else set()
+    found = []
+    for name, item in spec.items():
+        if not isinstance(name, str) or not name:
+            raise BuildError(f"weights: a batch field name is text, got {name!r}")
+        if name == "x":
+            raise BuildError("weights: a weight cannot be named x; x is the feature tensor")
+        if name in taken:
+            raise BuildError(f"weights: {name!r} is a target; give the weight field its own name")
+        if name in dropped:
+            raise BuildError(f"weights: {name!r} is in drop; a weight field cannot be dropped")
+        if isinstance(item, str) and item:
+            found.append(Weight(name, column=item))
+        elif isinstance(item, dict) and item:
+            found.append(Weight(name, rules=rules_of(name, item)))
+        else:
+            raise BuildError(f"weights.{name}: {SHAPE}; got {item!r}")
+    return found
+
+
+def scale_of(weight, values):
+    mean = float(numpy.mean(values)) if len(values) else math.nan
+    if not mean > 0:
+        raise BuildError(f"weights.{weight.name}: the train weights have the mean {mean:g}; it must be positive to "
+                         "scale them to mean one")
+    return 1.0 / mean

kalfa/std/data/window.py

@@ -0,0 +1,135 @@
+import numpy
+import pandas
+import torch
+from torch.utils.data import Dataset
+
+from kalfa.core.aliases import register
+from kalfa.core.errors import BuildError
+from kalfa.std.common import positive_int
+
+
+EMPTY = numpy.zeros(0, dtype="int64")
+
+
+def positive(value, what):
+    return positive_int(value, f"window: {what}")
+
+
+def flat(values):
+    values = torch.as_tensor(values)
+    if values.ndim == 2 and values.shape[1] == 1:
+        return values[:, 0]
+    return values
+
+
+def codes_of(groups, earlier, count, before):
+    if groups is None:
+        return numpy.zeros(count, dtype="int64"), numpy.zeros(before, dtype="int64")
+    current = numpy.asarray(groups)
+    if len(current) != count:
+        raise BuildError(f"window: {len(current)} group values for {count} rows")
+    if earlier is None or not before:
+        codes, _ = pandas.factorize(current, sort=False, use_na_sentinel=False)
+        return codes.astype("int64"), numpy.full(before, -1, dtype="int64")
+    earlier = numpy.asarray(earlier)
+    if len(earlier) != before:
+        raise BuildError(f"window: {len(earlier)} group values for {before} context rows")
+    codes, _ = pandas.factorize(numpy.concatenate([earlier, current]), sort=False, use_na_sentinel=False)
+    codes = codes.astype("int64")
+    return codes[before:], codes[:before]
+
+
+def members_of(codes):
+    if not len(codes):
+        return {}
+    order = numpy.argsort(codes, kind="stable")
+    ordered = codes[order]
+    cuts = numpy.flatnonzero(ordered[1:] != ordered[:-1]) + 1
+    keys = ordered[numpy.concatenate([[0], cuts]).astype("int64")]
+    return dict(zip(keys.tolist(), numpy.split(order.astype("int64"), cuts)))
+
+
+def gather(values, earlier, layout, before):
+    index = torch.from_numpy(layout)
+    out = values.new_zeros((len(layout), *values.shape[1:]))
+    late = index >= before
+    out[late] = values[index[late] - before]
+    if earlier is not None and tuple(earlier.shape[1:]) == tuple(values.shape[1:]):
+        out[~late] = earlier[index[~late]].to(values.dtype)
+    return out
+
+
+class WindowDataset(Dataset):
+    def __init__(self, x, targets, rows, starts, size, horizon):
+        self.x = x
+        self.targets = targets
+        self.rows = rows
+        self.starts = starts
+        self.size = size
+        self.horizon = horizon
+
+    def __len__(self):
+        return len(self.starts)
+
+    def __getitem__(self, position):
+        start = int(self.starts[position])
+        end = start + self.size
+        item = {"x": self.x[start:end]}
+        for name, values in self.targets.items():
+            item[name] = values[end:end + self.horizon]
+        return item
+
+
+class Window:
+    def __init__(self, size, horizon=1, stride=1, context=True, group=None):
+        self.size = positive(size, "size")
+        self.horizon = positive(horizon, "horizon")
+        self.stride = positive(stride, "stride")
+        self.context = bool(context)
+        self.group = group
+
+    def dataset(self, x, targets, rows, groups=None, context=None):
+        x = torch.as_tensor(x, dtype=torch.float32)
+        count = int(x.shape[0])
+        rows = numpy.asarray(rows)
+        if len(rows) != count:
+            raise BuildError(f"window: {len(rows)} row ids for {count} rows")
+        targets = {name: flat(values) for name, values in (targets or {}).items()}
+        earlier_x, earlier_targets, earlier_groups = x[:0], {}, None
+        if self.context and context is not None:
+            earlier_x, earlier_targets, _, earlier_groups = context
+            earlier_x = torch.as_tensor(earlier_x, dtype=torch.float32)
+            earlier_targets = {name: flat(values) for name, values in (earlier_targets or {}).items()}
+            if tuple(earlier_x.shape[1:]) != tuple(x.shape[1:]):
+                raise BuildError(f"window: the context rows have the shape {tuple(earlier_x.shape[1:])}, the rows "
+                                 f"{tuple(x.shape[1:])}")
+        before = int(earlier_x.shape[0])
+        current, previous = codes_of(groups, earlier_groups, count, before)
+        tails = members_of(previous)
+        pieces, starts, firsts = [], [], []
+        length = 0
+        for code, members in members_of(current).items():
+            tail = tails.get(code, EMPTY)[-self.size:]
+            offset = len(tail)
+            total = offset + len(members)
+            ends = numpy.arange(max(self.size, offset), total - self.horizon + 1, self.stride, dtype="int64")
+            if not len(ends):
+                continue
+            pieces.append(numpy.concatenate([tail, members + before]))
+            starts.append(ends - self.size + length)
+            firsts.append(members[ends - offset])
+            length += total
+        layout = numpy.concatenate(pieces) if pieces else EMPTY
+        starts = numpy.concatenate(starts) if starts else EMPTY
+        firsts = numpy.concatenate(firsts) if firsts else EMPTY
+        order = numpy.argsort(firsts, kind="stable")
+        windows = gather(x, earlier_x, layout, before)
+        horizons = {name: gather(values, earlier_targets.get(name), layout, before)
+                    for name, values in targets.items()}
+        return WindowDataset(windows, horizons, rows[firsts[order]], starts[order], self.size, self.horizon)
+
+
+register("window", "kalfa.std.data.window.Window", slot="value",
+         doc="turns the rows of a table into windows: x of the last size rows, each target over the next horizon "
+             "rows; every window keeps to one value of the group column; with context the first windows of a set "
+             "reach back into the previous set")

kalfa/std/figure.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+import matplotlib
+
+from kalfa.core.record import atomic
+
+
+matplotlib.use("Agg")
+
+from matplotlib import pyplot  # noqa: E402
+
+
+PALETTE = ("#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#4a3aa7", "#e34948")
+
+
+class Figures:
+    colors = PALETTE
+    width = 6.4
+    height = 4.4
+
+    def __init__(self, directory, format="png", dpi=150):
+        self.directory = directory
+        self.format = format
+        self.dpi = dpi
+
+    def new(self, width=None, height=None):
+        size = (float(width or self.width), float(height or self.height))
+        return pyplot.figure(figsize=size, layout="constrained")
+
+    def save(self, figure, name):
+        path = Path(self.directory) / f"{name}.{self.format}"
+        try:
+            with atomic(path) as temporary:
+                figure.savefig(temporary, format=self.format, dpi=self.dpi)
+        finally:
+            pyplot.close(figure)
+        return path

kalfa/std/init.py

@@ -0,0 +1,72 @@
+from torch import nn
+from torch.nn.parameter import is_lazy
+
+from kalfa.core.aliases import register
+
+
+LAYERS = (nn.Linear, nn.Conv1d, nn.Conv2d, nn.Conv3d, nn.ConvTranspose1d, nn.ConvTranspose2d, nn.ConvTranspose3d,
+          nn.Embedding)
+
+
+def zero_bias(layer):
+    bias = getattr(layer, "bias", None)
+    if bias is not None:
+        nn.init.zeros_(bias)
+
+
+class Pending:
+    def __init__(self, fill):
+        self.fill = fill
+        self.done = False
+
+    def __call__(self, module, inputs):
+        if not self.done:
+            self.done = True
+            self.fill(module)
+
+
+def initializer(fill):
+    def apply(module):
+        for layer in module.modules():
+            if not isinstance(layer, LAYERS):
+                continue
+            if any(is_lazy(parameter) for parameter in layer.parameters(recurse=False)):
+                layer.register_forward_pre_hook(Pending(fill))
+            else:
+                fill(layer)
+
+    return apply
+
+
+def normal_init(std=0.02, mean=0.0):
+    def fill(layer):
+        nn.init.normal_(layer.weight, mean=float(mean), std=float(std))
+        zero_bias(layer)
+
+    return initializer(fill)
+
+
+def xavier_init(gain=1.0):
+    def fill(layer):
+        nn.init.xavier_uniform_(layer.weight, gain=float(gain))
+        zero_bias(layer)
+
+    return initializer(fill)
+
+
+INITS = (
+    ("normal_init", "kalfa.std.init.normal_init", "draws linear, convolution and embedding weights from "
+                                                  "normal(mean, std) and zeroes biases; lazy layers are filled on "
+                                                  "their first forward"),
+    ("xavier_init", "kalfa.std.init.xavier_init", "xavier uniform weights for linear, convolution and embedding "
+                                                  "layers, zero biases; lazy layers are filled on their first "
+                                                  "forward"),
+)
+
+
+def register_names():
+    for name, target, doc in INITS:
+        register(name, target, slot="value", doc=doc)
+
+
+register_names()