Reduce

#include <popops/Reduce.hpp>

Define types of operations used in a reduce.

namespace popops

Common functions, such as elementwise and reductions.

map

Map an expression across tensors.

Elementwise Options

enableGenerateCodelet (true, false) [=true]

When true and the following conditions are met, poplar will generate a codelet to execute the map operation. Otherwise, it will sequence poplibs codelets to create the expression.
- All of the inputs are of the same size
- Inputs do not alias
- Multiple operations are being performed

mapInPlace

Update the input tensors with the result of map().

mapWithOutput

Write the result of map() to the given output tensor.

checkTypes

Check that the host compile-time type constType is compatible with the run-time IPU type elementType.

param elementType: The run-time IPU type.
param constant: Unused.

tparam constType: The host compile-time type.

throws std::runtime_error: If the types are not compatible.

varianceToInvStdDev

Convert variance to inverse standard deviation.

Each element in the output tensor is the result of 1 / sqrt(variance_value + epsilon), where variance_value is the corresponding element in variance.

Warning

If variance_value + epsilon is zero then the result will be invalid and this operation could generate a divide-by-zero floating-point exception (if enabled).

param graph: The graph to update.
param variance: A tensor of variance values.
param epsilon: A (typically small) scalar to add to the variance values, to avoid numerical issues (for example, divide by zero).
param prog: The sequence of programs to append this conversion operation to.
param debugContext: Optional debug information.

return: A tensor where each element is the inverse standard deviation.

invStdDevToVariance

Convert inverse standard deviation to variance.

Each element in the output tensor is the result of 1 / (invStdDev_value + epsilon)^2, where invStdDev_value is the corresponding element in invStdDev.

Warning

If invStdDev_value + epsilon is zero then the result will be invalid and this operation could generate a divide-by-zero floating-point exception (if enabled).

param graph: The graph to update.
param invStdDev: A tensor of inverse standard deviation values.
param epsilon: A (typically small) scalar to add to the variance values, to avoid numerical issues (for example, divide by zero).
param prog: The sequence of programs to append this conversion operation to.
param debugContext: Optional debug information.
param options: A list of flags to pass to the expression evaluator.

return: A tensor where each element is the variance.

add

Add each element in A to the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a + b, where a and b are the corresponding elements of A and B tensors respectively.

addInPlace

Update the tensor A with the result of add().

See add() for parameter descriptions.

addWithOutput

Write the result of add() to the given output tensor, out.

See add() for the remaining parameter descriptions.

param out: The tensor to write the results to.

sub

Subtract the elements of B from A and return the result in a new tensor.

param graph: The graph to update.
param A: The tensor of elements which will be subtracted from.
param B: The tensor of elements to subtract from A.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to a - b, where a and b are the corresponding elements of A and B tensors respectively.

subInPlace

Update the tensor A with the result of sub().

See sub() for parameter descriptions.

subWithOutput

Write the result of sub() to the given output tensor, out.

See sub() for the remaining parameter descriptions.

param out: The tensor to write the results to.

mul

Multiply each element in A by the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a * b, where a and b are the corresponding elements of A and B tensors respectively.

mulInPlace

Update the tensor A with the result of mul().

See mul() for parameter descriptions.

mulWithOutput

Write the result of mul() to the given output tensor, out.

See mul() for the remaining parameter descriptions.

param out: The tensor to write the results to.

div

Divide each element in A by the corresponding element in B.

param graph: The graph to update.
param A: The tensor of dividends.
param B: The tensor of divisors.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a / b, where a and b are the corresponding elements of A and B tensors respectively.

divInPlace

Update the tensor A with the result of div().

See div() for parameter descriptions.

divWithOutput

Write the result of div() to the given output tensor, out.

See div() for the remaining parameter descriptions.

param out: The tensor to write the results to.

pow

Compute each element in A to the power of the corresponding element in B.

param graph: The graph to update.
param A: The tensor of bases.
param B: The tensor of exponents.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to pow(a, b), where a and b are the corresponding elements of A and B tensors respectively.

powInPlace

Update the tensor A with the result of pow().

See pow() for parameter descriptions.

powWithOutput

Write the result of pow() to the given output tensor, out.

See pow() for the remaining parameter descriptions.

param out: The tensor to write the results to.

rem

Compute the remainder of each element in A divided by the corresponding element in B.

param graph: The graph to update.
param A: The tensor of dividends.
param B: The tensor of divisors.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to a % b, where a and b are the corresponding elements of A and B tensors respectively.

remInPlace

Update the tensor A with the result of rem().

See rem() for parameter descriptions.

