def __init__(
self,
formula,
aliases,
varinvalias,
axis=0,
dtype=default_dtype,
cuda_type=None,
dtype_acc="auto",
use_double_acc=False,
sum_scheme="auto",
enable_chunks=True,
rec_multVar_highdim=None,
):
r"""
Instantiate a new KernelSolve operation.
Note:
:class:`KernelSolve` relies on CUDA kernels that are compiled on-the-fly
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect input Tensors whose
shape are compatible with **aliases**.
varinvalias (string): The alphanumerical **alias** of the variable with
respect to which we shall perform our conjugate gradient descent.
**formula** is supposed to be linear with respect to **varinvalias**,
but may be more sophisticated than a mere ``"K(x,y) * {varinvalias}"``.
Keyword Args:
alpha (float, default = 1e-10): Non-negative
**ridge regularization** parameter, added to the diagonal
of the Kernel matrix :math:`K_{xx}`.
axis (int, default = 0): Specifies the dimension of the kernel matrix :math:`K_{x_ix_j}` that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float32"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float16"`` or ``"half"``.
- **dtype** = ``"float32"`` or ``"float"``.
- **dtype** = ``"float64"`` or ``"double"``.
dtype_acc (string, default ``"auto"``): type for accumulator of reduction, before casting to dtype.
It improves the accuracy of results in case of large sized data, but is slower.
Default value "auto" will set this option to the value of dtype. The supported values are:
- **dtype_acc** = ``"float16"`` : allowed only if dtype is "float16".
- **dtype_acc** = ``"float32"`` : allowed only if dtype is "float16" or "float32".
- **dtype_acc** = ``"float64"`` : allowed only if dtype is "float32" or "float64"..
use_double_acc (bool, default False): same as setting dtype_acc="float64" (only one of the two options can be set)
If True, accumulate results of reduction in float64 variables, before casting to float32.
This can only be set to True when data is in float32 or float64.
It improves the accuracy of results in case of large sized data, but is slower.
sum_scheme (string, default ``"auto"``): method used to sum up results for reductions.
Default value "auto" will set this option to "block_red". Possible values are:
- **sum_scheme** = ``"direct_sum"``: direct summation
- **sum_scheme** = ``"block_sum"``: use an intermediate accumulator in each block before accumulating
in the output. This improves accuracy for large sized data.
- **sum_scheme** = ``"kahan_scheme"``: use Kahan summation algorithm to compensate for round-off errors. This improves
accuracy for large sized data.
enable_chunks (bool, default True): enable automatic selection of special "chunked" computation mode for accelerating reductions
with formulas involving large dimension variables.
"""
if cuda_type:
# cuda_type is just old keyword for dtype, so this is just a trick to keep backward compatibility
dtype = cuda_type
reduction_op = "Sum"
self.optional_flags = get_optional_flags(reduction_op, dtype_acc,
use_double_acc, sum_scheme,
dtype, enable_chunks)
self.formula = (reduction_op + "_Reduction(" + formula + "," +
str(axis2cat(axis)) + ")")
self.aliases = complete_aliases(
formula, list(aliases)) # just in case the user provided a tuple
if varinvalias[:4] == "Var(":
# varinv is given directly as Var(*,*,*) so we just have to read the index
varinvpos = int(varinvalias[4:varinvalias.find(",")])
else:
# we need to recover index from alias
tmp = self.aliases.copy()
for (i, s) in enumerate(tmp):
tmp[i] = s[:s.find("=")].strip()
varinvpos = tmp.index(varinvalias)
self.varinvpos = varinvpos
self.dtype = dtype
self.rec_multVar_highdim = rec_multVar_highdim
def __init__(self,
formula,
aliases,
varinvalias,
axis=0,
dtype=default_dtype,
opt_arg=None,
use_double_acc=False,
use_BlockRed="auto",
use_Kahan=False):
r"""
Instantiate a new KernelSolve operation.
Note:
:class:`KernelSolve` relies on C++ or CUDA kernels that are compiled on-the-fly
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect input arrays whose
shape are compatible with **aliases**.
varinvalias (string): The alphanumerical **alias** of the variable with
respect to which we shall perform our conjugate gradient descent.
**formula** is supposed to be linear with respect to **varinvalias**,
but may be more sophisticated than a mere ``"K(x,y) * {varinvalias}"``.
Keyword Args:
axis (int, default = 0): Specifies the dimension of the kernel matrix :math:`K_{x_ix_j}` that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float32"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float32"`` or ``"float"``.
- **dtype** = ``"float64"`` or ``"double"``.
"""
reduction_op = 'Sum'
if opt_arg:
self.formula = reduction_op + '_Reduction(' + formula + ',' + str(
opt_arg) + ',' + str(axis2cat(axis)) + ')'
else:
self.formula = reduction_op + '_Reduction(' + formula + ',' + str(
axis2cat(axis)) + ')'
optional_flags = get_accuracy_flags(use_double_acc, use_BlockRed,
use_Kahan, dtype, reduction_op)
self.aliases = complete_aliases(formula, aliases)
(self.categories, self.dimensions) = parse_aliases(self.aliases)
self.varinvalias = varinvalias
self.dtype = dtype
self.myconv = LoadKeOps(self.formula, self.aliases, self.dtype,
'numpy', optional_flags).import_module()
if varinvalias[:4] == "Var(":
# varinv is given directly as Var(*,*,*) so we just have to read the index
varinvpos = int(varinvalias[4:varinvalias.find(",")])
else:
# we need to recover index from alias
tmp = self.aliases.copy()
for (i, s) in enumerate(tmp):
tmp[i] = s[:s.find("=")].strip()
varinvpos = tmp.index(varinvalias)
self.varinvpos = varinvpos
def __init__(self,
formula,
aliases,
reduction_op='Sum',
axis=0,
dtype=default_dtype,
opt_arg=None,
formula2=None,
cuda_type=None,
dtype_acc="auto",
use_double_acc=False,
sum_scheme="auto"):
r"""
Instantiate a new generic operation.
Note:
:class:`Genred` relies on C++ or CUDA kernels that are compiled on-the-fly,
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect as input Tensors whose
shape are compatible with **aliases**.
Keyword Args:
reduction_op (string, default = ``"Sum"``): Specifies the reduction
operation that is applied to reduce the values
of ``formula(x_i, y_j, ...)`` along axis 0 or axis 1.
The supported values are one of :ref:`part.reduction`.
axis (int, default = 0): Specifies the dimension of the "kernel matrix" that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float32"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float16"`` or ``"half"``.
- **dtype** = ``"float32"`` or ``"float"``.
- **dtype** = ``"float64"`` or ``"double"``.
opt_arg (int, default = None): If **reduction_op** is in ``["KMin", "ArgKMin", "KMin_ArgKMin"]``,
this argument allows you to specify the number ``K`` of neighbors to consider.
dtype_acc (string, default ``"auto"``): type for accumulator of reduction, before casting to dtype.
It improves the accuracy of results in case of large sized data, but is slower.
Default value "auto" will set this option to the value of dtype. The supported values are:
- **dtype_acc** = ``"float16"`` : allowed only if dtype is "float16".
- **dtype_acc** = ``"float32"`` : allowed only if dtype is "float16" or "float32".
- **dtype_acc** = ``"float64"`` : allowed only if dtype is "float32" or "float64"..
use_double_acc (bool, default False): same as setting dtype_acc="float64" (only one of the two options can be set)
If True, accumulate results of reduction in float64 variables, before casting to float32.
This can only be set to True when data is in float32 or float64.
It improves the accuracy of results in case of large sized data, but is slower.
sum_scheme (string, default ``"auto"``): method used to sum up results for reductions.
Default value "auto" will set this option to "block_red". Possible values are:
- **sum_scheme** = ``"direct_sum"``: direct summation
- **sum_scheme** = ``"block_sum"``: use an intermediate accumulator in each block before accumulating
in the output. This improves accuracy for large sized data.
- **sum_scheme** = ``"kahan_scheme"``: use Kahan summation algorithm to compensate for round-off errors. This improves
accuracy for large sized data.
"""
if cuda_type:
# cuda_type is just old keyword for dtype, so this is just a trick to keep backward compatibility
dtype = cuda_type
self.reduction_op = reduction_op
reduction_op_internal, formula2 = preprocess(reduction_op, formula2)
self.accuracy_flags = get_accuracy_flags(dtype_acc, use_double_acc,
sum_scheme, dtype,
reduction_op_internal)
str_opt_arg = ',' + str(opt_arg) if opt_arg else ''
str_formula2 = ',' + formula2 if formula2 else ''
self.formula = reduction_op_internal + '_Reduction(' + formula + str_opt_arg + ',' + str(
axis2cat(axis)) + str_formula2 + ')'
self.aliases = complete_aliases(
self.formula,
list(aliases)) # just in case the user provided a tuple
self.dtype = dtype
self.axis = axis
self.opt_arg = opt_arg
def __init__(
self,
formula,
aliases,
reduction_op="Sum",
axis=0,
dtype=default_dtype,
opt_arg=None,
formula2=None,
cuda_type=None,
dtype_acc="auto",
use_double_acc=False,
sum_scheme="auto",
enable_chunks=True,
optional_flags=[],
rec_multVar_highdim=None,
):
r"""
Instantiate a new generic operation.
Note:
:class:`Genred` relies on C++ or CUDA kernels that are compiled on-the-fly,
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect as input Tensors whose
shape are compatible with **aliases**.
Keyword Args:
reduction_op (string, default = ``"Sum"``): Specifies the reduction
operation that is applied to reduce the values
of ``formula(x_i, y_j, ...)`` along axis 0 or axis 1.
The supported values are one of :ref:`part.reduction`
axis (int, default = 0): Specifies the dimension of the "kernel matrix" that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float64"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float32"``.
- **dtype** = ``"float64"``.
opt_arg (int, default = None): If **reduction_op** is in ``["KMin", "ArgKMin", "KMinArgKMin"]``,
this argument allows you to specify the number ``K`` of neighbors to consider.
dtype_acc (string, default ``"auto"``): type for accumulator of reduction, before casting to dtype.
It improves the accuracy of results in case of large sized data, but is slower.
Default value "auto" will set this option to the value of dtype. The supported values are:
- **dtype_acc** = ``"float16"`` : allowed only if dtype is "float16".
- **dtype_acc** = ``"float32"`` : allowed only if dtype is "float16" or "float32".
- **dtype_acc** = ``"float64"`` : allowed only if dtype is "float32" or "float64"..
use_double_acc (bool, default False): same as setting dtype_acc="float64" (only one of the two options can be set)
If True, accumulate results of reduction in float64 variables, before casting to float32.
This can only be set to True when data is in float32 or float64.
It improves the accuracy of results in case of large sized data, but is slower.
sum_scheme (string, default ``"auto"``): method used to sum up results for reductions. This option may be changed only
when reduction_op is one of: "Sum", "MaxSumShiftExp", "LogSumExp", "Max_SumShiftExpWeight", "LogSumExpWeight", "SumSoftMaxWeight".
Default value "auto" will set this option to "block_red" for these reductions. Possible values are:
- **sum_scheme** = ``"direct_sum"``: direct summation
- **sum_scheme** = ``"block_sum"``: use an intermediate accumulator in each block before accumulating in the output. This improves accuracy for large sized data.
- **sum_scheme** = ``"kahan_scheme"``: use Kahan summation algorithm to compensate for round-off errors. This improves
accuracy for large sized data.
enable_chunks (bool, default True): enable automatic selection of special "chunked" computation mode for accelerating reductions
with formulas involving large dimension variables.
optional_flags (list, default []): further optional flags passed to the compiler, in the form ['-D...=...','-D...=...']
"""
if cuda_type:
# cuda_type is just old keyword for dtype, so this is just a trick to keep backward compatibility
dtype = cuda_type
if dtype in ("float16", "half"):
raise ValueError(
"[KeOps] Float16 type is only supported with PyTorch tensors inputs."
)
self.reduction_op = reduction_op
reduction_op_internal, formula2 = preprocess(reduction_op, formula2)
if rec_multVar_highdim is not None:
optional_flags += ["-DMULT_VAR_HIGHDIM=1"]
self.optional_flags = optional_flags + get_optional_flags(
reduction_op_internal,
dtype_acc,
use_double_acc,
sum_scheme,
dtype,
enable_chunks,
)
str_opt_arg = "," + str(opt_arg) if opt_arg else ""
str_formula2 = "," + formula2 if formula2 else ""
self.formula = (reduction_op_internal + "_Reduction(" + formula +
str_opt_arg + "," + str(axis2cat(axis)) +
str_formula2 + ")")
self.aliases = complete_aliases(self.formula, aliases)
self.dtype = dtype
self.myconv = LoadKeOps(self.formula, self.aliases, self.dtype,
"numpy", self.optional_flags).import_module()
self.axis = axis
self.opt_arg = opt_arg
def __init__(self,
formula,
aliases,
varinvalias,
axis=0,
dtype=default_dtype,
cuda_type=None):
r"""
Instantiate a new KernelSolve operation.
Note:
:class:`KernelSolve` relies on CUDA kernels that are compiled on-the-fly
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect input Tensors whose
shape are compatible with **aliases**.
varinvalias (string): The alphanumerical **alias** of the variable with
respect to which we shall perform our conjugate gradient descent.
**formula** is supposed to be linear with respect to **varinvalias**,
but may be more sophisticated than a mere ``"K(x,y) * {varinvalias}"``.
Keyword Args:
alpha (float, default = 1e-10): Non-negative
**ridge regularization** parameter, added to the diagonal
of the Kernel matrix :math:`K_{xx}`.
axis (int, default = 0): Specifies the dimension of the kernel matrix :math:`K_{x_ix_j}` that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float32"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float32"`` or ``"float"``.
- **dtype** = ``"float64"`` or ``"double"``.
"""
if cuda_type:
# cuda_type is just old keyword for dtype, so this is just a trick to keep backward compatibility
dtype = cuda_type
reduction_op = 'Sum'
self.formula = reduction_op + '_Reduction(' + formula + ',' + str(
axis2cat(axis)) + ')'
self.aliases = complete_aliases(
formula, list(aliases)) # just in case the user provided a tuple
if varinvalias[:4] == "Var(":
# varinv is given directly as Var(*,*,*) so we just have to read the index
varinvpos = int(varinvalias[4:varinvalias.find(",")])
else:
# we need to recover index from alias
tmp = self.aliases.copy()
for (i, s) in enumerate(tmp):
tmp[i] = s[:s.find("=")].strip()
varinvpos = tmp.index(varinvalias)
self.varinvpos = varinvpos
self.dtype = dtype
def __init__(self,
formula,
aliases,
reduction_op='Sum',
axis=0,
dtype=default_dtype,
opt_arg=None,
formula2=None,
cuda_type=None):
r"""
Instantiate a new generic operation.
Note:
:class:`Genred` relies on C++ or CUDA kernels that are compiled on-the-fly,
and stored in a :ref:`cache directory <part.cache>` as shared libraries (".so" files) for later use.
Args:
formula (string): The scalar- or vector-valued expression
that should be computed and reduced.
The correct syntax is described in the :doc:`documentation <../../Genred>`,
using appropriate :doc:`mathematical operations <../../../api/math-operations>`.
aliases (list of strings): A list of identifiers of the form ``"AL = TYPE(DIM)"``
that specify the categories and dimensions of the input variables. Here:
- ``AL`` is an alphanumerical alias, used in the **formula**.
- ``TYPE`` is a *category*. One of:
- ``Vi``: indexation by :math:`i` along axis 0.
- ``Vj``: indexation by :math:`j` along axis 1.
- ``Pm``: no indexation, the input tensor is a *vector* and not a 2d array.
- ``DIM`` is an integer, the dimension of the current variable.
As described below, :meth:`__call__` will expect as input Tensors whose
shape are compatible with **aliases**.
Keyword Args:
reduction_op (string, default = ``"Sum"``): Specifies the reduction
operation that is applied to reduce the values
of ``formula(x_i, y_j, ...)`` along axis 0 or axis 1.
The supported values are one of :ref:`part.reduction`.
axis (int, default = 0): Specifies the dimension of the "kernel matrix" that is reduced by our routine.
The supported values are:
- **axis** = 0: reduction with respect to :math:`i`, outputs a ``Vj`` or ":math:`j`" variable.
- **axis** = 1: reduction with respect to :math:`j`, outputs a ``Vi`` or ":math:`i`" variable.
dtype (string, default = ``"float32"``): Specifies the numerical ``dtype`` of the input and output arrays.
The supported values are:
- **dtype** = ``"float32"`` or ``"float"``.
- **dtype** = ``"float64"`` or ``"double"``.
opt_arg (int, default = None): If **reduction_op** is in ``["KMin", "ArgKMin", "KMin_ArgKMin"]``,
this argument allows you to specify the number ``K`` of neighbors to consider.
"""
if cuda_type:
# cuda_type is just old keyword for dtype, so this is just a trick to keep backward compatibility
dtype = cuda_type
self.reduction_op = reduction_op
reduction_op_internal, formula2 = preprocess(reduction_op, formula2)
str_opt_arg = ',' + str(opt_arg) if opt_arg else ''
str_formula2 = ',' + formula2 if formula2 else ''
self.formula = reduction_op_internal + '_Reduction(' + formula + str_opt_arg + ',' + str(
axis2cat(axis)) + str_formula2 + ')'
self.aliases = complete_aliases(
self.formula,
list(aliases)) # just in case the user provided a tuple
self.dtype = dtype
self.axis = axis
self.opt_arg = opt_arg
