Nd4jStatus LegacyScalarOp::validateAndExecute(Context &block) {
auto x = INPUT_VARIABLE(0);
int offset = 0;
auto z = OUTPUT_VARIABLE(0);
int opNum = block.opNum() < 0 ? this->_opNum : block.opNum();
if (block.width() > 1) {
auto y = INPUT_VARIABLE(1);
y->printIndexedBuffer("scalar");
// FIXME
NativeOpExcutioner::execScalar(opNum, x->getBuffer(), x->getShapeInfo(), z->getBuffer(), z->getShapeInfo(), y->buffer(), y->shapeInfo(), block.getTArguments()->data());
} else if (block.getTArguments()->size() > 0) {
auto y = NDArrayFactory::create(x->dataType(), T_ARG(0), block.getWorkspace());
offset++;
// FIXME
NativeOpExcutioner::execScalar(opNum, x->getBuffer(), x->getShapeInfo(), z->getBuffer(), z->getShapeInfo(), y.buffer(), y.shapeInfo(), block.getTArguments()->data() + offset);
} else {
// FIXME
NativeOpExcutioner::execScalar(opNum, x->getBuffer(), x->getShapeInfo(), z->getBuffer(), z->getShapeInfo(), _scalar.buffer(), _scalar.shapeInfo(), block.getTArguments()->data());
}
STORE_RESULT(*z);
return Status::OK();
}
Nd4jStatus LegacyPairwiseTransformOp::validateAndExecute(Context &block) {
auto x = INPUT_VARIABLE(0);
auto y = INPUT_VARIABLE(1);
auto z = OUTPUT_VARIABLE(0);
if (!x->isSameShape(y)) {
std::string sx = ShapeUtils::shapeAsString(x);
std::string sy = ShapeUtils::shapeAsString(y);
REQUIRE_TRUE(x->isSameShape(y) || y->isScalar(), 0, "Node_%i: For Pairwise transforms shapes of both operands should be equal but got %s vs %s", block.getNodeId(), sx.c_str(), sy.c_str());
}
int opNum = block.opNum() < 0 ? this->_opNum : block.opNum();
NativeOpExcutioner::execPairwiseTransform(opNum, x->getBuffer(), x->getShapeInfo(), y->getBuffer(), y->getShapeInfo(), z->getBuffer(), z->getShapeInfo(), block.getTArguments()->data());
STORE_RESULT(*z);
return ND4J_STATUS_OK;
}
/**
* For all reductions rules are simple: either you return scalar, or you return reduced NDArray.
* It solely depends on input shape, and requested dimensions
*/
ShapeList *LegacyReduceBoolOp::calculateOutputShape(ShapeList *inputShape, nd4j::graph::Context &block) {
auto inShape = inputShape->at(0);
Nd4jLong *newShape;
bool allAxes = false;
auto keepDims = block.numB() > 0 ? B_ARG(0) : false;
auto newFormat = block.numB() > 1 ? B_ARG(1) : true;
auto axis = block.width() > 1 ? INPUT_VARIABLE(1)->asVectorT<int>() : *block.getAxis();
if (axis.size() == shape::rank(inShape))
allAxes = true;
// in this case we're building proper shape for reduction
auto array = new NDArray(nullptr, inShape, block.getWorkspace());
array->triggerAllocationFlag(false, false);
newShape = ShapeUtils::evalReduceShapeInfo(shape::order(inShape), axis, *array, keepDims, !newFormat, block.workspace());
ArrayOptions::setDataType(newShape, DataType::BOOL);
delete array;
return SHAPELIST(newShape);
}
Nd4jStatus LegacyReduceBoolOp::validateAndExecute(Context &block) {
auto x = INPUT_VARIABLE(0);
int opNum = block.opNum() < 0 ? this->_opNum : block.opNum();
nd4j_debug("Executing LegacyReduceFloatOp: [%i]\n", opNum);
auto axis = *block.getAxis();
bool allAxes = false;
if (block.width() == 1) {
auto z = OUTPUT_VARIABLE(0);
if (axis.size() == x->rankOf())
allAxes = true;
if ((axis.empty()) ||
(axis.size() == 1 && axis[0] == MAX_INT) || allAxes) {
// scalar
NativeOpExcutioner::execReduceBoolScalar(opNum, x->getBuffer(), x->getShapeInfo(), block.getTArguments()->data(), z->buffer(), z->shapeInfo());
} else {
// TAD
std::vector<int> dims(axis);
for (int e = 0; e < dims.size(); e++)
if (dims[e] < 0)
dims[e] += x->rankOf();
std::sort(dims.begin(), dims.end());
REQUIRE_TRUE(dims.size() > 0, 0, "Some dimensions required for reduction!");
shape::TAD tad;
tad.init(x->getShapeInfo(), dims.data(), dims.size());
tad.createTadOnlyShapeInfo();
tad.createOffsets();
NativeOpExcutioner::execReduceBool(opNum, x->getBuffer(), x->getShapeInfo(), block.getTArguments()->data(), z->getBuffer(), z->getShapeInfo(), dims.data(), (int) dims.size(), tad.tadOnlyShapeInfo, tad.tadOffsets);
}
STORE_RESULT(*z);
} else {
auto indices = INPUT_VARIABLE(1);
if (indices->lengthOf() == x->rankOf())
allAxes = true;
//indices->printIndexedBuffer("indices");
std::vector<int> axis(indices->lengthOf());
for (int e = 0; e < indices->lengthOf(); e++) {
// lol otherwise we segfault on macOS
int f = indices->e<int>(e);
axis[e] = f >= 0 ? f : f += x->rankOf();
}
if ((block.getIArguments()->size() == 1 && INT_ARG(0) == MAX_INT) || allAxes) {
auto z = OUTPUT_VARIABLE(0);
auto b = x->getBuffer();
auto s = x->shapeInfo();
auto e = block.numT() > 0 ? block.getTArguments()->data() : nullptr;
//x->printIndexedBuffer("x");
// scalar
NativeOpExcutioner::execReduceBoolScalar(opNum, b, s, e, z->buffer(), z->shapeInfo());
} else {
// TAD
if (indices->lengthOf() > 1)
std::sort(axis.begin(), axis.end());
REQUIRE_TRUE(axis.size() > 0, 0, "Some dimensions required for reduction!");
shape::TAD tad;
tad.init(x->getShapeInfo(), axis.data(), axis.size());
tad.createTadOnlyShapeInfo();
tad.createOffsets();
auto z = OUTPUT_VARIABLE(0);
NativeOpExcutioner::execReduceBool(opNum, x->getBuffer(), x->getShapeInfo(), block.getTArguments()->data(), z->getBuffer(), z->getShapeInfo(), axis.data(), (int) axis.size(), tad.tadOnlyShapeInfo, tad.tadOffsets);
}
}
return Status::OK();
}
template <typename T>
LegacyRandomOp<T>::LegacyRandomOp(int opNum) : LegacyOp<T>::LegacyOp(1, opNum) {
// just a no-op
}
template <typename T>
LegacyOp<T>* LegacyRandomOp<T>::clone() {
return new LegacyRandomOp(this->_opNum);
}
template <typename T>
Nd4jStatus LegacyRandomOp<T>::validateAndExecute(Context<T> &block) {
REQUIRE_TRUE(block.getRNG() != nullptr, 0, "RNG should be provided for LegacyRandomOp, but got NULL instead at node_%i", block.nodeId())
auto input = INPUT_VARIABLE(0);
int opNum = block.opNum() < 0 ? this->_opNum : block.opNum();
/*
(0, randomOps::UniformDistribution) ,\
(1, randomOps::DropOut) ,\
(2, randomOps::DropOutInverted) ,\
(3, randomOps::ProbablisticMerge) ,\
(4, randomOps::Linspace) ,\
(5, randomOps::Choice) ,\
(6, randomOps::GaussianDistribution) ,\
(7, randomOps::BernoulliDistribution) ,\
(8, randomOps::BinomialDistribution),\
(9, randomOps::BinomialDistributionEx),\
(10, randomOps::LogNormalDistribution) ,\
