zea.ops.keras_ops

Auto-generated zea.Operation for all unary keras.ops and keras.ops.image functions.

They can be used in zea pipelines like any other zea.Operation, for example:

>>> from zea.ops.keras_ops import Squeeze

>>> op = Squeeze(axis=1)

This file is generated automatically. Do not edit manually. Generated with Keras 3.12.0

Classes

Abs(*args, **kwargs)	Operation wrapping keras.ops.abs.
Absolute(*args, **kwargs)	Operation wrapping keras.ops.absolute.
AffineTransform(*args, **kwargs)	Operation wrapping keras.ops.image.affine_transform.
All(*args, **kwargs)	Operation wrapping keras.ops.all.
Amax(*args, **kwargs)	Operation wrapping keras.ops.amax.
Amin(*args, **kwargs)	Operation wrapping keras.ops.amin.
Angle(*args, **kwargs)	Operation wrapping keras.ops.angle.
Any(*args, **kwargs)	Operation wrapping keras.ops.any.
Arccos(*args, **kwargs)	Operation wrapping keras.ops.arccos.
Arccosh(*args, **kwargs)	Operation wrapping keras.ops.arccosh.
Arcsin(*args, **kwargs)	Operation wrapping keras.ops.arcsin.
Arcsinh(*args, **kwargs)	Operation wrapping keras.ops.arcsinh.
Arctan(*args, **kwargs)	Operation wrapping keras.ops.arctan.
Arctanh(*args, **kwargs)	Operation wrapping keras.ops.arctanh.
Argmax(*args, **kwargs)	Operation wrapping keras.ops.argmax.
Argmin(*args, **kwargs)	Operation wrapping keras.ops.argmin.
Argpartition(*args, **kwargs)	Operation wrapping keras.ops.argpartition.
Argsort(*args, **kwargs)	Operation wrapping keras.ops.argsort.
Array(*args, **kwargs)	Operation wrapping keras.ops.array.
Average(*args, **kwargs)	Operation wrapping keras.ops.average.
Bartlett(*args, **kwargs)	Operation wrapping keras.ops.bartlett.
BatchNormalization(*args, **kwargs)	Operation wrapping keras.ops.batch_normalization.
Bincount(*args, **kwargs)	Operation wrapping keras.ops.bincount.
BitwiseAnd(*args, **kwargs)	Operation wrapping keras.ops.bitwise_and.
BitwiseInvert(*args, **kwargs)	Operation wrapping keras.ops.bitwise_invert.
BitwiseLeftShift(*args, **kwargs)	Operation wrapping keras.ops.bitwise_left_shift.
BitwiseNot(*args, **kwargs)	Operation wrapping keras.ops.bitwise_not.
BitwiseOr(*args, **kwargs)	Operation wrapping keras.ops.bitwise_or.
BitwiseRightShift(*args, **kwargs)	Operation wrapping keras.ops.bitwise_right_shift.
BitwiseXor(*args, **kwargs)	Operation wrapping keras.ops.bitwise_xor.
Blackman(*args, **kwargs)	Operation wrapping keras.ops.blackman.
BroadcastTo(*args, **kwargs)	Operation wrapping keras.ops.broadcast_to.
Cast(*args, **kwargs)	Operation wrapping keras.ops.cast.
Cbrt(*args, **kwargs)	Operation wrapping keras.ops.cbrt.
Ceil(*args, **kwargs)	Operation wrapping keras.ops.ceil.
Celu(*args, **kwargs)	Operation wrapping keras.ops.celu.
Cholesky(*args, **kwargs)	Operation wrapping keras.ops.cholesky.
CholeskyInverse(*args, **kwargs)	Operation wrapping keras.ops.cholesky_inverse.
Clip(*args, **kwargs)	Operation wrapping keras.ops.clip.
Conj(*args, **kwargs)	Operation wrapping keras.ops.conj.
Conjugate(*args, **kwargs)	Operation wrapping keras.ops.conjugate.
ConvertToNumpy(*args, **kwargs)	Operation wrapping keras.ops.convert_to_numpy.
ConvertToTensor(*args, **kwargs)	Operation wrapping keras.ops.convert_to_tensor.
Copy(*args, **kwargs)	Operation wrapping keras.ops.copy.
Corrcoef(*args, **kwargs)	Operation wrapping keras.ops.corrcoef.
Cos(*args, **kwargs)	Operation wrapping keras.ops.cos.
Cosh(*args, **kwargs)	Operation wrapping keras.ops.cosh.
CountNonzero(*args, **kwargs)	Operation wrapping keras.ops.count_nonzero.
CropImages(*args, **kwargs)	Operation wrapping keras.ops.image.crop_images.
Cumprod(*args, **kwargs)	Operation wrapping keras.ops.cumprod.
Cumsum(*args, **kwargs)	Operation wrapping keras.ops.cumsum.
Deg2rad(*args, **kwargs)	Operation wrapping keras.ops.deg2rad.
Det(*args, **kwargs)	Operation wrapping keras.ops.det.
Diag(*args, **kwargs)	Operation wrapping keras.ops.diag.
Diagflat(*args, **kwargs)	Operation wrapping keras.ops.diagflat.
Diagonal(*args, **kwargs)	Operation wrapping keras.ops.diagonal.
Digitize(*args, **kwargs)	Operation wrapping keras.ops.digitize.
Dtype(*args, **kwargs)	Operation wrapping keras.ops.dtype.
Eig(*args, **kwargs)	Operation wrapping keras.ops.eig.
Eigh(*args, **kwargs)	Operation wrapping keras.ops.eigh.
ElasticTransform(*args, **kwargs)	Operation wrapping keras.ops.image.elastic_transform.
Elu(*args, **kwargs)	Operation wrapping keras.ops.elu.
Erf(*args, **kwargs)	Operation wrapping keras.ops.erf.
Erfinv(*args, **kwargs)	Operation wrapping keras.ops.erfinv.
Exp(*args, **kwargs)	Operation wrapping keras.ops.exp.
Exp2(*args, **kwargs)	Operation wrapping keras.ops.exp2.
ExpandDims(*args, **kwargs)	Operation wrapping keras.ops.expand_dims.
Expm1(*args, **kwargs)	Operation wrapping keras.ops.expm1.
ExtractPatches(*args, **kwargs)	Operation wrapping keras.ops.image.extract_patches.
ExtractSequences(*args, **kwargs)	Operation wrapping keras.ops.extract_sequences.
Fft(*args, **kwargs)	Operation wrapping keras.ops.fft.
Fft2(*args, **kwargs)	Operation wrapping keras.ops.fft2.
Flip(*args, **kwargs)	Operation wrapping keras.ops.flip.
Floor(*args, **kwargs)	Operation wrapping keras.ops.floor.
FullLike(*args, **kwargs)	Operation wrapping keras.ops.full_like.
GaussianBlur(*args, **kwargs)	Operation wrapping keras.ops.image.gaussian_blur.
Gelu(*args, **kwargs)	Operation wrapping keras.ops.gelu.
GetItem(*args, **kwargs)	Operation wrapping keras.ops.get_item.
Glu(*args, **kwargs)	Operation wrapping keras.ops.glu.
Hamming(*args, **kwargs)	Operation wrapping keras.ops.hamming.
Hanning(*args, **kwargs)	Operation wrapping keras.ops.hanning.
HardShrink(*args, **kwargs)	Operation wrapping keras.ops.hard_shrink.
HardSigmoid(*args, **kwargs)	Operation wrapping keras.ops.hard_sigmoid.
HardSilu(*args, **kwargs)	Operation wrapping keras.ops.hard_silu.
HardSwish(*args, **kwargs)	Operation wrapping keras.ops.hard_swish.
HardTanh(*args, **kwargs)	Operation wrapping keras.ops.hard_tanh.
Histogram(*args, **kwargs)	Operation wrapping keras.ops.histogram.
HsvToRgb(*args, **kwargs)	Operation wrapping keras.ops.image.hsv_to_rgb.
Ifft2(*args, **kwargs)	Operation wrapping keras.ops.ifft2.
Imag(*args, **kwargs)	Operation wrapping keras.ops.imag.
Inv(*args, **kwargs)	Operation wrapping keras.ops.inv.
Irfft(*args, **kwargs)	Operation wrapping keras.ops.irfft.
IsTensor(*args, **kwargs)	Operation wrapping keras.ops.is_tensor.
Isfinite(*args, **kwargs)	Operation wrapping keras.ops.isfinite.
Isinf(*args, **kwargs)	Operation wrapping keras.ops.isinf.
Isnan(*args, **kwargs)	Operation wrapping keras.ops.isnan.
Isneginf(*args, **kwargs)	Operation wrapping keras.ops.isneginf.
Isposinf(*args, **kwargs)	Operation wrapping keras.ops.isposinf.
Isreal(*args, **kwargs)	Operation wrapping keras.ops.isreal.
Istft(*args, **kwargs)	Operation wrapping keras.ops.istft.
Kaiser(*args, **kwargs)	Operation wrapping keras.ops.kaiser.
LayerNormalization(*args, **kwargs)	Operation wrapping keras.ops.layer_normalization.
LeakyRelu(*args, **kwargs)	Operation wrapping keras.ops.leaky_relu.
LeftShift(*args, **kwargs)	Operation wrapping keras.ops.left_shift.
Log(*args, **kwargs)	Operation wrapping keras.ops.log.
Log10(*args, **kwargs)	Operation wrapping keras.ops.log10.
Log1p(*args, **kwargs)	Operation wrapping keras.ops.log1p.
Log2(*args, **kwargs)	Operation wrapping keras.ops.log2.
LogSigmoid(*args, **kwargs)	Operation wrapping keras.ops.log_sigmoid.
LogSoftmax(*args, **kwargs)	Operation wrapping keras.ops.log_softmax.
Logdet(*args, **kwargs)	Operation wrapping keras.ops.logdet.
LogicalNot(*args, **kwargs)	Operation wrapping keras.ops.logical_not.
Logsumexp(*args, **kwargs)	Operation wrapping keras.ops.logsumexp.
LuFactor(*args, **kwargs)	Operation wrapping keras.ops.lu_factor.
Max(*args, **kwargs)	Operation wrapping keras.ops.max.
Mean(*args, **kwargs)	Operation wrapping keras.ops.mean.
Median(*args, **kwargs)	Operation wrapping keras.ops.median.
Meshgrid(*args, **kwargs)	Operation wrapping keras.ops.meshgrid.
Min(*args, **kwargs)	Operation wrapping keras.ops.min.
Moments(*args, **kwargs)	Operation wrapping keras.ops.moments.
Moveaxis(*args, **kwargs)	Operation wrapping keras.ops.moveaxis.
NanToNum(*args, **kwargs)	Operation wrapping keras.ops.nan_to_num.
Ndim(*args, **kwargs)	Operation wrapping keras.ops.ndim.
Negative(*args, **kwargs)	Operation wrapping keras.ops.negative.
Nonzero(*args, **kwargs)	Operation wrapping keras.ops.nonzero.
Norm(*args, **kwargs)	Operation wrapping keras.ops.norm.
Normalize(*args, **kwargs)	Operation wrapping keras.ops.normalize.
OneHot(*args, **kwargs)	Operation wrapping keras.ops.one_hot.
OnesLike(*args, **kwargs)	Operation wrapping keras.ops.ones_like.
Pad(*args, **kwargs)	Operation wrapping keras.ops.pad.
PadImages(*args, **kwargs)	Operation wrapping keras.ops.image.pad_images.
PerspectiveTransform(*args, **kwargs)	Operation wrapping keras.ops.image.perspective_transform.
Prod(*args, **kwargs)	Operation wrapping keras.ops.prod.
Qr(*args, **kwargs)	Operation wrapping keras.ops.qr.
Quantile(*args, **kwargs)	Operation wrapping keras.ops.quantile.
Ravel(*args, **kwargs)	Operation wrapping keras.ops.ravel.
Real(*args, **kwargs)	Operation wrapping keras.ops.real.
Reciprocal(*args, **kwargs)	Operation wrapping keras.ops.reciprocal.
Relu(*args, **kwargs)	Operation wrapping keras.ops.relu.
Relu6(*args, **kwargs)	Operation wrapping keras.ops.relu6.
Repeat(*args, **kwargs)	Operation wrapping keras.ops.repeat.
Reshape(*args, **kwargs)	Operation wrapping keras.ops.reshape.
Resize(*args, **kwargs)	Operation wrapping keras.ops.image.resize.
Rfft(*args, **kwargs)	Operation wrapping keras.ops.rfft.
RgbToGrayscale(*args, **kwargs)	Operation wrapping keras.ops.image.rgb_to_grayscale.
RgbToHsv(*args, **kwargs)	Operation wrapping keras.ops.image.rgb_to_hsv.
RightShift(*args, **kwargs)	Operation wrapping keras.ops.right_shift.
RmsNormalization(*args, **kwargs)	Operation wrapping keras.ops.rms_normalization.
Roll(*args, **kwargs)	Operation wrapping keras.ops.roll.
Round(*args, **kwargs)	Operation wrapping keras.ops.round.
Rsqrt(*args, **kwargs)	Operation wrapping keras.ops.rsqrt.
SaturateCast(*args, **kwargs)	Operation wrapping keras.ops.saturate_cast.
ScaleAndTranslate(*args, **kwargs)	Operation wrapping keras.ops.image.scale_and_translate.
Selu(*args, **kwargs)	Operation wrapping keras.ops.selu.
Shape(*args, **kwargs)	Operation wrapping keras.ops.shape.
Sigmoid(*args, **kwargs)	Operation wrapping keras.ops.sigmoid.
Sign(*args, **kwargs)	Operation wrapping keras.ops.sign.
Signbit(*args, **kwargs)	Operation wrapping keras.ops.signbit.
Silu(*args, **kwargs)	Operation wrapping keras.ops.silu.
Sin(*args, **kwargs)	Operation wrapping keras.ops.sin.
Sinh(*args, **kwargs)	Operation wrapping keras.ops.sinh.
Size(*args, **kwargs)	Operation wrapping keras.ops.size.
Slogdet(*args, **kwargs)	Operation wrapping keras.ops.slogdet.
SoftShrink(*args, **kwargs)	Operation wrapping keras.ops.soft_shrink.
Softmax(*args, **kwargs)	Operation wrapping keras.ops.softmax.
Softplus(*args, **kwargs)	Operation wrapping keras.ops.softplus.
Softsign(*args, **kwargs)	Operation wrapping keras.ops.softsign.
Sort(*args, **kwargs)	Operation wrapping keras.ops.sort.
SparsePlus(*args, **kwargs)	Operation wrapping keras.ops.sparse_plus.
SparseSigmoid(*args, **kwargs)	Operation wrapping keras.ops.sparse_sigmoid.
Sparsemax(*args, **kwargs)	Operation wrapping keras.ops.sparsemax.
Split(*args, **kwargs)	Operation wrapping keras.ops.split.
Sqrt(*args, **kwargs)	Operation wrapping keras.ops.sqrt.
Square(*args, **kwargs)	Operation wrapping keras.ops.square.
Squareplus(*args, **kwargs)	Operation wrapping keras.ops.squareplus.
Squeeze(*args, **kwargs)	Operation wrapping keras.ops.squeeze.
Stack(*args, **kwargs)	Operation wrapping keras.ops.stack.
Std(*args, **kwargs)	Operation wrapping keras.ops.std.
Stft(*args, **kwargs)	Operation wrapping keras.ops.stft.
Sum(*args, **kwargs)	Operation wrapping keras.ops.sum.
Svd(*args, **kwargs)	Operation wrapping keras.ops.svd.
Swapaxes(*args, **kwargs)	Operation wrapping keras.ops.swapaxes.
Swish(*args, **kwargs)	Operation wrapping keras.ops.swish.
Take(*args, **kwargs)	Operation wrapping keras.ops.take.
TakeAlongAxis(*args, **kwargs)	Operation wrapping keras.ops.take_along_axis.
Tan(*args, **kwargs)	Operation wrapping keras.ops.tan.
Tanh(*args, **kwargs)	Operation wrapping keras.ops.tanh.
TanhShrink(*args, **kwargs)	Operation wrapping keras.ops.tanh_shrink.
Threshold(*args, **kwargs)	Operation wrapping keras.ops.threshold.
Tile(*args, **kwargs)	Operation wrapping keras.ops.tile.
TopK(*args, **kwargs)	Operation wrapping keras.ops.top_k.
Trace(*args, **kwargs)	Operation wrapping keras.ops.trace.
Transpose(*args, **kwargs)	Operation wrapping keras.ops.transpose.
Tril(*args, **kwargs)	Operation wrapping keras.ops.tril.
Triu(*args, **kwargs)	Operation wrapping keras.ops.triu.
Trunc(*args, **kwargs)	Operation wrapping keras.ops.trunc.
Unfold(*args, **kwargs)	Operation wrapping keras.ops.unfold.
Unstack(*args, **kwargs)	Operation wrapping keras.ops.unstack.
Var(*args, **kwargs)	Operation wrapping keras.ops.var.
View(*args, **kwargs)	Operation wrapping keras.ops.view.
ViewAsComplex(*args, **kwargs)	Operation wrapping keras.ops.view_as_complex.
ViewAsReal(*args, **kwargs)	Operation wrapping keras.ops.view_as_real.
ZerosLike(*args, **kwargs)	Operation wrapping keras.ops.zeros_like.