remWithOutput

Write the result of rem() to the given output tensor, out.

See rem() for the remaining parameter descriptions.

param out: The tensor to write the results to.

bitwiseAnd

Compute the bitwise AND of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a & b, where a and bare the corresponding elements of A and B tensors respectively.

bitwiseAndInPlace

Update the tensor A with the result of bitwiseAnd().

See bitwiseAnd() for parameter descriptions.

bitwiseAndWithOutput

Write the result of bitwiseAnd() to the given output tensor, out.

See bitwiseAnd() for the remaining parameter descriptions.

param out: The tensor to write the results to.

bitwiseOr

Compute the bitwise OR of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a | b, where a and b are the corresponding elements of A and B tensors respectively.

bitwiseOrInPlace

Update the tensor A with the result of bitwiseOr().

See bitwiseOr() for parameter descriptions.

bitwiseOrWithOutput

Write the result of bitwiseOr() to the given output tensor, out.

See bitwiseOr() for the remaining parameter descriptions.

param out: The tensor to write the results to.

bitwiseXor

Compute the bitwise XOR of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a ^ b, where a and b are the corresponding elements of A and B tensors respectively.

bitwiseXorInPlace

Update the tensor A with the result of bitwiseXor().

See bitwiseXnor() for parameter descriptions.

bitwiseXorWithOutput

Write the result of bitwiseXor() to the given output tensor, out.

See bitwiseXor() for the remaining parameter descriptions.

param out: The tensor to write the results to.

bitwiseXnor

Compute the bitwise XNOR of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of !(a ^ b), where a and b are the corresponding elements of A and B tensors respectively.

bitwiseXnorInPlace

Update the tensor A with the result of bitwiseXnor().

See bitwiseXnor() for parameter descriptions.

bitwiseXnorWithOutput

Write the result of bitwiseXnor() to the given output tensor, out.

See bitwiseXnor() for the remaining parameter descriptions.

param out: The tensor to write the results to.

shiftLeft

Shift the elements of A left by the corresponding elements of B.

param graph: The graph to update.
param A: The tensor of elements which to left-shift.
param B: The tensor of elements that describe the amount to left-shift A by.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to a << b, where a and b are the corresponding elements of A and B tensors respectively.

shiftLeftInPlace

Update the tensor A with the result of shiftLeft().

See shiftLeft() for parameter descriptions.

shiftLeftWithOutput

Write the result of shiftLeft() to the given output tensor, out.

See shiftLeft() for the remaining parameter descriptions.

param out: The tensor to write the results to.

shiftRight

Shift the elements of A right by the corresponding elements of B.

param graph: The graph to update.
param A: The tensor of elements which to right-shift.
param B: The tensor of elements that describe the amount to right-shift by. A.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to a >> b (without sign extension), where a and b are the corresponding elements of A and B tensors respectively.

shiftRightInPlace

Update the tensor A with the result of shiftRight().

See shiftRight() for parameter descriptions.

shiftRightWithOutput

Write the result of shiftRight() to the given output tensor, out.

See shiftRight() for the remaining parameter descriptions.

param out: The tensor to write the results to.

shiftRightSignExtend

Shift the elements of A right with sign extension by the corresponding elements of B.

param graph: The graph to update.
param A: The tensor of elements which to right-shift.
param B: The tensor of elements that describe the amount to right-shift A by.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is equal to a >> b with sign extension, where a and b are the corresponding elements of A and B tensors respectively.

shiftRightSignExtendInPlace

Update the tensor A with the result of shiftRightSignExtend().

See shiftRightSignExtend() for parameter descriptions.

shiftRightSignExtendWithOutput

Write the result of shiftRightSignExtend() to the given output tensor, out.

See shiftRightSignExtend() for the remaining parameter descriptions.

param out: The tensor to write the results to.

logicalAnd

Compute the logical AND (&&) of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a && b, where a and b are the corresponding elements of A and B tensors respectively.

logicalAndInPlace

Update the tensor A with the result of logicalAnd().

See logicalAnd() for parameter descriptions.

logicalAndWithOutput

Write the result of logicalAnd() to the given output tensor, out.

See logicalAnd() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

logicalOr

Compute the logical OR (||) of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a || b, where a and b are the corresponding elements of A and B tensors respectively.

logicalOrInPlace

Update the tensor A with the result of logicalOr().

See logicalOr() for parameter descriptions.

logicalOrWithOutput

Write the result of logicalOr() to the given output tensor, out.

See logicalOr() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

eq

Check if each element in A is equal to the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a == b, where a and b are the corresponding elements of A and B tensors respectively.

