Validation.h File Reference

#include "OperationType.h"
#include "Model.h"
#include "Request.h"
#include "NeuralNetworks.h"

Go to the source code of this file.

Functions
int	validateOperationType (const OperationType &)
int	validateOperandType (const ANeuralNetworksOperandType &type, const char *tag, bool allowPartial)
int	validateOperandList (uint32_t count, const uint32_t *list, uint32_t operandCount, const char *tag)
bool	validateModel (const Model &model)
bool	validateRequest (const Request &request, const Model &model)

Function Documentation

validateModel()

bool validateModel

(

const Model &

model

)

Definition at line 181 of file Validation.cpp.

{
  const size_t operandCount = model.operands.size();
  return (validOperands(model.operands, model.operandValues) &&
          validOperations(model.operations, operandCount) &&
          validOperandIndexes(model.inputIndexes, operandCount) &&
          validOperandIndexes(model.outputIndexes, operandCount));
}

Referenced by ModelBuilder::finish().

validateOperandList()

int validateOperandList	(	uint32_t	count,
		const uint32_t *	list,
		uint32_t	operandCount,
		const char *	tag
	)

Definition at line 81 of file Validation.cpp.

{
  for (uint32_t i = 0; i < count; i++)
  {
    if (list[i] >= operandCount)
    {
      LOG(ERROR) << tag << " invalid operand index at " << i << " = " << list[i]
                 << ", operandCount " << operandCount;
      return ANEURALNETWORKS_BAD_DATA;
    }
  }
  return ANEURALNETWORKS_NO_ERROR;
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_NO_ERROR, and LOG.

Referenced by ModelBuilder::addOperation(), and ModelBuilder::identifyInputsAndOutputs().

validateOperandType()

int validateOperandType	(	const ANeuralNetworksOperandType &	type,
		const char *	tag,
		bool	allowPartial
	)

Definition at line 33 of file Validation.cpp.

{
  if (!allowPartial)
  {
    for (uint32_t i = 0; i < type.dimensionCount; i++)
    {
      if (type.dimensions[i] == 0)
      {
        LOG(ERROR) << tag << " OperandType invalid dimensions[" << i
                   << "] = " << type.dimensions[i];
        return ANEURALNETWORKS_BAD_DATA;
      }
    }
  }
  if (!validCode(kNumberOfDataTypes, type.type))
  {
    LOG(ERROR) << tag << " OperandType invalid type " << type.type;
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (type.type == ANEURALNETWORKS_TENSOR_QUANT8_ASYMM)
  {
    if (type.zeroPoint < 0 || type.zeroPoint > 255)
    {
      LOG(ERROR) << tag << " OperandType invalid zeroPoint " << type.zeroPoint;
      return ANEURALNETWORKS_BAD_DATA;
    }
    if (type.scale < 0.f)
    {
      LOG(ERROR) << tag << " OperandType invalid scale " << type.scale;
      return ANEURALNETWORKS_BAD_DATA;
    }
  }
 
  // TODO-NNRT : add 'type.type == ANEURALNETWORKS_OEM_SCALAR' later.
  //             OEM operaters are not supported now.
  if (type.type == ANEURALNETWORKS_FLOAT32 || type.type == ANEURALNETWORKS_INT32 ||
      type.type == ANEURALNETWORKS_UINT32)
  {
    if (type.dimensionCount != 0 || type.dimensions != nullptr)
    {
      LOG(ERROR) << tag << " Invalid dimensions for scalar type";
      return ANEURALNETWORKS_BAD_DATA;
    }
  }
 
  return ANEURALNETWORKS_NO_ERROR;
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_FLOAT32, ANEURALNETWORKS_INT32, ANEURALNETWORKS_NO_ERROR, ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, ANEURALNETWORKS_UINT32, kNumberOfDataTypes, and LOG.

Referenced by ModelBuilder::addOperand(), ExecutionBuilder::setInput(), and ExecutionBuilder::setOutput().

validateOperationType()

int validateOperationType

(

const OperationType &

type

)

Definition at line 27 of file Validation.cpp.

{
  return validCode(kNumberOfOperationTypes, static_cast<uint32_t>(type));
}

References kNumberOfOperationTypes.

Referenced by ModelBuilder::addOperation().

validateRequest()

bool validateRequest	(	const Request &	request,
		const Model &	model
	)

Definition at line 254 of file Validation.cpp.

{
  //const size_t poolCount = request.pools.size();
  const size_t poolCount = 0;
  return (validRequestArguments(request.inputs, model.inputIndexes, model.operands, poolCount,
                                "input") &&
          validRequestArguments(request.outputs, model.outputIndexes, model.operands, poolCount,
                                "output"));
}

References Request::inputs, Request::outputs, and validRequestArguments().