Exceptions

MissingKerasOps(class_name, func)

class zea.ops.keras_ops.Abs(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.abs.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Absolute(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.absolute.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.AffineTransform(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.affine_transform.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.All(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.all.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Amax(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.amax.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Amin(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.amin.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Angle(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.angle.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Any(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.any.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arccos(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arccos.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arccosh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arccosh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arcsin(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arcsin.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arcsinh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arcsinh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arctan(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arctan.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Arctanh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.arctanh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Argmax(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.argmax.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Argmin(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.argmin.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Argpartition(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.argpartition.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Argsort(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.argsort.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Array(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.array.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Average(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.average.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Bartlett(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bartlett.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BatchNormalization(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.batch_normalization.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Bincount(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bincount.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseAnd(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_and.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseInvert(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_invert.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseLeftShift(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_left_shift.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseNot(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_not.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseOr(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_or.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseRightShift(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_right_shift.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BitwiseXor(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.bitwise_xor.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Blackman(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.blackman.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.BroadcastTo(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.broadcast_to.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cast(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cast.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cbrt(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cbrt.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Ceil(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.ceil.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Celu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.celu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cholesky(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cholesky.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.CholeskyInverse(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cholesky_inverse.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Clip(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.clip.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Conj(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.conj.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Conjugate(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.conjugate.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ConvertToNumpy(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.convert_to_numpy.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ConvertToTensor(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.convert_to_tensor.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Copy(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.copy.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Corrcoef(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.corrcoef.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cos(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cos.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cosh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cosh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.CountNonzero(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.count_nonzero.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.CropImages(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.crop_images.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cumprod(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cumprod.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Cumsum(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.cumsum.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Deg2rad(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.deg2rad.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Det(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.det.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Diag(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.diag.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Diagflat(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.diagflat.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Diagonal(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.diagonal.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Digitize(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.digitize.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Dtype(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.dtype.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Eig(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.eig.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Eigh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.eigh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ElasticTransform(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.elastic_transform.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Elu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.elu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Erf(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.erf.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Erfinv(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.erfinv.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Exp(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.exp.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Exp2(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.exp2.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ExpandDims(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.expand_dims.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Expm1(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.expm1.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ExtractPatches(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.extract_patches.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ExtractSequences(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.extract_sequences.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Fft(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.fft.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Fft2(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.fft2.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Flip(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.flip.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Floor(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.floor.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.FullLike(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.full_like.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.GaussianBlur(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.gaussian_blur.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Gelu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.gelu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.GetItem(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.get_item.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Glu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.glu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Hamming(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hamming.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Hanning(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hanning.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HardShrink(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hard_shrink.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HardSigmoid(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hard_sigmoid.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HardSilu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hard_silu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HardSwish(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hard_swish.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HardTanh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.hard_tanh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Histogram(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.histogram.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.HsvToRgb(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.hsv_to_rgb.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Ifft2(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.ifft2.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Imag(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.imag.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Inv(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.inv.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Irfft(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.irfft.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.IsTensor(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.is_tensor.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isfinite(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isfinite.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isinf(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isinf.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isnan(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isnan.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isneginf(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isneginf.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isposinf(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isposinf.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Isreal(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.isreal.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Istft(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.istft.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Kaiser(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.kaiser.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LayerNormalization(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.layer_normalization.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LeakyRelu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.leaky_relu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LeftShift(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.left_shift.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Log(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Log10(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log10.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Log1p(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log1p.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Log2(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log2.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LogSigmoid(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log_sigmoid.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LogSoftmax(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.log_softmax.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Logdet(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.logdet.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LogicalNot(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.logical_not.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Logsumexp(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.logsumexp.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.LuFactor(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.lu_factor.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Max(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.max.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Mean(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.mean.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Median(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.median.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Meshgrid(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.meshgrid.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Min(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.min.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

exception zea.ops.keras_ops.MissingKerasOps(class_name, func)

Bases: ValueError

class zea.ops.keras_ops.Moments(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.moments.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Moveaxis(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.moveaxis.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.NanToNum(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.nan_to_num.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Ndim(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.ndim.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Negative(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.negative.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Nonzero(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.nonzero.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Norm(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.norm.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Normalize(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.normalize.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.OneHot(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.one_hot.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.OnesLike(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.ones_like.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Pad(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.pad.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.PadImages(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.pad_images.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.PerspectiveTransform(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.perspective_transform.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Prod(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.prod.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Qr(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.qr.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Quantile(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.quantile.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Ravel(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.ravel.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Real(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.real.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Reciprocal(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.reciprocal.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Relu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.relu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Relu6(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.relu6.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Repeat(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.repeat.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Reshape(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.reshape.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Resize(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.resize.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Rfft(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.rfft.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.RgbToGrayscale(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.rgb_to_grayscale.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.RgbToHsv(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.rgb_to_hsv.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.RightShift(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.right_shift.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.RmsNormalization(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.rms_normalization.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Roll(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.roll.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Round(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.round.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Rsqrt(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.rsqrt.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.SaturateCast(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.saturate_cast.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ScaleAndTranslate(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.image.scale_and_translate.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Selu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.selu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Shape(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.shape.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sigmoid(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sigmoid.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sign(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sign.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Signbit(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.signbit.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Silu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.silu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sin(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sin.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sinh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sinh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Size(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.size.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Slogdet(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.slogdet.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.SoftShrink(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.soft_shrink.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Softmax(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.softmax.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Softplus(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.softplus.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Softsign(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.softsign.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sort(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sort.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.SparsePlus(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sparse_plus.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.SparseSigmoid(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sparse_sigmoid.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sparsemax(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sparsemax.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Split(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.split.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sqrt(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sqrt.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Square(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.square.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Squareplus(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.squareplus.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Squeeze(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.squeeze.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Stack(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.stack.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Std(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.std.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Stft(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.stft.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Sum(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.sum.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Svd(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.svd.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Swapaxes(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.swapaxes.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Swish(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.swish.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Take(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.take.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.TakeAlongAxis(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.take_along_axis.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Tan(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.tan.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Tanh(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.tanh.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.TanhShrink(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.tanh_shrink.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Threshold(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.threshold.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Tile(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.tile.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.TopK(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.top_k.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Trace(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.trace.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Transpose(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.transpose.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Tril(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.tril.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Triu(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.triu.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Trunc(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.trunc.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Unfold(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.unfold.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Unstack(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.unstack.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.Var(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.var.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.View(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.view.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ViewAsComplex(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.view_as_complex.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ViewAsReal(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.view_as_real.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.

class zea.ops.keras_ops.ZerosLike(*args, **kwargs)

Bases: Lambda

Operation wrapping keras.ops.zeros_like.

Parameters:

• input_data_type (DataTypes) – The data type of the input data

• output_data_type (DataTypes) – The data type of the output data

• key – The key for the input data (operation will operate on this key) Defaults to “data”.

• output_key – The key for the output data (operation will output to this key) Defaults to the same as the input key. If you want to store intermediate results, you can set this to a different key. But make sure to update the input key of the next operation to match the output key of this operation.

• cache_inputs – A list of input keys to cache or True to cache all inputs

• cache_outputs – A list of output keys to cache or True to cache all outputs

• jit_compile – Whether to JIT compile the ‘call’ method for faster execution

• with_batch_dim – Whether operations should expect a batch dimension in the input

• jit_kwargs – Additional keyword arguments for the JIT compiler

• jittable – Whether the operation can be JIT compiled

• additional_output_keys – A list of additional output keys produced by the operation. These are used to track if all keys are available for downstream operations. If the operation has a conditional output, it is best to add all possible output keys here.