diff --git a/cirkit/backend/torch/layers/inner.py b/cirkit/backend/torch/layers/inner.py index 11d01369..a4309f1b 100644 --- a/cirkit/backend/torch/layers/inner.py +++ b/cirkit/backend/torch/layers/inner.py @@ -155,12 +155,8 @@ def __init__( num_folds: The number of channels. Raises: - NotImplementedError: If the arity is not 2. ValueError: If the number of input units is not the same as the number of output units. """ - # TODO: generalize kronecker layer as to support a greater arity - if arity != 2: - raise NotImplementedError("Kronecker only implemented for binary product units.") super().__init__( num_input_units, num_input_units**arity, @@ -177,18 +173,25 @@ def config(self) -> Mapping[str, Any]: } def forward(self, x: Tensor) -> Tensor: - x0 = x[:, 0].unsqueeze(dim=-1) # shape (F, B, Ki, 1). - x1 = x[:, 1].unsqueeze(dim=-2) # shape (F, B, 1, Ki). - # shape (F, B, Ki, Ki) -> (F, B, Ko=Ki**2). - return self.semiring.mul(x0, x1).flatten(start_dim=-2) + # x: (F, H, B, Ki) + y0 = x[:, 0] + for i in range(1, x.shape[1]): + y0 = y0.unsqueeze(dim=-1) # (F, B, K, 1). + y1 = x[:, i].unsqueeze(dim=-2) # (F, B, 1, Ki). + # y0: (F, B, K=K * Ki). + y0 = torch.flatten(self.semiring.mul(y0, y1), start_dim=-2) + # y0: (F, B, Ko=Ki ** arity) + return y0 def sample(self, x: Tensor) -> tuple[Tensor, Tensor | None]: # x: (F, H, C, K, num_samples, D) - x0 = x[:, 0].unsqueeze(dim=3) # (F, C, Ki, 1, num_samples, D) - x1 = x[:, 1].unsqueeze(dim=2) # (F, C, 1, Ki, num_samples, D) - # shape (F, C, Ki, Ki, num_samples, D) -> (F, C, Ko=Ki**2, num_samples, D) - x = x0 + x1 - return torch.flatten(x, start_dim=2, end_dim=3), None + y0 = x[:, 0] + for i in range(1, x.shape[1]): + y0 = y0.unsqueeze(dim=3) # (F, C, K, 1, num_samples, D) + y1 = x[:, i].unsqueeze(dim=2) # (F, C, 1, Ki, num_samples, D) + y0 = torch.flatten(y0 + y1, start_dim=2, end_dim=3) + # y0: (F, C, Ko=Ki ** arity, num_samples, D) + return y0, None class TorchSumLayer(TorchInnerLayer): diff --git a/cirkit/backend/torch/layers/optimized.py b/cirkit/backend/torch/layers/optimized.py index 5b7159c5..fe866d0f 100644 --- a/cirkit/backend/torch/layers/optimized.py +++ b/cirkit/backend/torch/layers/optimized.py @@ -28,20 +28,18 @@ def __init__( Args: num_input_units: The number of input units. num_output_units: The number of output units. - arity: The arity of the layer, must be 2. Defaults to 2. + arity: The arity of the layer. Defaults to 2. weight: The weight parameter, which must have shape $(F, K_o, K_i^2)$, where $F$ is the number of folds, $K_o$ is the number output units, and $K_i$ is the number of input units. Raises: - NotImplementedError: If the arity is not equal to 2. Future versions of cirkit - will support Tucker layers having arity greter than 2. + ValueError: If the arity is less than two. ValueError: If the number of input and output units are incompatible with the shape of the weight parameter. """ - # TODO: Generalize Tucker layer to have any arity greater or equal 2 - if arity != 2: - raise NotImplementedError("The Tucker layer is only implemented with arity=2") + if arity < 2: + raise ValueError("The arity should be at least 2") super().__init__( num_input_units, num_output_units, arity=arity, semiring=semiring, num_folds=num_folds ) @@ -52,6 +50,16 @@ def __init__( f"{weight.num_folds} and {weight.shape}, respectively" ) self.weight = weight + # Construct the einsum expression that the Tucker layer computes + # For instance, if arity == 2 then we have that + # self._einsum = ((0, 1, 2), (0, 1, 3), (0, 1, 4, 2, 3), (0, 1, 4)) + # Also, if arity == 3 then we have that + # self._einsum = ((0, 1, 2), (0, 1, 3), (0, 1, 4), (0, 5, 2, 3, 4), (0, 1, 5)) + self._einsum = ( + tuple((0, 1, i + 2) for i in range(arity)) + + ((0, arity + 2, *tuple(i + 2 for i in range(arity))),) + + ((0, 1, arity + 2),) + ) def _valid_weight_shape(self, w: TorchParameter) -> bool: if w.num_folds != self.num_folds: @@ -60,7 +68,7 @@ def _valid_weight_shape(self, w: TorchParameter) -> bool: @property def _weight_shape(self) -> tuple[int, ...]: - return self.num_output_units, self.num_input_units * self.num_input_units + return self.num_output_units, self.num_input_units**self.arity @property def config(self) -> Mapping[str, Any]: @@ -75,14 +83,15 @@ def params(self) -> Mapping[str, TorchParameter]: return {"weight": self.weight} def forward(self, x: Tensor) -> Tensor: - # weight: (F, Ko, Ki * Ki) -> (F, Ko, Ki, Ki) + # x: (F, H, B, Ki) + # weight: (F, Ko, Ki ** arity) -> (F, Ko, Ki, ..., Ki) weight = self.weight().view( - -1, self.num_output_units, self.num_input_units, self.num_input_units + -1, self.num_output_units, *(self.num_input_units for _ in range(self.arity)) ) return self.semiring.einsum( - "fbi,fbj,foij->fbo", + self._einsum, + inputs=x.unbind(dim=1), operands=(weight,), - inputs=(x[:, 0], x[:, 1]), dim=-1, keepdim=True, ) diff --git a/cirkit/backend/torch/semiring.py b/cirkit/backend/torch/semiring.py index 2a93c29c..f586d6cc 100644 --- a/cirkit/backend/torch/semiring.py +++ b/cirkit/backend/torch/semiring.py @@ -1,4 +1,5 @@ import functools +import itertools from abc import ABC, abstractmethod from collections.abc import Callable, Iterable, Sequence from typing import ClassVar, TypeVar, cast @@ -153,19 +154,40 @@ def __new__(cls) -> "SemiringImpl": @classmethod def einsum( cls, - equation: str, + equation: str | Sequence[Sequence[int, ...], ...], *, - inputs: tuple[Tensor, ...], - operands: tuple[Tensor, ...], + inputs: tuple[Tensor, ...] | None = None, + operands: tuple[Tensor, ...] | None = None, dim: int, keepdim: bool, ) -> Tensor: - operands = tuple(cls.cast(opd) for opd in operands) - - def _einsum_func(*xs: Tensor) -> Tensor: - return torch.einsum(equation, *xs, *operands) - - return cls.apply_reduce(_einsum_func, *inputs, dim=dim, keepdim=keepdim) + # TODO (LL): We need to remove this super general yet extremely complicated and hard + # to maintain einsum definition, which depends on the semiring. A future version of the + # compiler in cirkit will be able to emit pytorch code for every layer at compile time + match equation: + case str(): + + def _einsum_str_func(*xs: Tensor) -> Tensor: + opds = tuple(cls.cast(opd) for opd in operands) + return torch.einsum(equation, *xs, *opds) + + einsum_func = _einsum_str_func + case Sequence(): + + def _einsum_seq_func(*xs: Tensor) -> Tensor: + opds = tuple(cls.cast(opd) for opd in operands) + einsum_args = tuple( + itertools.chain.from_iterable(zip(xs + opds, equation[:-1])) + ) + return torch.einsum(*einsum_args, equation[-1]) + + einsum_func = _einsum_seq_func + case _: + raise ValueError( + "The einsum expression must be either a string or a sequence of int sequences" + ) + + return cls.apply_reduce(einsum_func, *inputs, dim=dim, keepdim=keepdim) # NOTE: Subclasses should not touch any of the above final static methods but should implement # all the following abstract class methods, and subclasses should be @final. diff --git a/cirkit/templates/tensor_factorizations.py b/cirkit/templates/tensor_factorizations.py index 5e43b520..29fcd5b8 100644 --- a/cirkit/templates/tensor_factorizations.py +++ b/cirkit/templates/tensor_factorizations.py @@ -1,26 +1,62 @@ +from collections import defaultdict +from typing import cast + +import numpy as np +from scipy import linalg + from cirkit.symbolic.circuit import Circuit -from cirkit.symbolic.layers import EmbeddingLayer, HadamardLayer, SumLayer -from cirkit.symbolic.parameters import ConstantParameter, Parameter -from cirkit.templates.utils import Parameterization, parameterization_to_factory +from cirkit.symbolic.layers import EmbeddingLayer, HadamardLayer, KroneckerLayer, Layer, SumLayer +from cirkit.symbolic.parameters import ConstantParameter, Parameter, ParameterFactory +from cirkit.templates.utils import ( + InputLayerFactory, + Parameterization, + name_to_input_layer_factory, + parameterization_to_factory, +) from cirkit.utils.scope import Scope +def _input_layer_factory_builder( + input_layer: str, dim: int, factor_param_kwargs: dict[str, ParameterFactory] +) -> InputLayerFactory: + match input_layer: + case "categorical": + factor_dim_kwargs = {"num_categories": dim} + case "binomial": + factor_dim_kwargs = {"total_count": dim} + case "embedding": + factor_dim_kwargs = {"num_states": dim} + case _: + assert False + return name_to_input_layer_factory(input_layer, **factor_dim_kwargs, **factor_param_kwargs) + + +def _input_param_factories( + input_params: dict[str, Parameterization] +) -> dict[str, ParameterFactory]: + return { + name + "_factory": parameterization_to_factory(param) + for name, param in input_params.items() + } + + def cp( shape: tuple[int, ...], rank: int, *, - factor_param: Parameterization | None = None, + input_layer: str = "embedding", + input_params: dict[str, Parameterization] | None = None, weight_param: Parameterization | None = None, ) -> Circuit: - r"""Constructs a circuit encoding a CP factorization of an n-dimensional tensor. + r"""Constructs a circuit encoding a CP factorization of an $n$-dimensional tensor. - Formally, given the shape of a tensor $\mathcal{T}\in\mathbb{R}^{I_1\times \ldots\times I_n}$, + Formally, given the shape of a tensor $\mathcal{T}\in\mathbb{R}^{I_1\times \cdots\times I_n}$, this method returns a circuit $c$ over $n$ discrete random variables $\{X_j\}_{j=1}^n$, each taking value between $0$ and $I_j$ for $1\leq j\leq n$, and $c$ computes a rank-$R$ CP factorization, i.e., $$ - c(X_1,\ldots,X_n) = t_{X_1\cdots X_n} = \sum_{i=1}^R a^{(1)}_{X_1 i} \ldots a^{(n)}_{X_n i}, + c(X_1,\ldots,X_n) = t_{X_1\cdots X_n} = \sum_{i=1}^R a^{(1)}_{X_1 i} \cdots a^{(n)}_{X_n i}, $$ where for $1\leq j\leq n$ we have that $\mathbf{A}^{(j)}\in\mathbb{R}^{I_j\times R}$ is the $j$-th factor. @@ -52,8 +88,12 @@ def cp( Args: shape: The shape of the tensor to encode the CP factorization of. rank: The rank of the CP factorization. Defaults to 1. - factor_param: The parameterization to use for the factor matrices. - If None, then it defaults to no activation and uses an initialization based on + input_layer: The input layer to use for the factors. It can be 'embedding', 'categorical' + or 'binomial'. Defaults to 'embedding'. If it is 'embedding' then it corresponds to the + CP factorization described above where the factors are matrices. + input_params: A dictionary mapping each name of a parameter of the input layer to + its parameterization. If it is None and ```input_layer``` is 'embedding', then + it defaults to no activation and uses an initialization based on independently sampling from a standard Gaussian distribution. weight_param: The parameterization to use for the weight coefficients. If None, then it defaults to fixed weights set all to one. @@ -64,16 +104,14 @@ def cp( Raises: ValueError: If the given tensor shape is not valid. ValueError: If the rank is not a positive number. + ValueError: If the input layer is not valid. """ if len(shape) < 1 or any(dim < 1 for dim in shape): raise ValueError("The tensor shape is not valid") if rank < 1: raise ValueError("The factorization rank should be a positive number") - - # Retrieve the factory to parameterize the embeddings - if factor_param is None: - factor_param = Parameterization(activation="none", initialization="normal") - embedding_factory = parameterization_to_factory(factor_param) + if input_layer not in ["categorical", "binomial", "embedding"]: + raise ValueError(f"The input layer {input_layer} is not valid for CP") # Retrieve the sum layer weight, depending on whether we the CP factorization is weighted if weight_param is None: @@ -83,10 +121,13 @@ def cp( weight_factory = parameterization_to_factory(weight_param) weight = None - # Construct the embedding, hadamard and sum layers + # Construct the factor, hadamard and sum layers + factor_param_kwargs = {} if input_params is None else _input_param_factories(input_params) + embedding_layer_factories: list[InputLayerFactory] = [ + _input_layer_factory_builder(input_layer, dim, factor_param_kwargs) for dim in shape + ] embedding_layers = [ - EmbeddingLayer(Scope([i]), rank, 1, num_states=dim, weight_factory=embedding_factory) - for i, dim in enumerate(shape) + f(Scope([i]), rank, num_channels=1) for i, f in enumerate(embedding_layer_factories) ] hadamard_layer = HadamardLayer(rank, arity=len(shape)) sum_layer = SumLayer(rank, 1, arity=1, weight=weight, weight_factory=weight_factory) @@ -97,3 +138,221 @@ def cp( in_layers={sum_layer: [hadamard_layer], hadamard_layer: embedding_layers}, outputs=[sum_layer], ) + + +def tucker( + shape: tuple[int, ...], + rank: int, + *, + input_layer: str = "embedding", + input_params: dict[str, Parameterization] | None = None, + core_param: Parameterization | None = None, +) -> Circuit: + r"""Constructs a circuit encoding a Tucker factorization of an $n$-dimensional tensor. + + Formally, given the shape of a tensor $\mathcal{T}\in\mathbb{R}^{I_1\times \cdots\times I_n}$, + this method returns a circuit $c$ over $n$ discrete random variables $\{X_j\}_{j=1}^n$, + each taking value between $0$ and $I_j$ for $1\leq j\leq n$, + and $c$ computes a rank-$R$ Tucker factorization, i.e., + + $$ + c(X_1,\ldots,X_n) = t_{X_1\cdots X_n} = \sum_{r_1=1}^R \cdots \sum_{r_n=1}^R w_{r_1\cdots r_n} a^{(1)}_{X_1 r_1} \cdots a^{(n)}_{X_n r_n}, + $$ + + where for $1\leq j\leq n$ we have that $\mathbf{A}^{(j)}\in\mathbb{R}^{I_j\times R}$ is the $j$-th factor, + and $\mathcal{W}\in\mathbb{R}^{R\times\cdots\times R}$ is an $n$-dimensional tensor, sometimes called + the core tensor of the Tucker factorization. + + This method allows you to specify different types of parameterizations for the factors and + the core tensor. For example, if the arguments ```factor_param``` and + ```core_param``` are both equal to a + [parameterization][cirkit.templates.utils.Parameterization] + ```Parameterization(activation="softmax", initialization="normal")```, + then the returned circuit encodes a probabilistic model that is a mixture of fully-factorized + models. That is, the returned circuit $c$ encodes the factorization of a non-negative tensor + $\mathcal{T}\in\mathbb{R}_+^{I_1\times \ldots\times I_n}$ as the distribution + + $$ + p(X_1,\ldots,X_n) = t_{X_1\cdots X_n} = \sum_{r_1=1}^R \cdots \sum_{r_n=1}^R p(Z=(r_1,\ldots,r_n)) \: p(X_1\mid Z=r_1) \cdots p(X_n\mid Z=r_n), + $$ + + where $Z$ is a discrete latent variable taking value in $\{1,\ldots,R\}^n$ and modelled by + $p(Z)$. + + Args: + shape: The shape of the tensor to encode the Tucker factorization of. + rank: The rank of the Tucker factorization. Defaults to 1. + input_layer: The input layer to use for the factors. It can be 'embedding', 'categorical' + or 'binomial'. Defaults to 'embedding'. If it is 'embedding' then it corresponds to the + CP factorization described above where the factors are matrices. + input_params: A dictionary mapping each name of a parameter of the input layer to + its parameterization. If it is None and ```input_layer``` is 'embedding', then + it defaults to no activation and uses an initialization based on + independently sampling from a standard Gaussian distribution. + core_param: The parameterization to use for the core tensor. + If None, then it defaults to no activation and uses an initialization based on + independently sampling from a standard Gaussian distribution. + + Returns: + Circuit: A circuit encoding a Tucker factorization. + + Raises: + ValueError: If the given tensor shape is not valid. + ValueError: If the rank is not a positive number. + ValueError: If the input layer is not valid. + """ + if len(shape) < 1 or any(dim < 1 for dim in shape): + raise ValueError("The tensor shape is not valid") + if rank < 1: + raise ValueError("The factorization rank should be a positive number") + if input_layer not in ["categorical", "binomial", "embedding"]: + raise ValueError(f"The input layer {input_layer} is not valid for Tucker") + + # Retrieve the factory to parameterize the core tensor + if core_param is None: + core_param = Parameterization(activation="none", initialization="normal") + weight_factory = parameterization_to_factory(core_param) + + # Construct the embedding, kronecker and sum layers + factor_param_kwargs = {} if input_params is None else _input_param_factories(input_params) + embedding_layer_factories: list[InputLayerFactory] = [ + _input_layer_factory_builder(input_layer, dim, factor_param_kwargs) for dim in shape + ] + embedding_layers = [ + f(Scope([i]), rank, num_channels=1) for i, f in enumerate(embedding_layer_factories) + ] + kronecker_layer = KroneckerLayer(rank, arity=len(shape)) + sum_layer = SumLayer(cast(int, rank ** len(shape)), 1, arity=1, weight_factory=weight_factory) + + return Circuit( + 1, + layers=embedding_layers + [kronecker_layer, sum_layer], + in_layers={sum_layer: [kronecker_layer], kronecker_layer: embedding_layers}, + outputs=[sum_layer], + ) + + +def tensor_train( + shape: tuple[int, ...], + rank: int, + *, + factor_param: Parameterization | None = None, +) -> Circuit: + r"""Constructs a circuit encoding a Tensor-Train (TT) factorization of an $n$-dimensional + tensor. This factorization is also called Matrix-Product State (MPS) in quantum physics. + Note that the obtained circuit encodes the complete left-to-right contraction of the + Note that the obtained circuit encodes the complete left-to-right contraction of the + TT/MPS factorization, given an entry of the tensor being factorized. + + Formally, given the shape of a tensor $\mathcal{T}\in\mathbb{R}^{I_1\times \cdots\times I_n}$, + this method returns a circuit $c$ over $n$ discrete random variables $\{X_j\}_{j=1}^n$, + each taking value between $0$ and $I_j$ for $1\leq j\leq n$, + and $c$ computes a rank-$R$ TT/MPS factorization, i.e., + + $$ + c(X_1,\ldots,X_n) = t_{X_1\cdots X_n} = \sum_{r_1=1}^R \cdots \sum_{r_{n-1}=1}^R v^{(1)}_{X_1 r_1} v^{(2)}_{X_2 r_1 r_2} \cdots v^{(n-1)}_{X_{n-1} r_{n-2} r_{n-1}} v^{(n)}_{X_n r_{n-1}}, + $$ + + where $\mathbf{V}^{(1)}\in\mathbb{R}^{I_1\times R}$, + $\mathbf{V}^{(n)}\in\mathbb{R}^{I_n\times R}$, + and $\mathbf{V}^{(j)}\in\mathbb{R}^{I_j\times R\times R}$ for $1< j< n$ + are the factor tensors of the TT/MPS factorization. + + This method allows you to specify different types of parameterizations for the factor tensors. + For instance, if the argument ```factor_param``` is equal to + [parameterization][cirkit.templates.utils.Parameterization] + ```Parameterization(dtype="complex")``` + then the returned circuit has complex parameters and therefore can be used + to represent a many-body quantum system. + + Args: + shape: The shape of the tensor to encode the TT/MPS factorization of. + rank: The rank of the TT/MPS factorization. Defaults to 1. + factor_param: The parameterization to use for the factor tensors. + If None, then it defaults to no activation and uses an initialization based on + independently sampling from a standard Gaussian distribution. + + Returns: + Circuit: A circuit encoding a TT/MPS factorization. + + Raises: + ValueError: If the given tensor shape is not valid. + ValueError: If the rank is not a positive number. + """ + if len(shape) < 1 or any(dim < 1 for dim in shape): + raise ValueError("The tensor shape is not valid") + if rank < 1: + raise ValueError("The factorization rank should be a positive number") + + # Retrieve the factory to parameterize the embeddings and the core tensor + if factor_param is None: + factor_param = Parameterization(activation="none", initialization="normal") + embedding_factory = parameterization_to_factory(factor_param) + + # Construct the first, last, and inner embedding layers + first_embedding = EmbeddingLayer( + Scope([0]), rank, 1, num_states=shape[0], weight_factory=embedding_factory + ) + last_embedding = EmbeddingLayer( + Scope([len(shape) - 1]), rank, 1, num_states=shape[-1], weight_factory=embedding_factory + ) + inner_embeddings = [ + [ + EmbeddingLayer(Scope([i]), rank, 1, num_states=dim, weight_factory=embedding_factory) + for _ in range(rank) + ] + for i, dim in enumerate(shape[1:-1], start=1) + ] + + # The inner sum layers will have a constant parameter matrix used to encode a matrix-vector + # product, while the last sum layer will have a constant parameter matrix of ones used to + # encode a vector dot product + dot_ones = np.ones((1, rank)) + mav_ones = linalg.block_diag(*((dot_ones,) * rank)) + + # Build the layers encoding the left-to-right contraction of the TT/MPS factorization + layers: list[Layer] = [first_embedding, last_embedding] + [ + sl for sls in inner_embeddings for sl in sls + ] + in_layers: dict[Layer, list[Layer]] = defaultdict(list) + cur_sl = first_embedding + for i in range(len(shape) - 1): + if i == len(shape) - 2: + # i = n + # Encode the vector dot product by stacking an hadamard layer and a sum layer + prod_sl = HadamardLayer(rank, arity=2) + sum_sl = SumLayer( + rank, + 1, + arity=1, + weight=Parameter.from_input(ConstantParameter(1, rank, value=dot_ones)), + ) + layers.append(prod_sl) + layers.append(sum_sl) + in_layers[sum_sl] = [prod_sl] + in_layers[prod_sl] = [cur_sl, last_embedding] + cur_sl = sum_sl + continue + # 0<= i< n + # Encode the matrix-vector product by stacking hadamard layers and a sum layer + prod_sls = [HadamardLayer(rank, arity=2) for _ in range(rank)] + sum_sl = SumLayer( + rank, + rank, + arity=rank, + weight=Parameter.from_input(ConstantParameter(rank, rank * rank, value=mav_ones)), + ) + layers.extend(prod_sls) + layers.append(sum_sl) + in_layers[sum_sl] = prod_sls + for prod_sl, emb_sl in zip(prod_sls, inner_embeddings[i]): + in_layers[prod_sl] = [cur_sl, emb_sl] + cur_sl = sum_sl + + # Instantiate and return the circuit + return Circuit( + 1, + layers=layers, + in_layers=in_layers, + outputs=[cur_sl], + ) diff --git a/cirkit/templates/utils.py b/cirkit/templates/utils.py index 2f3ffb03..1f636e78 100644 --- a/cirkit/templates/utils.py +++ b/cirkit/templates/utils.py @@ -36,8 +36,8 @@ class Parameterization: """The settings for a parameterization: the initialization method, the activation function to use, and the data type of the parameter tensor.""" - initialization: str - """The initialization method.""" + initialization: str = "normal" + """The initialization method. Defaults to 'normal', i.e., sampling from a standard Gaussian.""" activation: str = "none" """The activation function. Defaults to 'none', i.e., no activation.""" dtype: str = "real" diff --git a/notebooks/compression-cp-factorization.ipynb b/notebooks/compression-cp-factorization.ipynb index 049fcb9c..c63942ec 100644 --- a/notebooks/compression-cp-factorization.ipynb +++ b/notebooks/compression-cp-factorization.ipynb @@ -141,7 +141,7 @@ "from cirkit.templates import tensor_factorizations, utils\n", "\n", "# Set the factorization rank to use\n", - "factorization_rank = 48\n", + "factorization_rank = 64\n", "\n", "# Construct the symbolic circuit encoding a CP tensor factorization\n", "symbolic_circuit = tensor_factorizations.cp(\n", @@ -150,11 +150,18 @@ " original_image.shape,\n", " # The rank of the CP factorization\n", " rank=factorization_rank,\n", + " # Use embeddings as input layers, i.e., which encodes the factor matrices\n", + " input_layer='embedding',\n", " # Initialize the factor matrices by sampling independently from a normal distribution\n", - " factor_param=utils.Parameterization(\n", - " initialization=\"normal\",\n", - " initialization_kwargs={\"mean\": 0.5, \"stddev\": 1.0 / np.sqrt(factorization_rank)}\n", - " )\n", + " # Mean and standard deviation have been chosen based on trial-and-error\n", + " input_params={\n", + " 'weight': utils.Parameterization(\n", + " initialization=\"normal\",\n", + " initialization_kwargs={\n", + " \"mean\": 1.0 / np.cbrt(2 * factorization_rank),\n", + " \"stddev\": 5e-2\n", + " }\n", + " )}\n", ")" ] }, @@ -210,7 +217,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Number of image indices: 2764800 Batch size: 16384\n" + "Number of image indices: 2764800 Batch size: 32768\n" ] } ], @@ -219,7 +226,7 @@ "from torch.utils.data import DataLoader, TensorDataset\n", "\n", "# Construct a data loader that randomly samples indices of the image/tensor to approximate\n", - "batch_size = int(2 ** 14)\n", + "batch_size = int(2 ** 15)\n", "image_indices = np.stack(np.mgrid[0:original_image.shape[0], 0:original_image.shape[1], 0:original_image.shape[2]], axis=-1).reshape(-1, 3)\n", "train_dataloader = DataLoader(TensorDataset(torch.from_numpy(image_indices)), shuffle=True, batch_size=batch_size, drop_last=True)\n", "print(f\"Number of image indices: {len(image_indices)}\", f\"Batch size: {batch_size}\")\n", @@ -238,21 +245,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1: Average MSE: 0.374\n", - "Epoch 2: Average MSE: 0.030\n", - "Epoch 3: Average MSE: 0.023\n", - "Epoch 4: Average MSE: 0.020\n", - "Epoch 5: Average MSE: 0.018\n", - "Epoch 6: Average MSE: 0.017\n", - "Epoch 7: Average MSE: 0.016\n", - "Epoch 8: Average MSE: 0.016\n", - "Epoch 9: Average MSE: 0.015\n", - "Epoch 10: Average MSE: 0.015\n" + "Epoch 1: Average MSE: 0.039\n", + "Epoch 2: Average MSE: 0.016\n", + "Epoch 3: Average MSE: 0.015\n", + "Epoch 4: Average MSE: 0.015\n", + "Epoch 5: Average MSE: 0.015\n" ] } ], "source": [ - "num_epochs = 10\n", + "num_epochs = 5\n", "running_loss = 0.0\n", "running_samples = 0\n", "\n", @@ -303,7 +305,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/pyproject.toml b/pyproject.toml index 0ab36994..fd6bef13 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -70,7 +70,7 @@ docs = [ ] notebooks = [ "notebook", - "torchvision~=0.18.0", + "torchvision", "matplotlib", "scikit-learn", "pandas", diff --git a/tests/templates/region_graph/test_graph.py b/tests/templates/region_graph/test_graph.py deleted file mode 100644 index e69de29b..00000000 diff --git a/tests/templates/test_tensor_factorizations.py b/tests/templates/test_tensor_factorizations.py index 8d81a6e6..87002a1d 100644 --- a/tests/templates/test_tensor_factorizations.py +++ b/tests/templates/test_tensor_factorizations.py @@ -1,47 +1,157 @@ import itertools +import numpy as np import pytest -from cirkit.symbolic.layers import EmbeddingLayer, HadamardLayer, SumLayer -from cirkit.symbolic.parameters import ConstantParameter +from cirkit.symbolic.dtypes import DataType +from cirkit.symbolic.layers import ( + CategoricalLayer, + EmbeddingLayer, + HadamardLayer, + KroneckerLayer, + SumLayer, +) +from cirkit.symbolic.parameters import ConstantParameter, SoftmaxParameter, TensorParameter from cirkit.templates import tensor_factorizations from cirkit.templates.utils import Parameterization from cirkit.utils.scope import Scope -@pytest.mark.parametrize( - "rank,factor_param,weight_param", - itertools.product( - [1, 5], - [None, Parameterization(activation="softmax", initialization="normal")], - [None, Parameterization(activation="softmax", initialization="normal")], - ), -) -def test_cp( - rank: int, factor_param: Parameterization | None, weight_param: Parameterization | None -): - shape = (256, 32, 32) +@pytest.mark.parametrize("rank", [1, 5]) +def test_factorization_cp(rank: int): + shape = (48, 16, 32) + circuit = tensor_factorizations.cp(shape, rank, input_layer="embedding") + assert circuit.scope == Scope(range(len(shape))) + input_layers = list(circuit.inputs) + product_layers = list(circuit.product_layers) + sum_layers = list(circuit.sum_layers) + assert len(input_layers) == len(shape) + assert all(isinstance(sl, EmbeddingLayer) for sl in input_layers) + assert len(product_layers) == 1 and isinstance(product_layers[0], HadamardLayer) + assert product_layers[0].num_input_units == rank + assert product_layers[0].arity == len(input_layers) + assert len(sum_layers) == 1 and isinstance(sum_layers[0], SumLayer) + assert sum_layers[0].num_input_units == rank and sum_layers[0].num_output_units == 1 + assert sum_layers[0].arity == 1 + assert all(len(sl.weight.nodes) == 1 for sl in input_layers) + assert len(sum_layers[0].weight.nodes) == 1 + assert isinstance(sum_layers[0].weight.nodes[0], ConstantParameter) + + +@pytest.mark.parametrize("rank", [1, 5]) +def test_factorization_cp_probabilistic(rank: int): + shape = (48, 16, 32) circuit = tensor_factorizations.cp( - shape, rank, factor_param=factor_param, weight_param=weight_param + shape, + rank, + input_layer="categorical", + input_params={"probs": Parameterization(activation="softmax")}, + weight_param=Parameterization(activation="softmax"), ) assert circuit.scope == Scope(range(len(shape))) input_layers = list(circuit.inputs) product_layers = list(circuit.product_layers) sum_layers = list(circuit.sum_layers) assert len(input_layers) == len(shape) - assert all(isinstance(sl, EmbeddingLayer) for sl in input_layers) + assert all(isinstance(sl, CategoricalLayer) for sl in input_layers) assert len(product_layers) == 1 and isinstance(product_layers[0], HadamardLayer) assert product_layers[0].num_input_units == rank assert product_layers[0].arity == len(input_layers) assert len(sum_layers) == 1 and isinstance(sum_layers[0], SumLayer) assert sum_layers[0].num_input_units == rank and sum_layers[0].num_output_units == 1 assert sum_layers[0].arity == 1 - if factor_param is None: - assert all(len(sl.weight.nodes) == 1 for sl in input_layers) - else: - assert all(len(sl.weight.nodes) == 2 for sl in input_layers) - if weight_param is not None: - assert len(sum_layers[0].weight.nodes) == 2 - else: - assert len(sum_layers[0].weight.nodes) == 1 - assert isinstance(sum_layers[0].weight.nodes[0], ConstantParameter) + assert all(len(sl.probs.nodes) == 2 for sl in input_layers) + assert all(SoftmaxParameter in map(type, sl.probs.nodes) for sl in input_layers) + assert len(sum_layers[0].weight.nodes) == 2 + assert SoftmaxParameter in map(type, sum_layers[0].weight.nodes) + + +@pytest.mark.parametrize("rank", [1, 5]) +def test_factorization_tucker(rank: int): + shape = (48, 16, 32) + circuit = tensor_factorizations.tucker(shape, rank, input_layer="embedding") + assert circuit.scope == Scope(range(len(shape))) + input_layers = list(circuit.inputs) + product_layers = list(circuit.product_layers) + sum_layers = list(circuit.sum_layers) + assert len(input_layers) == len(shape) + assert all(isinstance(sl, EmbeddingLayer) for sl in input_layers) + assert len(product_layers) == 1 and isinstance(product_layers[0], KroneckerLayer) + assert product_layers[0].num_input_units == rank + assert product_layers[0].arity == len(input_layers) + assert len(sum_layers) == 1 and isinstance(sum_layers[0], SumLayer) + assert sum_layers[0].num_input_units == rank ** len(input_layers) + assert sum_layers[0].num_output_units == 1 + assert sum_layers[0].arity == 1 + assert all(len(sl.weight.nodes) == 1 for sl in input_layers) + assert len(sum_layers[0].weight.nodes) == 1 + assert isinstance(sum_layers[0].weight.nodes[0], TensorParameter) + + +@pytest.mark.parametrize("rank", [1, 5]) +def test_factorization_tucker_probabilistic(rank: int): + shape = (48, 16, 32) + circuit = tensor_factorizations.tucker( + shape, + rank, + input_layer="categorical", + input_params={"probs": Parameterization(activation="softmax")}, + core_param=Parameterization(activation="softmax"), + ) + assert circuit.scope == Scope(range(len(shape))) + input_layers = list(circuit.inputs) + product_layers = list(circuit.product_layers) + sum_layers = list(circuit.sum_layers) + assert len(input_layers) == len(shape) + assert all(isinstance(sl, CategoricalLayer) for sl in input_layers) + assert len(product_layers) == 1 and isinstance(product_layers[0], KroneckerLayer) + assert product_layers[0].num_input_units == rank + assert product_layers[0].arity == len(input_layers) + assert len(sum_layers) == 1 and isinstance(sum_layers[0], SumLayer) + assert sum_layers[0].num_input_units == rank ** len(input_layers) + assert sum_layers[0].num_output_units == 1 + assert sum_layers[0].arity == 1 + assert all(len(sl.probs.nodes) == 2 for sl in input_layers) + assert all(SoftmaxParameter in map(type, sl.probs.nodes) for sl in input_layers) + assert len(sum_layers[0].weight.nodes) == 2 + assert SoftmaxParameter in map(type, sum_layers[0].weight.nodes) + + +@pytest.mark.parametrize( + "rank,factor_param", + itertools.product([1, 5], [None, Parameterization(dtype="complex")]), +) +def test_factorization_tensor_train(rank: int, factor_param: Parameterization | None): + shape = (48, 16, 32) + circuit = tensor_factorizations.tensor_train(shape, rank=rank, factor_param=factor_param) + assert circuit.scope == Scope(range(len(shape))) + input_layers = list(circuit.inputs) + product_layers = list(circuit.product_layers) + sum_layers = list(circuit.sum_layers) + assert set([sl.num_output_units for sl in input_layers]) == {rank} + assert len([sl for sl in input_layers if circuit.layer_scope(sl) == Scope([0])]) == 1 + assert ( + len([sl for sl in input_layers if circuit.layer_scope(sl) == Scope([len(shape) - 1])]) == 1 + ) + for i in range(1, len(shape) - 1, 1): + assert len([sl for sl in input_layers if circuit.layer_scope(sl) == Scope([i])]) == rank + assert all(isinstance(sl, HadamardLayer) for sl in product_layers) + assert len(product_layers) == (len(shape) - 2) * rank + 1 + assert len(sum_layers) == len(shape) - 1 + for sl in sum_layers: + assert len(sl.weight.nodes) == 1 + weight = sl.weight.nodes[0] + assert isinstance(weight, ConstantParameter) + value = np.reshape(weight.value, shape=(sl.num_output_units, sl.arity, sl.num_input_units)) + ones = np.ones(sl.num_input_units) + zeros = np.zeros(sl.num_input_units) + for i in range(sl.num_output_units): + assert np.all(value[i, i] == ones) + for j in range(sl.num_output_units): + if i == j: + continue + assert np.all(value[i, j] == zeros) + if factor_param is not None: + for sl in input_layers: + assert len(sl.weight.nodes) == 1 + assert sl.weight.nodes[0].dtype == DataType.COMPLEX