eqInPlace

Update the tensor A with the result of eq().

See eq() for parameter descriptions.

eqWithOutput

Write the result of eq() to the given output tensor, out.

See eq() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

neq

Check if each element in A is not equal to the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a != b, where a and b are the corresponding elements of A and B tensors respectively.

neqInPlace

Update the tensor A with the result of neq().

See neq() for parameter descriptions.

neqWithOutput

Write the result of neq() to the given output tensor, out.

See neq() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

gteq

Check if each element in A is greater than or equal to the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a >= b, where a and b are the corresponding elements of A and B tensors respectively.

gteqInPlace

Update the tensor A with the result of gteq().

See gteq() for parameter descriptions.

gteqWithOutput

Write the result of gteq() to the given output tensor, out.

See gteq() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

gt

Check if each element in A is greater than the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of a > b, where a and b are the corresponding elements of A and B tensors respectively.

gtInPlace

Update the tensor A with the result of gt().

See gt() for parameter descriptions.

gtWithOutput

Write the result of gt() to the given output tensor, out.

See gt() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

lteq

Check if each element in A is less than or equal to the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a <= b, where a and b are the corresponding elements of A and B tensors respectively.

lteqInPlace

Update the A with the result of lteq().

See lteq() for parameter descriptions.

lteqWithOutput

Write the result of lteq() to the given output tensor, out.

See lteq() for the remaining parameter descriptions.

param out: The tensor to write the booleans to.

lt

Check if each element in A is less than the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of a < b, where a and b are the corresponding elements of A and B tensors respectively.

ltInPlace

Update the A with the result of lt().

See lt() for parameter descriptions.

ltWithOutput

Write the result of lt() to the given output tensor, out.

See lt() for the remaining parameter descriptions.

param out: The tensor to write the boolean results to.

max

Compute the maximum of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of max(a, b), where a and b are the corresponding elements of A and B tensors respectively.

maxInPlace

Update the tensor A with the result of max().

See max() for parameter descriptions.

maxWithOutput

Write the result of max() to the given output tensor, out.

See max() for the remaining parameter descriptions.

param out: The tensor to write the maximums to.

min

Compute the minimum of each element in A with the corresponding element in B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information.
param options: Element-wise options. See map().

return: A tensor where each element is the result of min(a, b), where a and b are the corresponding elements of A and B tensors respectively.

minInPlace

Update the tensor A with the result of min().

See min() for parameter descriptions.

minWithOutput

Write the result of min() to the given output tensor, out.

See min() for the remaining parameter descriptions.

param out: The tensor to write the minimums to.

atan2

Compute the element-wise arctangent of A / B.

param graph: The graph to update.
param A: A tensor of elements.
param B: A tensor of elements.
param prog: The sequence to extend with the execution of the expression evaluation.
param debugContext: Optional debug information
param options: Element-wise options. See map().

return: A tensor where each element is the result of arctan(a / b); a and b are the corresponding elements of A and B tensors respectively.

atan2InPlace

Update the tensor A with the result of atan2().

See atan2() for parameter descriptions.

atan2WithOutput

Write the result of atan2() to the given output tensor, out.

See atan2() for the remaining parameter descriptions.

param out: The tensor to write the result to.

invStdDevToVarianceInPlace

Update the invStdDev tensor with the result of invStdDevToVariance().

See invStdDevToVariance() for parameter descriptions.

invStdDevToVarianceWithOutput

Write the result of invStdDevToVariance() to the given output tensor, out.

See invStdDevToVariance() for the remaining parameter descriptions.

param out: The tensor to write the variance to.

varianceToInvStdDevInPlace

Update the variance tensor with the result of varianceToInvStdDev().

See varianceToInvStdDev() for parameter descriptions.

varianceToInvStdDevWithOutput

Write the result of varianceToInvStdDev() to the given output tensor, out.

See varianceToInvStdDev() for the remaining parameter descriptions.

param out: The tensor to write inverse standard deviation to.

Unnamed Group

