CTileTensor#
- class CTileTensor#
An encrypted tile tensor. A tile tensor is an data structure for storing tensors (multipy dimensional arrays, e.g., vectors, matrices, or higher dimensional arrays) in a set of fixed size tiles, in this case ciphertexts.
- add(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise add with other CTileTensor. Relies on CTile::add.
- Parameters:
other (CTileTensor) – other CTileTensor to add.
- add_plain(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise add with other (plaintext) PTileTensor. Relies on CTile::add_plain.
- Parameters:
other (PTileTensor) – other PTileTensor to add.
- add_plain_raw(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise add with other (plaintext) PTileTensor. Relies on CTile::add_plain_raw.
- Parameters:
other (PTileTensor) – other PTileTensor to add.
- add_raw(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise add with other CTileTensor. Relies on CTile::add_raw.
- Parameters:
other (CTileTensor) – other CTileTensor to add.
- add_scalar(self: pyhelayers.CTileTensor, scalar: float, keep_unknowns_clear: bool = False) None#
adds a double scalar value to all elements of this tensor.
- Parameters:
scalar (double) – double value to add.
keep_unknowns_clear (boolean) – the default is ‘false’.
- adjust_chain_index(self: pyhelayers.CTileTensor, chain_index: int) None#
Calls corresponding function for every CTile.
- Parameters:
chain_index (int) – The required chain index.
- clear_unknowns(self: pyhelayers.CTileTensor) None#
Clears all unknowns from this tile tensor.
- duplicate_over_dim(self: pyhelayers.CTileTensor, dim: int) None#
Cause a dimension to become duplicated
- Parameters:
dim (int) – The dimension to duplicate.
- flatten(*args, **kwargs)#
Overloaded function.
flatten(self: pyhelayers.CTileTensor, start_dim: int, end_dim: int) -> None
Flattens consecutive fully-duplicated dimensions into a single fully-duplicated dimension. The Flattened dimension will have tile size equals to the product of tile sizes of all the flattened dimensions, and will be considered interleaved if and only if all the flattened dimensions are.
- param start_dim:
The first dimension to be flattened.
- type start_dim:
int
- param end_dim:
The dimension in which to end the flattening (exclusive). Flatten(a, b) will flatten dimensions [a,b).
- type end_dim:
int
- raises RuntimeError:
If the specified dimensions do not exist, or are not fully duplicated, or if startDim >= endDim.
flatten(self: pyhelayers.CTileTensor, start_dim: int, end_dim: int) -> pyhelayers.CTileTensor
Returns the result of Flattening consecutive fully-duplicated dimensions into a single fully-duplicated dimension. See also CTileTensor::flatten.
- param start_dim:
The first dimension to be flattened.
- type start_dim:
int
- param end_dim:
The dimension in which to end the flattening (exclusive). Flatten(a, b) will flatten dimensions [a,b).
- type end_dim:
int
- raises RuntimeError:
If the specified dimensions do not exist, or are not fully duplicated, or if startDim >= endDim.
- get_add_plain(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise add of this and other PTileTensor. Relies on CTile::addPlain.
- Parameters:
plain (PTileTensor) – Other PTileTensor to add.
- get_add_plain_raw(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise add of this and other PTileTensor. Relies on CTile::addPlainRaw.
- Parameters:
plain (PTileTensor) – Other PTileTensor to add.
- get_add_scalar(self: pyhelayers.CTileTensor, val: float) pyhelayers.CTileTensor#
Returns the result of elementwise add of this and the given scalar.
- Parameters:
val (double) – Scalar to add.
- get_chain_index(self: pyhelayers.CTileTensor) int#
Returns chain index of tiles. They are maintained to have equal chain index.
- get_clear_unknowns(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of cleraing all unknowns.
- get_convolution(self: pyhelayers.CTileTensor, filters: pyhelayers.CTileTensor, biases: pyhelayers.CTileTensor, stride_rows: int, stride_cols: int) pyhelayers.CTileTensor#
Returns the result of appling convolution with the given parameters.
- Parameters:
filters (CTileTensor) – The filters to convolute with.
biases (CTileTensor) – The biases to add.
stride_rows (int) – Stride rows parameter to use during the convolution.
stride_cols (int) – Stride cols parameter to use during the convolution.
- get_duplicate_over_dim(self: pyhelayers.CTileTensor, dim: int) pyhelayers.CTileTensor#
Returns the result of duplicating the specified dimension.
- Parameters:
dim (int) – The dimension to duplicate.
- get_matrix_multiplication(self: pyhelayers.CTileTensor, other: pyhelayers.TileTensor, sum_dim: int) pyhelayers.CTileTensor#
Computes matrix-vector multiplication with other. For non-diagonalized computation, it calls get_multiply_and_sum() (See documentation in get_multiply_and_sum())
For diagonalization, other shape should be diagonalized. For example: Other is a matrix [(d)16/t1,6/t2,1/t3] This is a vector [16/t1*t2,1/t3] Result is [*/t1,6/t2,1/t3]
Constraints: - other should be diagonalized - this should not be diagonalized - this tile size 0 should equal other tileSize0*tileSize1 - this original size 0 should equal other original size 0 - this dims 1..end should be identical to other dims 2..end. (will be extended to support comptability) - sumDim must be 0
- Parameters:
other – Other tile tensor to multiply with
sumDim – Dimension to sum over.
- get_multiply_and_sum(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor, sum_dim: int) pyhelayers.CTileTensor#
Returns the result of elementwise multiplication and summation between this and other. See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other (CTileTensor) – Other encoded tile tensor.
sumDim – Dimension to sum over.
- get_multiply_plain(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise multiplication of this and other PTileTensor. Relies on CTile::multiplyPlain.
- Parameters:
plain (PTileTensor) – Other PTileTensor to multiply by.
- get_multiply_plain_and_sum(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor, sum_dim: int) pyhelayers.CTileTensor#
Returns the result of elementwise multiplication and summation between this and other. See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other (PTileTensor) – Other encoded tile tensor.
sumDim – Dimension to sum over.
- get_multiply_plain_raw(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise multiplication of this and other PTileTensor. Relies on CTile::multiplyPlainRaw.
- Parameters:
plain (PTileTensor) – Other PTileTensor to multiply by.
- get_multiply_scalar(self: pyhelayers.CTileTensor, val: float) pyhelayers.CTileTensor#
Returns the result of elementwise multiplication of this and the given scalar.
- Parameters:
val (double) – Scalar to multiply by.
- get_reduce_chain_index(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of reducing chain indexes of every CTile.
- get_relinearize(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of calling relinearize on every CTile.
- get_rescale(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of calling rescale on every CTile.
- get_set_chain_index(*args, **kwargs)#
Overloaded function.
get_set_chain_index(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) -> pyhelayers.CTileTensor
Returns the result of Calling corresponding function for every CTile.
- param other:
CTileTensor to get chain index from.
- type other:
CTileTensor
get_set_chain_index(self: pyhelayers.CTileTensor, chain_index: int) -> pyhelayers.CTileTensor
Returns the result of Calling corresponding function for every CTile.
- param chain_index:
The required chain index.
- type chain_index:
int
- get_slice(self: pyhelayers.CTileTensor, dim: int, start_index: int, slice_depth: int) pyhelayers.CTileTensor#
Returns a slice of the tensor in specific dimension. Result has the same number of dimensions as the original tensor. For dim with tile size of 1, getSlice is supported for every valid startIndex and sliceDepth. For a non-interleaved dim with tile size > 1, getSlice is supported only for startIndex which is a multiple of the tile size. For interleaved dim with tile size > 1, getSlice is supported only for startIndex 0.
- Parameters:
dim – The dimension to slice along. Specifying negative value will count from the last dim backwards (-1 for the last dim, -2 for the previoud one etc.).
start_index – The index to start slicing at along the dimension
slice_depth – The depth/size of the slice along the dimension
- get_square(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise squaring of this CTileTensor. Relies on CTile::square.
- get_square_raw(self: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise squaring of this CTileTensor. Relies on CTile::squareRaw.
- get_sub(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise sub of this and other CTileTensor. Relies on CTile::sub.
- Parameters:
other (CTileTensor) – Other CTileTensor to sub.
- get_sub_plain(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise sub of this and other PTileTensor. Relies on CTile::subPlain.
- Parameters:
plain (PTileTensor) – Other PTileTensor to sub.
- get_sub_plain_raw(self: pyhelayers.CTileTensor, plain: pyhelayers.PTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise sub of this and other PTileTensor. Relies on CTile::subPlainRaw.
- Parameters:
plain (PTileTensor) – Other PTileTensor to sub.
- get_sub_raw(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) pyhelayers.CTileTensor#
Returns the result of elementwise sub of this and other CTileTensor. Relies on CTile::subRaw.
- Parameters:
other (CTileTensor) – Other CTileTensor to sub.
- get_sum_in_tiles_over_dim(self: pyhelayers.CTileTensor, dim: int) pyhelayers.CTileTensor#
Returns the result of summing inside the tiles over the specified dimension.
- Parameters:
dim (int) – The dimension to sum over.
- get_sum_over_dim(self: pyhelayers.CTileTensor, dim: int) pyhelayers.CTileTensor#
Returns the result of summing over the specified dimension.
- Parameters:
dim (int) – The dimension to sum over.
- get_sum_tiles_over_dim(self: pyhelayers.CTileTensor, dim: int) pyhelayers.CTileTensor#
Returns the result of summing tiles over the specified dimension.
- Parameters:
dim (int) – The dimension to sum over.
- multiply(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise multiplication with other CTileTensor. Relies on CTile::multiply.
- Parameters:
other (CTileTensor) – other CTileTensor to multiply by.
- multiply_and_sum(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor, sum_dim: int) None#
Performs elementwise multiplication between this and other, then sums over the specified dim. If both are vectors of same length, sum over dim 0 to get inner product.
If this is a matrix [a/t1,b/t2] and other is a vector [a/t1,*/t2], sum over dim 0 will produce the matrix-vector multiplication. Similarly for matrix [a/t1,b/t2] and vector [*/t1,b/t2], sum over dim 1.
For matrix-matrix multiplication use for example:
Matrix1 [ a/t1,b/t2,* /t3] and Matrix2 [a/t1,* / t2, c/t3], sum over dim 0.
or:
Matrix1 [ a/t1,b/t2,* /t3] and Matrix2 [* / t1,b / t2, c/t3], sum over dim 1.
- Parameters:
other (CTileTensor) – Other encrypted tile tensor.
sumDim (int) – Dimension to sum over.
- multiply_plain(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise multiply by other (plaintext) PTileTensor. Relies on CTile::multiply_plain.
- Parameters:
other (PTileTensor) – other PTileTensor to multiply by.
- multiply_plain_and_sum(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor, sum_dim: int) None#
Performs elementwise multiplication between this and other, then sums over the specified dim. See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other (PTileTensor) – Other encoded tile tensor.
sumDim – Dimension to sum over.
- multiply_plain_raw(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise multiply by other (plaintext) PTileTensor. Relies on CTile::multiply_plain_raw.
- Parameters:
other (PTileTensor) – other PTileTensor to multiply by.
- multiply_raw(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise multiplication with other CTileTensor. Relies on CTile::multiply_raw.
- Parameters:
other (CTileTensor) – other CTileTensor to multiply by.
- multiply_scalar(self: pyhelayers.CTileTensor, scalar: float) None#
Multiplies all used tensor elements by a given scalar. Consumes one chain index. As a side effect, unused elements will be zeroed, thus unknown unused elements will be eliminated.
- Parameters:
scalar (double) – double value to multiply by.
- negate(self: pyhelayers.CTileTensor) None#
Elementwise negate. Relies on CTile::negate.
- re_encrypt(self: pyhelayers.CTileTensor) None#
Decrypt the CTileTensor and encrypts it again to bring it to top chain index.
- reduce_chain_index(self: pyhelayers.CTileTensor) None#
Calls corresponding function for every CTile.
- relinearize(self: pyhelayers.CTileTensor) None#
Calls corresponding function for every CTile
- relinearize_and_rescale(self: pyhelayers.CTileTensor) None#
Calls corresponding function for every CTile
- rescale(self: pyhelayers.CTileTensor) None#
Calls corresponding function for every CTile
- rotate_along_dim(self: pyhelayers.CTileTensor, dim: int, rot: int) None#
Rotates this CTileTensor along the specified dimension (index (i+rot) % originalSize moves to i). The elements that fall out of one end cycle back in the other end. If the external size of “dim” is not 1, then “dim” must be interleaved. If the external size of “dim” is 1, the rotation works and will have the same effect regardless of the interleaved flag being on or off. For the rotation to succeed, “dim” must be the first non-trivial” dimension, and it must not contain any unused slots.
- Parameters:
dim (int) – The dimension to rotate along.
rot (int) – The rotation offset.
- Raises:
ValueError – If the rotated dimension does not satisfy the
above requirements.
- set_chain_index(*args, **kwargs)#
Overloaded function.
set_chain_index(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) -> None
Calls corresponding function for every CTile.
- param other:
CTileTensor to get chain index from.
- type other:
CTileTensor
set_chain_index(self: pyhelayers.CTileTensor, chain_index: int) -> None
Calls corresponding function for every CTile.
- param chain_index:
The required chain index.
- type chain_index:
int
- shift_along_dim(self: pyhelayers.CTileTensor, dim: int, shift: int) None#
Shifts this CTileTensor along the specified dimension (index i+shift moves to i). The elements that fall out of one end do not cycle back in the other end. If the external size of “dim” is not 1, then “dim” must be interleaved. If the external size of “dim” is 1, the shift works and will have the same effect regardless of the interleaved flag being on or off. “shift” must be positive and smaller than the original size of “dim”. Following the shift, the original size of dim will be reduced by the given “shift” value, and the unused slots will be marked unkown.
- Parameters:
dim (int) – The dimension to shift along.
rot (int) – The shift offset.
- Raises:
ValueError – If the shifted dimension does not satisfy the
above requirements. :raises ValueError: If “shift” is negative or greater than the original size of “dim”.
- square(self: pyhelayers.CTileTensor) None#
Elementwise square. Relies on CTile::square.
- square_raw(self: pyhelayers.CTileTensor) None#
Elementwise square. Relies on CTile::squareRaw.
- sub(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise sub with other CTileTensor. Relies on CTile::sub.
- Parameters:
other (CTileTensor) – other CTileTensor to subtract.
- sub_plain(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise sub with other (plaintext) PTileTensor. Relies on CTile::sub_plain.
- Parameters:
other (PTileTensor) – other PTileTensor to subtract.
- sub_plain_raw(self: pyhelayers.CTileTensor, other: pyhelayers.PTileTensor) None#
Elementwise sub with other (plaintext) PTileTensor. Relies on CTile::sub_plain_raw.
- Parameters:
other (PTileTensor) – other PTileTensor to subtract.
- sub_raw(self: pyhelayers.CTileTensor, other: pyhelayers.CTileTensor) None#
Elementwise sub with other CTileTensor. Relies on CTile::sub_raw.
- Parameters:
other (CTileTensor) – other CTileTensor to subtract.
- sum_in_tiles_over_dim(self: pyhelayers.CTileTensor, dim: int) None#
Sums inside tiles over a dimension.
- Parameters:
dim (int) – The dimension to sum inside tiles over it.
- sum_over_dim(self: pyhelayers.CTileTensor, dim: int) None#
Sums over a dimension.
- Parameters:
dim (int) – The dimension to sum over.
- sum_tiles_over_dim(self: pyhelayers.CTileTensor, dim: int) None#
Sums tile over a dimension.
- Parameters:
dim (int) – The dimension to sum over.
-
class CTileTensor : public helayers::TileTensor#
An encrypted tile tensor.
A tile tensor is a data structure for storing tensors (multipy dimensional arrays, e.g., vectors, matrices, or higher dimensional arrays) in a set of fixed size tiles, in this case ciphertexts.
Public Types
-
typedef boost::numeric::ublas::tensor<CTile, PTileTensor::tensorFormat> ExternalTensorType#
Underlying type used to store the external tensor.
-
using BitwiseEvaluatorMethod = CTile (BitwiseEvaluator::*)(const CTile&, const CTile&) const#
Applies bitwise operation on each two corresponding tiles.
- Param other:
Other encrypted tile tensor
- Param be:
BitwiseEvaluator of the HeContext corresponding to this CTileTensor
- Param method:
A BitwiseEvaluator method to apply. The method must receive two CTiles as input and return a CTile
- Param actionType:
Indication whether this is an ADDITIVE_ACTION_TYPE, a MULTIPLICATIVE_ACTION_TYPE, or OTHER_ACTION_TYPE. The default is OTHER_ACTION_TYPE, the most restrictive.
Public Functions
-
CTileTensor(const CTileTensor &src)#
Copy constructor.
- Parameters:
src – [in] object to copy
-
CTileTensor(CTileTensor &&src)#
Move constructor.
- Parameters:
src – [in] object to move
-
CTileTensor(const HeContext &he, const TTShape &s)#
Construct an object of a certain chape.
- Parameters:
he – [in] the context
s – [in] shape of new object
-
~CTileTensor()#
-
CTileTensor &operator=(const CTileTensor &src)#
Copy other tile tensor to this one.
- Parameters:
src – [in] object to copy
-
CTileTensor &operator=(CTileTensor &&src)#
Move other tile tensor to this one.
- Parameters:
src – [in] object to move
-
void add(const CTileTensor &other)#
Elementwise add with other CTileTensor.
Relies on CTile::add.
- Parameters:
other – [in] other CTileTensor to add.
-
void addRaw(const CTileTensor &other)#
Elementwise add with other CTileTensor.
Relies on CTile::addRaw.
- Parameters:
other – [in] other CTileTensor to add.
-
void sub(const CTileTensor &other)#
Elementwise subtract other CTileTensor from this.
Relies on CTile::sub.
- Parameters:
other – [in] other CTileTensor to subtract.
-
void subRaw(const CTileTensor &other)#
Elementwise subtract other CTileTensor from this.
Relies on CTile::subRaw.
- Parameters:
other – [in] other CTileTensor to subtract.
-
void multiply(const CTileTensor &other)#
Elementwise multiply with other CTileTensor.
Relies on CTile::multiply.
- Parameters:
other – [in] other CTileTensor to multiply.
-
void multiplyRaw(const CTileTensor &other)#
Elementwise multiply with other CTileTensor.
Relies on CTile::multiplyRaw.
- Parameters:
other – [in] other CTileTensor to multiply.
-
void addPlain(const PTileTensor &plain)#
Elementwise add with other (plaintext) PTileTensor.
Relies on CTile::addPlain.
- Parameters:
plain – [in] other PTileTensor to add.
-
void addPlainRaw(const PTileTensor &plain)#
Elementwise add with other (plaintext) PTileTensor.
Relies on CTile::addPlainRaw.
- Parameters:
plain – [in] other PTileTensor to add.
-
void subPlain(const PTileTensor &plain)#
Elementwise subtract other (plaintext) PTileTensor from this.
Relies on CTile::subPlain.
- Parameters:
plain – [in] other PTileTensor to subtract.
-
void subPlainRaw(const PTileTensor &plain)#
Elementwise subtract other (plaintext) PTileTensor from this.
Relies on CTile::subPlainRaw.
- Parameters:
plain – [in] other PTileTensor to subtract.
-
void multiplyPlain(const PTileTensor &plain)#
Elementwise multiply with other (plaintext) PTileTensor.
Relies on CTile::multiplyPlain.
- Parameters:
plain – [in] other PTileTensor to multiply.
-
void multiplyPlainRaw(const PTileTensor &plain)#
Elementwise multiply with other (plaintext) PTileTensor.
Relies on CTile::multiplyPlainRaw.
- Parameters:
plain – [in] other PTileTensor to multiply.
-
void addScalar(double val, bool keepUnknownsClear = false)#
Add scalar to all tensor elements.
Relies on CTile::addScalar. Will add unknowns to unused slots, unless the keepUnknownsClear is set, which causes a more costly operation.
- Parameters:
val – [in] Value to add.
keepUnknownsClear – [in] If set and current shape has no unknowns, it will keep it that way.
-
void multiplyScalar(double val)#
Multiplies all used tensor elements by a given scalar.
Consumes one chain index. As a side effect, unused elements will be zeroed, thus unknown unused elements will be eliminated.
- Parameters:
val – [in] Value to multiply by.
-
void square()#
Elementwise square. Relies on CTile::square.
-
void squareRaw()#
Elementwise squareRaw. Relies on CTile::squareRaw.
-
void negate()#
Elementwise negate. Relies on CTile::negate.
-
void multiplyAndSum(const CTileTensor &other, int sumDim)#
Performs elementwise multiplication between this and other, then sums over specified dim.
Example usages: If both are vectors of same length, sum over dim 0 to get inner product If this is a matrix [a/t1,b/t2] and other is a vector [a/t1,*/t2], sum over dim 0 will produce the matrix-vector multiplication. Similarly for matrix [a/t1,b/t2] and vector [*/t1,b/t2], sum over dim 1.
For matrix-matrix multiplication use for example: Matrix1 [ a/t1,b/t2,* /t3] and Matrix2 [a/t1,* / t2, c/t3], sum over dim 0. or: Matrix1 [ a/t1,b/t2,* /t3] and Matrix2 [* / t1,b / t2, c/t3], sum over dim 1.
- Parameters:
other – Other encrypted tile tensor
sumDim – Dimension to sum over
-
void multiplyPlainAndSum(const PTileTensor &other, int sumDim)#
Performs elementwise multiplication between this and other, then sums over specified dim.
See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other – Other encoded tile tensor
sumDim – Dimension to sum over
-
void applyBitwiseMethod(const CTileTensor &other, const BitwiseEvaluator &be, BitwiseEvaluatorMethod method, ActionType actionType = OTHER_ACTION_TYPE)#
-
void sumOverDim(int dim)#
Sums over a dimension.
- Parameters:
dim – [in] Dimension to sum over.
-
void sumTilesOverDim(int dim)#
Sums tile over a dimension.
-
void sumInTilesOverDim(int dim)#
Sum inside tiles.
This method assumes the external size along this dimension is 1. It reduces the original size to 1 by summing inside the remaining tile.
The result will be duplicated if this is the first non-trivial dimension. Note if the originalSize is 1, this call will still incur rotations if this is the first non-trivial dim, to satisfy the duplicated result requirement.
- Parameters:
dim – Dimension to sum over.
-
void multiplyOverDim(int dim)#
Multiplies over a dimension.
- Parameters:
dim – [in] Dimension to multiply over.
-
void multiplyTilesOverDim(int dim)#
Multiplies tile over a dimension.
-
void duplicateOverDim(int dim)#
Cause a dimension to become duplicated.
- Parameters:
dim – [in] Dimension to duplicate.
-
void clearUnknowns()#
Clears all unknowns from this tile tensor.
-
void flatten(int startDim, int endDim)#
Flattens consecutive fully-duplicated dimensions into a single fully-duplicated dimension.
The Flattened dimension will have tile size equals to the product of tile sizes of all the flattened dimensions, and will be considered interleaved if and only if all the flattened dimensions are.
- Parameters:
startDim – [in] The first dimension to be flattened.
endDim – [in] The dimension in which to end the flattening (exclusive). Flatten(a, b) will flatten dimensions [a,b).
- Throws:
runtime_error – If the specified dimensions do not exist, or are not fully duplicated, or if startDim >= endDim.
-
void reorderDims(const std::vector<DimInt> &dimOrder)#
Reorders the dimensions of this tensor.
The relative order of dimensions with tile size > 1 must be kept. For example, given {1,2,0}, the current second dimension will become first, the current third dimension will become second, and the current first dimension will become last.
- Parameters:
dimOrder – New order of dimensions
- Throws:
runtime_error – If dimOrder size doesn’t match number of dims.
runtime_error – If the relative order of dimensions with tile size > 1 is not the same as in dimOrder.
-
void addDim(int place = -1)#
Adds a dim with original size and tile size 1 to this tensor at given place.
- Parameters:
place – Place of the new dimension, default is last.
-
void removeDim(DimInt dim)#
Removes a dim from this tensor.
Only for dim with original size 1 and tile size 1. Number of dims before calling the function must be at least 3.
- Parameters:
dim – Dim to remove
- Throws:
runtime_error – If dim doesn’t exists
runtime_error – If dim is not of size 1
runtime_error – If number of dims is less than 3
-
void setChainIndex(const CTileTensor &other)#
Calls corresponding function for every CTile.
-
virtual int getChainIndex() const override#
Returns chain index of tiles.
They are maintained to have equal chain index.
-
double getScale() const#
Returns the scale of the tiles.
They are maintained to have equal scales.
-
void reEncrypt()#
Decrypt the CTileTensor and encrypts it again to bring it to top chain index.
- Throws:
runtime_error – if HeContext doesn’t have the secret key.
-
void fakeBootstrap()#
A testing method.
-
void bootstrap()#
Performs bootstrap on all the tiles of this tile tensor.
-
inline virtual const CTile &getTileAt(const std::vector<DimInt> &inds) const override#
Returns the tile specified by the given indices.
- Parameters:
inds – Indices of tiles. Their number should match the number of dimensions, except trailing trivial dimensions where the external size is 1 which may be omitted.
-
virtual const CTile &getTileByFlatIndex(DimInt i) const override#
Returns the i’th tile in a flattened order according to the first-order convention.
- Parameters:
i – Index of tile
-
virtual CTileTensor getAdd(const CTileTensor &other) const override#
Returns the result of elementwise add of this and other CTileTensor.
Relies on CTile::add.
- Parameters:
other – [in] other CTileTensor to add.
-
virtual CTileTensor getAddRaw(const CTileTensor &other) const override#
Returns the result of elementwise add of this and other CTileTensor.
Relies on CTile::addRaw.
- Parameters:
other – [in] other CTileTensor to add.
-
virtual void addTo(CTileTensor &other) const override#
Equivalent to other.add(*this)
- Parameters:
other – [in] other CTileTensor to add.
-
virtual void addToRaw(CTileTensor &other) const override#
See addTo()
-
virtual void subFrom(CTileTensor &other) const override#
Equivalent to other.sub(*this)
- Parameters:
other – [in] other CTileTensor to subtract from.
-
virtual void subFromRaw(CTileTensor &other) const override#
See subFrom()
-
virtual void multiplyTo(CTileTensor &other) const override#
Equivalent to other.multiply(*this)
- Parameters:
other – [in] other CTileTensor to multiply to
-
virtual void multiplyToRaw(CTileTensor &other) const override#
See multiplyTo()
-
CTileTensor getSub(const CTileTensor &other) const#
Returns the result of elementwise sub of this and other CTileTensor.
Relies on CTile::sub.
- Parameters:
other – [in] other CTileTensor to sub.
-
CTileTensor getSubRaw(const CTileTensor &other) const#
Returns the result of elementwise sub of this and other CTileTensor.
Relies on CTile::subRaw.
- Parameters:
other – [in] other CTileTensor to sub.
-
virtual CTileTensor getMultiply(const CTileTensor &other) const override#
Returns the result of elementwise multiplication of this and other CTileTensor.
Relies on CTile::multiply.
- Parameters:
other – [in] other CTileTensor to multiply.
-
virtual CTileTensor getMultiplyRaw(const CTileTensor &other) const override#
Returns the result of elementwise multiplication of this and other CTileTensor.
Relies on CTile::multiplyRaw.
- Parameters:
other – [in] other CTileTensor to multiply.
-
CTileTensor getAddPlain(const PTileTensor &plain) const#
Returns the result of elementwise add with other (plaintext) PTileTensor.
Relies on CTile::addPlain.
- Parameters:
plain – [in] other PTileTensor to add.
-
CTileTensor getAddPlainRaw(const PTileTensor &plain) const#
Returns the result of elementwise add with other (plaintext) PTileTensor.
Relies on CTile::addPlainRaw.
- Parameters:
plain – [in] other PTileTensor to add.
-
CTileTensor getSubPlain(const PTileTensor &plain) const#
Returns the result of elementwise subtract with other (plaintext) PTileTensor.
Relies on CTile::subPlain.
- Parameters:
plain – [in] other PTileTensor to subtract.
-
CTileTensor getSubPlainRaw(const PTileTensor &plain) const#
Returns the result of elementwise subtract with other (plaintext) PTileTensor.
Relies on CTile::subPlainRaw.
- Parameters:
plain – [in] other PTileTensor to subtract.
-
CTileTensor getMultiplyPlain(const PTileTensor &plain) const#
Returns the result of elementwise multiplication with other (plaintext) PTileTensor.
Relies on CTile::multiplyPlain.
- Parameters:
plain – [in] other PTileTensor to multiply.
-
CTileTensor getMultiplyPlainRaw(const PTileTensor &plain) const#
Returns the result of elementwise multiplication with other (plaintext) PTileTensor.
Relies on CTile::multiplyPlainRaw.
- Parameters:
plain – [in] other PTileTensor to multiply.
-
CTileTensor getAddScalar(double val) const#
Returns the result of addition with a scalar.
- Parameters:
val – [in] Scalar to add.
-
CTileTensor getMultiplyScalar(double val) const#
Returns the result of multiplication with a scalar.
- Parameters:
val – [in] Scalar to multiply.
-
CTileTensor getSquare() const#
Returns the result of elementwise squaring.
Relies on CTile::square.
-
CTileTensor getSquareRaw() const#
Returns the result of elementwise squaring.
Relies on CTile::squareRaw.
-
virtual CTileTensor getMultiplyAndSum(const CTileTensor &other, int dim) const override#
Returns the result of elementwise multiplication of this and other and summing over specified dim.
See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other – Other encrypted tile tensor
dim – Dimension to sum over
-
virtual CTileTensor getMultiplyPlainAndSum(const PTileTensor &other, int dim) const#
Returns the result of elementwise multiplication of this and other and summing over specified dim.
See CTileTensor::multiplyAndSum for usage examples.
- Parameters:
other – Other encoded tile tensor
dim – Dimension to sum over
-
virtual void multiplyAndSumTo(CTileTensor &other, int dim) const override#
Equivalent to other.multiplyAndSum(*this, dim)
- Parameters:
other – Other encrypted tile tensor
dim – Dimension to sum over
-
CTileTensor getMatrixMultiplication(const TileTensor &other, int sumDim) const#
Computes matrix-vector multiplication with other.
For non-diagonalized computation, it calls getMultiplyAndSum() (See documentation in getMultiplyAndSum())
For diagonalization, other shape should be diagonalized. (See TTShape::setDiagonalized()) For example: Other is a matrix [(d)16/t1,6/t2,…] This is a vector [16/t1*t2,…] Result is [*/t1,6/t2,…]
Constraints:
other should be diagonalized
this should not be diagonalized
this tile size 0 should equal other tileSize0*tileSize1
this original size 0 should equal other original size 0
this dims 1..end should be identical to other dims 2..end. (will be extended to support comptability)
sumDim must be 0
- Parameters:
other – Other tile tensor to multiply with
sumDim – Dimension to sum over
-
CTileTensor getRelinearize() const#
Returns result with applying CTile::relinearize to all tiles.
-
CTileTensor getRescale() const#
Returns result with applying CTile::rescale to all tiles.
-
CTileTensor getSumOverDim(int dim) const#
Returns result of summing over a dimension.
- Parameters:
dim – Dimension to sum over
-
CTileTensor getSumTilesOverDim(int dim) const#
Returns results of summing tiles over a dimension.
Note this is function is used as an intermediate step when summing over dim. Most users should call getSumOverDim() directly.
- Parameters:
dim – Dimension to sum over
-
CTileTensor getSumInTilesOverDim(int dim) const#
Returns results of summing inside tiles over a dimension.
Note this is function is used as an intermediate step when summing over dim. Most users should call getSumOverDim() directly.
- Parameters:
dim – Dimension to sum over
-
CTileTensor getDuplicateOverDim(int dim) const#
Returns results of duplicating a dimension.
- Parameters:
dim – Dimension duplicate.
-
CTileTensor getClearUnknowns() const#
Returns results after multiplying with a mask to clear unkonwns.
-
CTileTensor getFlatten(int startDim, int endDim) const#
Returns the results after flatting some dimensions.
See flatten()
- Parameters:
startDim – The first dimension to be flattened.
endDim – The dimension in which to end the flattening (exclusive). Flatten(a, b) will flatten dimensions [a,b).
-
CTileTensor getReduceChainIndex() const#
Returns results after applying CTile::reduceChainIndex to all tiles.
-
CTileTensor getSetChainIndex(const CTileTensor &other) const#
Returns the results after setting chain index to equal other object.
- Parameters:
other – Other object to take chain index from.
-
CTileTensor getSetChainIndex(int chainIndex) const#
Returns the results after setting chain index.
- Parameters:
chainIndex – Chain index to set.
-
CTileTensor getConvolution(const CTileTensor &filters, const CTileTensor *biases, int strideRows, int strideCols) const#
Returns the result of convolution between this and filters, with specified strides.
Assumes all tensors are packed in SIMD fashion.
- Parameters:
filters – Convolution filters
biases – Biases to add (optional)
strideRows – Filter strides on rows
strideCols – Filter strides on cols
-
CTileTensor getSlice(DimInt dim, DimInt startIndex, DimInt sliceDepth = 1) const#
Returns a slice of the tensor in specific dimension.
Result has the same number of dimensions as the original tensor. For dim with tile size of 1, getSlice is supported for every valid startIndex and sliceDepth. For a non-interleaved dim with tile size > 1, getSlice is supported only for startIndex which is a multiple of the tile size. For interleaved dim with tile size > 1, getSlice is supported only for startIndex 0.
- Parameters:
dim – The dimension to slice along. Specifying negative value will count from the last dim backwards (-1 for the last dim, -2 for the previoud one etc.).
startIndex – The index to start slicing at along the dimension
sliceDepth – The depth/size of the slice along the dimension
- Throws:
invalid_argument – If the given dimension is greater or equal to the total number of dimensions in this TileTensor
invalid_argument – If startIndex + sliceDepth is greater than the original size of the given dimension.
invalid_argument – If the tile size of the given dimension is different than 1.
-
void setDimInterleaved(DimInt dim, bool isInterleaved)#
Turns interleave flag on or off for specific dim without changing the underlying tiling.
Can be used only if dim original size is 1.
- Parameters:
dim – Which dimension to set
isInterleaved – Whether this dimension is interleaved
- Throws:
invalid_argument – If dim doesn’t exists
invalid_argument – If dim original size > 1
-
void rotateAlongDim(int dim, int rot)#
Rotates this CTileTensor along the specified dimension (index (i+rot) % originalSize moves to i).
The elements that fall out of one end cycle back in the other end. If the external size of “dim” is not 1, then “dim” must be interleaved. If the external size of “dim” is 1, the rotation works and will have the same effect regardless of the interleaved flag being on or off. For the rotation to succeed, “dim” must be the first non-trivial” dimension, and it must not contain any unused slots.
- Parameters:
dim – The dimension to rotate along.
rot – The rotation offset.
- Throws:
invalid_argument – If the rotated dimension does not satisfy the above requirements.
-
void shiftAlongDim(int dim, int shift)#
Shifts this CTileTensor along the specified dimension (index i+shift moves to i).
The elements that fall out of one end do not cycle back in the other end. If the external size of “dim” is not 1, then “dim” must be interleaved. If the external size of “dim” is 1, the shift works and will have the same effect regardless of the interleaved flag being on or off. “shift” must be positive and smaller than the original size of “dim”. Following the shift, the original size of dim will be reduced by the given “shift” value, and the unused slots will be marked unkown.
- Parameters:
dim – The dimension to shift along.
shift – The shift offset.
- Throws:
invalid_argument – If the shifted dimension does not satisfy the above requirements.
invalid_argument – If “shift” is negative or greater than the original size of “dim”.
-
virtual double assertIntegrity(double epsilon = 1e-6) const override#
Validates the integrity of the tile tensor.
Used for internal checks only. Returns the maximal diff found. If uninitialized, returns 0
- Parameters:
epsilon – Tolerance for diffs.
- Throws:
runtime_error – if test fails
-
virtual void debugPrint(const std::string &title = "", Verbosity verbosity = VERBOSITY_REGULAR, std::ostream &out = std::cout) const override#
Prints the content of this object.
- Parameters:
title – Text to add to the print
verbosity – Verbosity level
out – Output stream
-
inline virtual int32_t getContextId() const override#
Returns the contextId of the HeContext this object was initialized with.
This contextId can be used, for example, to verify heContext match when loading a saved Saveable object.
-
virtual void sleep() override#
If Ptiles, if lazyMode is LAZY_ENCODING, clear all the tiles.
-
virtual void wakeup() override#
If Ptiles, encodes data if lazyMode is LAZY_ENCODING, and does nothing else.
-
void resizeOriginalDim(DimInt dim, DimInt newSize)#
Change the original size of a tensor along a dimension.
The external-size may change accordingly. If new CTiles need to be added to the tensor they are added as 0s.
- Parameters:
dim – The dimension whose size changes
newSize – The new original size.
Public Static Functions
-
static CTileTensor createSingleTile(const HeContext &he, const TTShape &shape, const CTile &tile)#
Creates a CTileTensor with one tile.
- Parameters:
he – The HeContext.
shape – The shape of the CTileTensor to create. Each dimension of this shape must be either incomplete, t_i/t_i or n_i?/t_i for n_i < t_i. If a dimension is incomplete, it will be replaced with t_i/t_i in the resulting CTileTensor.
tile – The only tile of the created CTileTesnor.
- Throws:
invalid_argument – If the given shape does not satisfy the requirement above.
-
static CTileTensor createFromCTileVector(const HeContext &he, const TTShape &shape, const std::vector<CTile> &tilesVec)#
Creates a CTileTensor from the given vector of CTiles.
“tilesVec” vector is expected to have a first-order orientation. The created CTileTensor will have the given shape, which is assumed to be complete (i.e. with all original sizes set), not to contain any duplicated dims and to have all unused slots unknown.
- Parameters:
he – The HeContext to initialize the created CTileTensor with.
shape – The shape of the resulting CTileTensor.
tilesVec – The vector of CTiles, in first-order orientation.
- Throws:
invalid_argument – If “shape” doesn’t satisfy the above assumptions.
-
static CTileTensor combineAlongDim(const std::vector<CTileTensor> &ctts, DimInt dim)#
Combines the given CTileTensors into one by composing them along the specified dimension.
All of the given CTileTensors must have the same shape and chain index. The dimension to combine along mustn’t be duplicated and it mustn’t have any unused slots. Combining along a non-trivial interleaved dimension (i.e. originalSize > 1) is not supported. The resulting CTileTensor has the same number of dimensions as the source CTileTensors. When combining along a trivial interleaved dimension, the combined dimension of the result will not be interleaved. The original size of the combined dimension is multiplied by the number of CTileTensors to combine. Other than that, all aspects of the shape of the result stay the same as the source CTileTensors.
- Parameters:
ctts – The CTileTensors to combine.
dim – The dimension to combine along
- Throws:
invalid_argument – If the conditions above don’t hold, if “ctts” is empty or if “dim” is negative or greater or equal to the order of the given CTileTensors.
-
static CTileTensor combine(const std::vector<std::vector<std::vector<CTileTensor>>> &cts)#
Combines the given CTileTensors into one CTileTensor.
All of the given CTileTensors must have the same shape and chain index. Let cts be of dimensions [d0,d1,d2]. The shape of the combined CTileTensor is given by adding the dimensions [d0/1,d1/2,d2/1] to the shape of the given CTileTensors. cts[i][j][k][…] will be copied into indexes [i,j,k,…] of the combined CTileTensor.
- Parameters:
cts – A 3D tensor of CTileTensors to combine.
- Throws:
invalid_Argument – If “cts” does not represent a 3D tensor (e.g. if cts[i].size() != cts[j].size() for some i,j).
invalid_argument – If one of cts, cts[0] or cts[0][0] is an empty vector.
invalid_arugment – If the given CTileTensors don’t have different shapes or different chain indexes.
Friends
- friend class circuit::Runner
-
typedef boost::numeric::ublas::tensor<CTile, PTileTensor::tensorFormat> ExternalTensorType#