wehub-resource-sync
478 lines
19 KiB
C++
478 lines
19 KiB
C++
/* ******************************************************************************
|
|
*
|
|
*
|
|
* This program and the accompanying materials are made available under the
|
|
* terms of the Apache License, Version 2.0 which is available at
|
|
* https://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* See the NOTICE file distributed with this work for additional
|
|
* information regarding copyright ownership.
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
******************************************************************************/
|
|
|
|
//
|
|
// @author Yurii Shyrma (iuriish@yahoo.com), created on 23.11.2017
|
|
//
|
|
|
|
#include <system/op_boilerplate.h>
|
|
#if NOT_EXCLUDED(OP_huber_loss)
|
|
|
|
#include <ops/declarable/CustomOperations.h>
|
|
|
|
namespace sd {
|
|
namespace ops {
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
CUSTOM_OP_IMPL(huber_loss, 3, 1, false, 1, 1) {
|
|
auto predictions = INPUT_VARIABLE(0);
|
|
auto weights = INPUT_VARIABLE(1);
|
|
auto labels = INPUT_VARIABLE(2);
|
|
auto output = OUTPUT_VARIABLE(0);
|
|
|
|
int reductionMode =
|
|
INT_ARG(0); // 0 - "none"; 1 - "weighted_sum"; 2 - "weighted_mean"; 3 - "weighted_sum_by_nonzero_weights"
|
|
// FIXME: double?
|
|
double delta = T_ARG(0);
|
|
|
|
// input validation
|
|
REQUIRE_TRUE(
|
|
labels->isSameShape(predictions), 0,
|
|
"HUBER_LOSS OP: labels and predictions arrays must have the same shapes, but got %s and %s correspondingly !",
|
|
ShapeUtils::shapeAsString(labels).c_str(), ShapeUtils::shapeAsString(predictions).c_str());
|
|
// weights array can be single scalar or has the same rank as labels, and must be broadcastable to labels
|
|
REQUIRE_TRUE(weights->isScalar() || weights->rankOf() == labels->rankOf(), 0,
|
|
"HUBER_LOSS OP: weights array should be scalar or have the same rank as labels array, but got %i and %i "
|
|
"correspondingly!",
|
|
weights->rankOf(), labels->rankOf());
|
|
// check whether broadcast operation is possible for weights array
|
|
REQUIRE_TRUE(weights->isScalar() || ShapeUtils::areShapesBroadcastable(*weights, *labels), 0,
|
|
"HUBER_LOSS OP: shapes of weights and labels arrays should be broadcastable, but got weights = %s and "
|
|
"labels = %s instead!",
|
|
ShapeUtils::shapeAsString(weights).c_str(), ShapeUtils::shapeAsString(labels).c_str());
|
|
// only 4 possible reduction modes exist
|
|
REQUIRE_TRUE(
|
|
reductionMode == 0 || reductionMode == 1 || reductionMode == 2 || reductionMode == 3, 0,
|
|
"HUBER_LOSS OP: reduction mode value is not acceptable, possible values are 0, 1, 2, 3, but got %i instead!",
|
|
reductionMode);
|
|
|
|
// perform weights broadcasting/tile to predictions if needed
|
|
auto weightsBroad = weights;
|
|
if (!weights->isScalar() && !weights->isSameShape(predictions))
|
|
weightsBroad = new NDArray(weights->tileToShape(predictions->shapeInfo()));
|
|
|
|
NDArray* error = (*predictions) - (*labels);
|
|
error->applyTransform(transform::Abs, error);
|
|
NDArray quadratic(error->shapeInfo(), block.getWorkspace());
|
|
error->applyScalar(scalar::MinPairwise, delta, &quadratic);
|
|
|
|
NDArray* quadraticSquared = quadratic * quadratic;
|
|
NDArray* scaledQuadratic = (*quadraticSquared) * 0.5f;
|
|
delete quadraticSquared;
|
|
|
|
NDArray* errorMinusQuadratic = (*error) - quadratic;
|
|
NDArray* linearTerm = (*errorMinusQuadratic) * delta;
|
|
delete errorMinusQuadratic;
|
|
|
|
NDArray* E = (*scaledQuadratic) + (*linearTerm);
|
|
delete scaledQuadratic;
|
|
delete linearTerm;
|
|
|
|
// multiply E on weights
|
|
NDArray* EWeighted = (*E) * (*weightsBroad);
|
|
delete E;
|
|
|
|
switch (reductionMode) {
|
|
case 0: { // 0 - "none", un-reduced weighted losses with the same shape as labels.
|
|
output->assign(EWeighted);
|
|
break;
|
|
}
|
|
case 1: { // 1 - "weighted_sum", output is scalar and equal to sum of all elements of E array
|
|
auto* sumResult = EWeighted->reduceNumber(reduce::Sum);
|
|
output->assign(sumResult);
|
|
delete sumResult;
|
|
break;
|
|
}
|
|
case 2: { // 2 - "weighted_mean", output is scalar and equal to sum of all elements of E array divided by sum of
|
|
// all elements of weightsBroad array
|
|
NDArray* sum;
|
|
if (weights->isScalar()) {
|
|
sum = (*weights) * EWeighted->lengthOf();
|
|
} else {
|
|
sum = weightsBroad->reduceNumber(reduce::Sum);
|
|
}
|
|
|
|
if (sum->e<double>(0) == 0.) {
|
|
*output = 0.;
|
|
} else {
|
|
auto* sumE = EWeighted->reduceNumber(reduce::Sum);
|
|
auto* result = (*sumE) / (*sum);
|
|
output->assign(result);
|
|
delete result;
|
|
delete sumE;
|
|
}
|
|
delete sum;
|
|
break;
|
|
}
|
|
case 3: { // 3 - "weighted_sum_by_nonzero_weights", output is scalar and equal to scalar sum of all elements of E
|
|
// array divided by number of non-zero weights
|
|
LongType numOfNonZeroWeights = 0;
|
|
if (weights->isScalar()) {
|
|
if (weights->e<double>(0) != 0.) numOfNonZeroWeights = EWeighted->lengthOf();
|
|
} else {
|
|
auto* countResult = weightsBroad->reduceNumber(reduce::CountNonZero);
|
|
numOfNonZeroWeights = countResult->e<LongType>(0);
|
|
delete countResult;
|
|
}
|
|
|
|
if (numOfNonZeroWeights == 0) {
|
|
(*output) = 0.;
|
|
} else {
|
|
auto* sumE = EWeighted->reduceNumber(reduce::Sum);
|
|
auto* result = (*sumE) / double(numOfNonZeroWeights);
|
|
output->assign(result);
|
|
delete result;
|
|
delete sumE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete EWeighted;
|
|
delete error;
|
|
if (weightsBroad != weights) delete weightsBroad;
|
|
|
|
return Status::OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
DECLARE_TYPES(huber_loss) {
|
|
getOpDescriptor()->setAllowedInputTypes(ANY)->setAllowedOutputTypes({ALL_FLOATS});
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
DECLARE_SHAPE_FN(huber_loss) {
|
|
auto predictionsShapeInfo = inputShape->at(0);
|
|
auto weightsShapeInfo = inputShape->at(1);
|
|
auto labelsShapeInfo = inputShape->at(2);
|
|
|
|
// labels and predictions must have the same shapes
|
|
REQUIRE_TRUE(
|
|
shape::shapeEquals(labelsShapeInfo, predictionsShapeInfo), 0,
|
|
"HUBER_LOSS OP: labels and predictions arrays must have the same shapes, but got %s and %s correspondingly !",
|
|
ShapeUtils::shapeAsString(labelsShapeInfo).c_str(), ShapeUtils::shapeAsString(predictionsShapeInfo).c_str());
|
|
// weights array can be single scalar or has the same rank as labels, and must be broadcastable to labels
|
|
REQUIRE_TRUE(shape::isScalar(weightsShapeInfo) || shape::rank(weightsShapeInfo) == shape::rank(labelsShapeInfo), 0,
|
|
"HUBER_LOSS OP: weights array should be scalar or have the same rank as labels array, but got %i and %i "
|
|
"correspondingly!",
|
|
shape::rank(weightsShapeInfo), shape::rank(labelsShapeInfo));
|
|
// check whether broadcast operation is possible for weights array
|
|
REQUIRE_TRUE(
|
|
shape::isScalar(weightsShapeInfo) || ShapeUtils::areShapesBroadcastable(weightsShapeInfo, labelsShapeInfo), 0,
|
|
"HUBER_LOSS OP: shapes of weights and labels arrays should be broadcastable, but got weights = %s and labels = "
|
|
"%s instead!",
|
|
ShapeUtils::shapeAsString(weightsShapeInfo).c_str(), ShapeUtils::shapeAsString(labelsShapeInfo).c_str());
|
|
|
|
DataType outType = DataTypeUtils::pickFloatingType(ArrayOptions::dataType(predictionsShapeInfo));
|
|
LongType * outShapeInfo = nullptr;
|
|
|
|
if (INT_ARG(0) != 0) // in this case output is scalar
|
|
outShapeInfo = ConstantShapeHelper::getInstance().scalarShapeInfo(outType);
|
|
else { // in this case output has the same shape as labels and predictions
|
|
outShapeInfo = ConstantShapeHelper::getInstance().bufferForShapeInfo(outType, shape::order(labelsShapeInfo),
|
|
shape::rank(labelsShapeInfo),
|
|
shape::shapeOf(labelsShapeInfo))->primary();
|
|
}
|
|
return SHAPELIST(outShapeInfo);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
CUSTOM_OP_IMPL(huber_loss_grad, 3, 3, false, 1, 1) {
|
|
auto predictions = INPUT_VARIABLE(0);
|
|
auto weights = INPUT_VARIABLE(1);
|
|
auto labels = INPUT_VARIABLE(2);
|
|
|
|
auto dLdp = OUTPUT_VARIABLE(0); // dL/dpredictions
|
|
auto dLdw = OUTPUT_VARIABLE(1); // dL/dweights
|
|
auto dLdl = OUTPUT_VARIABLE(2); // dL/dlabels
|
|
|
|
auto delta = T_ARG(0);
|
|
|
|
int reductionMode =
|
|
INT_ARG(0); // 0 - "none"; 1 - "weighted_sum"; 2 - "weighted_mean"; 3 - "weighted_sum_by_nonzero_weights"
|
|
// take into account Alex's proposition to treat "none" the same as "weighted_sum" mode when calculating gradients
|
|
if (reductionMode == 0) reductionMode = 1;
|
|
|
|
// inputs validation
|
|
REQUIRE_TRUE(labels->isSameShape(predictions), 0,
|
|
"HUBER_LOSS_GRAD OP: labels and predictions arrays must have the same shapes, but got %s and %s "
|
|
"correspondingly !",
|
|
ShapeUtils::shapeAsString(labels).c_str(), ShapeUtils::shapeAsString(predictions).c_str());
|
|
// weights array can be single scalar or has the same rank as labels, and must be broadcastable to labels
|
|
REQUIRE_TRUE(weights->isScalar() || weights->rankOf() == labels->rankOf(), 0,
|
|
"HUBER_LOSS_GRAD OP: weights array should be scalar or have the same rank as labels array, but got %i "
|
|
"and %i correspondingly!",
|
|
weights->rankOf(), labels->rankOf());
|
|
// check whether broadcast operation is possible for weights array
|
|
REQUIRE_TRUE(weights->isScalar() || ShapeUtils::areShapesBroadcastable(*weights, *labels), 0,
|
|
"HUBER_LOSS_GRAD OP: shapes of weights and labels arrays should be broadcastable, but got weights = %s "
|
|
"and labels = %s instead!",
|
|
ShapeUtils::shapeAsString(weights).c_str(), ShapeUtils::shapeAsString(labels).c_str());
|
|
// only 4 possible reduction modes exist
|
|
REQUIRE_TRUE(
|
|
reductionMode == 0 || reductionMode == 1 || reductionMode == 2 || reductionMode == 3, 0,
|
|
"HUBER_LOSS_GRAD OP: reduction mode value is not acceptable, possible values are 0, 1, 2, 3, but got %i instead!",
|
|
reductionMode);
|
|
|
|
// perform weights broadcasting/tile to labels if needed
|
|
auto weightsBroad = weights;
|
|
if (!weights->isScalar() && !weights->isSameShape(predictions))
|
|
weightsBroad = new NDArray(weights->tileToShape(predictions->shapeInfo()));
|
|
|
|
NDArray* diff = (*predictions) - (*labels);
|
|
NDArray absDiff(*diff);
|
|
absDiff.applyTransform(transform::Abs, &absDiff);
|
|
NDArray quadratic(absDiff);
|
|
absDiff.applyScalar(scalar::MinPairwise, delta, &quadratic);
|
|
|
|
NDArray* quadraticSquared = quadratic * quadratic;
|
|
NDArray* scaledQuadratic = (*quadraticSquared) * 0.5f;
|
|
delete quadraticSquared;
|
|
|
|
NDArray* absDiffMinusQuadratic = absDiff - quadratic;
|
|
NDArray* linearTerm = (*absDiffMinusQuadratic) * delta;
|
|
delete absDiffMinusQuadratic;
|
|
|
|
NDArray* E = (*scaledQuadratic) + (*linearTerm);
|
|
delete scaledQuadratic;
|
|
delete linearTerm;
|
|
|
|
NDArray lteMask(diff->shapeInfo(), BOOL, true, block.launchContext());
|
|
absDiff.applyScalar(scalar::LessThanOrEqual, delta, <eMask);
|
|
|
|
NDArray gtMask(diff->shapeInfo(), BOOL, true, block.launchContext());
|
|
absDiff.applyScalar(scalar::GreaterThan, delta, >Mask);
|
|
|
|
NDArray signDiff(*diff);
|
|
diff->applyTransform(transform::Sign, &signDiff);
|
|
|
|
auto gtMaskFloat = gtMask.cast(diff->dataType());
|
|
auto lteMaskFloat = lteMask.cast(diff->dataType());
|
|
|
|
// For dLdp
|
|
NDArray* lteDiff = (*lteMaskFloat) * (*diff);
|
|
NDArray* gtSignScaled = (*gtMaskFloat) * delta;
|
|
NDArray* gtTerm = (*gtSignScaled) * signDiff;
|
|
delete gtSignScaled;
|
|
NDArray* dLdpTemp = (*lteDiff) + (*gtTerm);
|
|
delete lteDiff;
|
|
delete gtTerm;
|
|
dLdp->assign(dLdpTemp);
|
|
delete dLdpTemp;
|
|
|
|
// For dLdl
|
|
NDArray negLteMaskFloat = -(*lteMaskFloat);
|
|
NDArray* negLteDiff = negLteMaskFloat * (*diff);
|
|
NDArray* negGtSignScaled = (*gtMaskFloat) * delta;
|
|
NDArray* negGtTerm = (*negGtSignScaled) * signDiff;
|
|
delete negGtSignScaled;
|
|
NDArray negGtTermNeg = -(*negGtTerm);
|
|
delete negGtTerm;
|
|
NDArray* dLdlTemp = (*negLteDiff) + negGtTermNeg;
|
|
delete negLteDiff;
|
|
dLdl->assign(dLdlTemp);
|
|
delete dLdlTemp;
|
|
|
|
switch (reductionMode) {
|
|
case 1: { // 1 - "none" and "weighted_sum", output is scalar and equal to sum of all elements of E array
|
|
|
|
NDArray* dLdpWeighted = (*dLdp) * (*weightsBroad);
|
|
dLdp->assign(dLdpWeighted);
|
|
delete dLdpWeighted;
|
|
|
|
NDArray* dLdlWeighted = (*dLdl) * (*weightsBroad);
|
|
dLdl->assign(dLdlWeighted);
|
|
delete dLdlWeighted;
|
|
|
|
if (weights->isScalar()) {
|
|
auto* sumE = E->reduceNumber(reduce::Sum);
|
|
dLdw->assign(sumE);
|
|
delete sumE;
|
|
} else if (weights != weightsBroad) {
|
|
std::vector<LongType> axesToReduceAlong =
|
|
ShapeUtils::evalBroadcastBackwardAxis(weights->shapeInfo(), weightsBroad->shapeInfo());
|
|
E->reduceAlongDimension(reduce::Sum, dLdw, &axesToReduceAlong, true);
|
|
} else
|
|
dLdw->assign(E);
|
|
break;
|
|
}
|
|
case 2: { // 2 - "weighted_mean", output is scalar and equal to sum of all elements of E array divided by sum of
|
|
// all elements of weightsBroad array
|
|
|
|
NDArray* sum;
|
|
if (weights->isScalar()) {
|
|
sum = (*weights) * E->lengthOf();
|
|
} else {
|
|
sum = weightsBroad->reduceNumber(reduce::Sum);
|
|
}
|
|
|
|
if (sum->e<double>(0) == 0.) {
|
|
*dLdp = 0.;
|
|
*dLdl = 0.;
|
|
*dLdw = 0.;
|
|
} else {
|
|
NDArray* weightsDivSum = (*weightsBroad) / (*sum);
|
|
NDArray* dLdpResult = (*dLdp) * (*weightsDivSum);
|
|
dLdp->assign(dLdpResult);
|
|
delete dLdpResult;
|
|
|
|
NDArray* dLdlResult = (*dLdl) * (*weightsDivSum);
|
|
dLdl->assign(dLdlResult);
|
|
delete dLdlResult;
|
|
delete weightsDivSum;
|
|
|
|
if (weights->isScalar()) {
|
|
*dLdw = 0.;
|
|
} else if (weights != weightsBroad) {
|
|
std::vector<LongType> axesToReduceAlong =
|
|
ShapeUtils::evalBroadcastBackwardAxis(weights->shapeInfo(), weightsBroad->shapeInfo());
|
|
NDArray* EWeighted = (*E) * (*weightsBroad);
|
|
NDArray* EWeightedSum = EWeighted->reduceNumber(reduce::Sum);
|
|
delete EWeighted;
|
|
NDArray* ESum = (*E) * (*sum);
|
|
NDArray* numerator = (*ESum) - (*EWeightedSum);
|
|
delete ESum;
|
|
delete EWeightedSum;
|
|
NDArray* sumSquared = (*sum) * (*sum);
|
|
NDArray* gradTemp = (*numerator) / (*sumSquared);
|
|
delete numerator;
|
|
delete sumSquared;
|
|
gradTemp->reduceAlongDimension(reduce::Sum, dLdw, &axesToReduceAlong, true);
|
|
delete gradTemp;
|
|
} else {
|
|
NDArray* EWeighted = (*E) * (*weightsBroad);
|
|
NDArray* EWeightedSum = EWeighted->reduceNumber(reduce::Sum);
|
|
delete EWeighted;
|
|
NDArray* ESum = (*E) * (*sum);
|
|
NDArray* numerator = (*ESum) - (*EWeightedSum);
|
|
delete ESum;
|
|
delete EWeightedSum;
|
|
NDArray* sumSquared = (*sum) * (*sum);
|
|
NDArray* gradTemp = (*numerator) / (*sumSquared);
|
|
delete numerator;
|
|
delete sumSquared;
|
|
dLdw->assign(gradTemp);
|
|
delete gradTemp;
|
|
}
|
|
}
|
|
delete sum;
|
|
break;
|
|
}
|
|
case 3: { // 3 - "weighted_sum_by_nonzero_weights", output is scalar and equal to scalar sum of all elements of E
|
|
// array divided by number of non-zero weights
|
|
|
|
LongType numOfNonZeroWeights = 0;
|
|
if (weights->isScalar()) {
|
|
if (weights->e<double>(0) != 0.) numOfNonZeroWeights = E->lengthOf();
|
|
} else {
|
|
auto* countResult = weightsBroad->reduceNumber(reduce::CountNonZero);
|
|
numOfNonZeroWeights = countResult->e<LongType>(0);
|
|
delete countResult;
|
|
}
|
|
|
|
if (numOfNonZeroWeights == 0) {
|
|
*dLdp = 0.;
|
|
*dLdl = 0.;
|
|
*dLdw = 0.;
|
|
} else {
|
|
auto numOfNonZeroWeightsScalar =
|
|
NDArrayFactory::create(dLdw->dataType(), numOfNonZeroWeights, block.launchContext());
|
|
|
|
if (weights->isScalar()) {
|
|
auto* sumE = E->reduceNumber(reduce::Sum);
|
|
auto* result = (*sumE) / double(numOfNonZeroWeights);
|
|
dLdw->assign(result);
|
|
delete result;
|
|
delete sumE;
|
|
} else if (weights != weightsBroad) {
|
|
std::vector<LongType> axesToReduceAlong =
|
|
ShapeUtils::evalBroadcastBackwardAxis(weights->shapeInfo(), weightsBroad->shapeInfo());
|
|
E->reduceAlongDimension(reduce::Sum, dLdw, &axesToReduceAlong, true);
|
|
NDArray* dLdwResult = (*dLdw) / (*numOfNonZeroWeightsScalar);
|
|
dLdw->assign(dLdwResult);
|
|
delete dLdwResult;
|
|
} else {
|
|
auto* result = (*E) / (*numOfNonZeroWeightsScalar);
|
|
dLdw->assign(result);
|
|
delete result;
|
|
}
|
|
|
|
NDArray* temp = (*weightsBroad) / (*numOfNonZeroWeightsScalar);
|
|
NDArray* dLdpResult = (*dLdp) * (*temp);
|
|
dLdp->assign(dLdpResult);
|
|
delete dLdpResult;
|
|
|
|
NDArray* dLdlResult = (*dLdl) * (*temp);
|
|
dLdl->assign(dLdlResult);
|
|
delete dLdlResult;
|
|
delete temp;
|
|
|
|
delete numOfNonZeroWeightsScalar;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete E;
|
|
delete diff;
|
|
if (weightsBroad != weights) delete weightsBroad;
|
|
|
|
return Status::OK;
|
|
}
|
|
|
|
DECLARE_TYPES(huber_loss_grad) {
|
|
getOpDescriptor()->setAllowedInputTypes(ANY)->setAllowedOutputTypes({ALL_FLOATS});
|
|
}
|
|
|
|
DECLARE_SHAPE_FN(huber_loss_grad) {
|
|
auto predictionsShapeInfo = inputShape->at(0);
|
|
auto weightsShapeInfo = inputShape->at(1);
|
|
auto labelsShapeInfo = inputShape->at(2);
|
|
|
|
// labels and predictions must have the same shapes
|
|
REQUIRE_TRUE(shape::shapeEquals(labelsShapeInfo, predictionsShapeInfo), 0,
|
|
"HUBER_LOSS_GRAD OP: labels and predictions arrays must have the same shapes, but got %s and %s "
|
|
"correspondingly !",
|
|
ShapeUtils::shapeAsString(labelsShapeInfo).c_str(),
|
|
ShapeUtils::shapeAsString(predictionsShapeInfo).c_str());
|
|
// weights array can be single scalar or has the same rank as labels, and must be broadcastable to labels
|
|
REQUIRE_TRUE(shape::isScalar(weightsShapeInfo) || shape::rank(weightsShapeInfo) == shape::rank(labelsShapeInfo), 0,
|
|
"HUBER_LOSS_GRAD OP: weights array should be scalar or have the same rank as labels array, but got %i "
|
|
"and %i correspondingly!",
|
|
shape::rank(weightsShapeInfo), shape::rank(labelsShapeInfo));
|
|
// check whether broadcast operation is possible for weights array
|
|
REQUIRE_TRUE(
|
|
shape::isScalar(weightsShapeInfo) || ShapeUtils::areShapesBroadcastable(weightsShapeInfo, labelsShapeInfo), 0,
|
|
"HUBER_LOSS_GRAD OP: shapes of weights and labels arrays should be broadcastable, but got weights = %s and "
|
|
"labels = %s instead!",
|
|
ShapeUtils::shapeAsString(weightsShapeInfo).c_str(), ShapeUtils::shapeAsString(labelsShapeInfo).c_str());
|
|
|
|
DataType outType = DataTypeUtils::pickFloatingType(ArrayOptions::dataType(predictionsShapeInfo));
|
|
|
|
auto dLdpShapeInfo = ShapeBuilders::copyShapeInfoAndType(predictionsShapeInfo, outType, false, block.getWorkspace());
|
|
auto dLdwShapeInfo = ShapeBuilders::copyShapeInfoAndType(weightsShapeInfo, outType, false, block.getWorkspace());
|
|
auto dLdlShapeInfo = ShapeBuilders::copyShapeInfoAndType(labelsShapeInfo, outType, false, block.getWorkspace());
|
|
|
|
return SHAPELIST(dLdpShapeInfo, dLdwShapeInfo, dLdlShapeInfo);
|
|
}
|
|
|
|
} // namespace ops
|
|
} // namespace sd
|
|
|
|
#endif
|