poplar::Tensor reduce(poplar::Graph &graph, const poplar::Tensor &in, const poplar::Type &outType, const std::vector<std::size_t> &dims, ReduceParams params, std::vector<poplar::ComputeSet> &css, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Apply a reduction operation to a tensor.

Deprecated:: The reduce overloads that expect a vector of compute sets are deprecated. Please use the reduceMany() function instead.

These are alternate forms that add their vertices to a vector of compute sets instead of a poplar::program::Sequence. The caller is expected to add each compute set to a poplar::program::Sequence (in a poplar::program::Execute) themselves, like this:

Sequence seq;
std::vector<ComputeSet> css;
auto A = reduce(..., css);
auto B = reduce(..., css);
for (const auto &cs : css) {
  seq.add(Execute(cs));

This allows you to do multiple reductions in parallel. Note that the reductions are not aware of each other, so it may be more efficient to concatenate tensors and do a single reduction instead if they have the same shape, operation, and input and output types.

scale and update are only valid with the ADD , SQUARE_ADD or LOG_ADD operations. LOG_ADD performs all arithmetic consistent with the input and output being log probabilities. In other words, the update is another log add operation and the scale is a log multiply operation.

Internally, this creates a new variable for the output then calls reduceWithOutput(). The type of the output will be outType.

The options parameter accepts the following:

accumType.interTile (float, half)

The type to use for intermediate values between tiles. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.
accumType.inVertex (float, half)

The type to use for intermediate values within a vertex. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.

If either of the above options are not set then the intermediate type will default to either the input tensor element type or float if the input is of type half and the reduction operation benefits from higher precision (for example, add).

The input and output types that are supported depend on the operation:

ADD, SQUARE_ADD, MUL: float->float, half->half, int->int, float->half, half->float
LOG_ADD : float->float, half->half, float->half, half->float
MAX, MIN: float->float, half->half, int->int
LOGICAL_AND, LOGICAL_OR: bool->bool

Parameters

graph – The graph to add the operation to.
in – The tensor to be reduced.
outType – The output type of the reduce operation.
dims – The dimensions to reduce in.
prog – The program sequence to add the operation to.
debugContext – Optional debug information.

poplar::Tensor reduce(poplar::Graph &graph, const poplar::Tensor &in, const std::vector<std::size_t> &dims, ReduceParams params, std::vector<poplar::ComputeSet> &css, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

void reduceWithOutput(poplar::Graph &graph, const poplar::Tensor &in, const poplar::Tensor &out, const std::vector<std::size_t> &dims, ReduceParams params, std::vector<poplar::ComputeSet> &css, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Functions

poplar::Tensor reduce(poplar::Graph &graph, const poplar::Tensor &in, const poplar::Type &outType, const std::vector<std::size_t> &dims, ReduceParams params, poplar::program::Sequence &prog, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Apply a reduction operation to a tensor.

scale and update are only valid with the ADD , SQUARE_ADD or LOG_ADD operations. LOG_ADD performs all arithmetic consistent with the input and output being log probabilities. In other words, the update is another log add operation and the scale is a log multiply operation.

Internally, this creates a new variable for the output then calls reduceWithOutput(). The type of the output will be outType.

The options parameter accepts the following:

accumType.interTile (float, half)

The type to use for intermediate values between tiles. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.
accumType.inVertex (float, half)

The type to use for intermediate values within a vertex. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.

If either of the above options are not set then the intermediate type will default to either the input tensor element type or float if the input is of type half and the reduction operation benefits from higher precision (for example, add).

The input and output types that are supported depend on the operation:

ADD, SQUARE_ADD, MUL: float->float, half->half, int->int, float->half, half->float
LOG_ADD : float->float, half->half, float->half, half->float
MAX, MIN: float->float, half->half, int->int
LOGICAL_AND, LOGICAL_OR: bool->bool

Parameters

graph – The graph to add the operation to.
in – The tensor to be reduced.
outType – The output type of the reduce operation.
dims – The dimensions to reduce in.
prog – The program sequence to add the operation to.
debugContext – Optional debug information.

poplar::Tensor reduce(poplar::Graph &graph, const poplar::Tensor &in, const std::vector<std::size_t> &dims, ReduceParams params, poplar::program::Sequence &prog, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Apply a reduction operation to a tensor.

An alias for reduce(graph, in, in.elementType(), …)

scale and update are only valid with the ADD , SQUARE_ADD or LOG_ADD operations. LOG_ADD performs all arithmetic consistent with the input and output being log probabilities. In other words, the update is another log add operation and the scale is a log multiply operation.

Internally, this creates a new variable for the output then calls reduceWithOutput(). The type of the output will be outType.

The options parameter accepts the following:

accumType.interTile (float, half)

The type to use for intermediate values between tiles. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.
accumType.inVertex (float, half)

The type to use for intermediate values within a vertex. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.

If either of the above options are not set then the intermediate type will default to either the input tensor element type or float if the input is of type half and the reduction operation benefits from higher precision (for example, add).

The input and output types that are supported depend on the operation:

ADD, SQUARE_ADD, MUL: float->float, half->half, int->int, float->half, half->float
LOG_ADD : float->float, half->half, float->half, half->float
MAX, MIN: float->float, half->half, int->int
LOGICAL_AND, LOGICAL_OR: bool->bool

Parameters

graph – The graph to add the operation to.
in – The tensor to be reduced.
outType – The output type of the reduce operation.
dims – The dimensions to reduce in.
prog – The program sequence to add the operation to.
debugContext – Optional debug information.

void reduceWithOutput(poplar::Graph &graph, const poplar::Tensor &in, const poplar::Tensor &out, const std::vector<std::size_t> &dims, ReduceParams params, poplar::program::Sequence &prog, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Apply a reduction operation to a tensor.

This is similar to reduce() but allows you to specify the output. If the tile mapping of out is not complete it will be set. Otherwise it won’t be changed.

scale and update are only valid with the ADD , SQUARE_ADD or LOG_ADD operations. LOG_ADD performs all arithmetic consistent with the input and output being log probabilities. In other words, the update is another log add operation and the scale is a log multiply operation.

Internally, this creates a new variable for the output then calls reduceWithOutput(). The type of the output will be outType.

The options parameter accepts the following:

accumType.interTile (float, half)

The type to use for intermediate values between tiles. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.
accumType.inVertex (float, half)

The type to use for intermediate values within a vertex. If the type specified is smaller than the output type then the option is ignored and the output type is used instead.

If either of the above options are not set then the intermediate type will default to either the input tensor element type or float if the input is of type half and the reduction operation benefits from higher precision (for example, add).

The input and output types that are supported depend on the operation:

ADD, SQUARE_ADD, MUL: float->float, half->half, int->int, float->half, half->float
LOG_ADD : float->float, half->half, float->half, half->float
MAX, MIN: float->float, half->half, int->int
LOGICAL_AND, LOGICAL_OR: bool->bool

Parameters

graph – The graph to add the operation to.
in – The tensor to be reduced.
outType – The output type of the reduce operation.
dims – The dimensions to reduce in.
prog – The program sequence to add the operation to.
debugContext – Optional debug information.

void reduceMany(poplar::Graph &graph, const std::vector<SingleReduceOp> &reductions, std::vector<poplar::Tensor> &outputs, poplar::program::Sequence &prog, const poplar::DebugContext &debugContext = {}, const poplar::OptionFlags &options = {})

Perform many reductions (in parallel if possible).

Please see the documentation for reduce() for details of the common inputs.

Parameters

reductions – The inputs to each reduction to perform. The outType attribute controls the element type of the output tensor if outputs is empty, otherwise it is ignored. If outputs is empty and useOutType is false then the output element type will be set to the same element type as the corresponding in tensor.
outputs – The tensors to store the output of the reductions. This may be empty in which case reduceMany will create the tensors. If the tile mapping is not set or not complete it will be set completely by this function.

Throws

poputils::poplibs_error – If outputs is not empty then its size must exactly match the size of reductions else an exception will be thrown.
poputils::poplibs_error – If outputs is empty and any reduction has params.update set to true then an exception will be thrown. outputs is required to perform an update reduction.

struct ReduceParams

#include <Reduce.hpp>

Stores parameters for the reduce operation, as well as the basic operation being performed (for example, add or mul).

Public Functions

ReduceParams() = default

inline ReduceParams(popops::Operation op, bool update = false)

inline ReduceParams(popops::Operation op, bool update, poplar::Tensor scale)

Define the details of the reduce operation that will be performed by the reduce() and reduceWithOutput() functions.

Parameters

op – The reduce operation to use.
scale – Can (optionally) scale the output.
update – Specify that the output should be updated, where out += reduce(in) rather than out = reduce(in).

ReduceParams(popops::Operation op, float constantScale, bool update = false) = delete

Public Members

popops::Operation op

bool update

bool useScale

poplar::Tensor scale

struct SingleReduceOp

#include <Reduce.hpp>

The parameterisation of the inputs to a single reduction for the reduceMany() function.

Please see the documentation for reduce() for a description of the struct members.

Public Functions

inline SingleReduceOp(poplar::Tensor in, std::vector<std::size_t> dims, ReduceParams params, poplar::Type outType, std::string debugName = "")

inline SingleReduceOp(poplar::Tensor in, std::vector<std::size_t> dims, ReduceParams params, std::string debugName = "")

Public Members

poplar::Tensor in

std::vector<std::size_t> dims

ReduceParams params

bool useOutType

Note that if useOutType is false then the element type of in is used.

Also note that OutType is ignored if the outputs vector is not empty when calling reduceMany().

poplar::Type outType

std::string debugName