Function WriteToNumpyFile

include/armnn/Numpy.hpp:328–405

    // Please see write_header() in the above file for more details.
    template<typename T>
    inline void WriteToNumpyFile(const std::string& outputTensorFileName,
                                 const T* const array,
                                 const unsigned int numElements,
                                 armnn::DataType dataType,
                                 const armnn::TensorShape& shape)
    {
        std::ofstream out(outputTensorFileName, std::ofstream::binary);

        // write header
        {
            // Setup string of tensor shape in format (x0, x1, x2, ..)
            std::string shapeStr = "(";
            for (uint32_t i = 0; i < shape.GetNumDimensions()-1; i++)
            {
                shapeStr = shapeStr + std::to_string(shape[i]) + ", ";
            }
            shapeStr = shapeStr + std::to_string(shape[shape.GetNumDimensions()-1]) + ")";

            int i = 1;
            std::string endianChar = (*(reinterpret_cast<char *>(&i))) ? "<" : ">";
            std::string dataTypeStr = getNumpyDescr(dataType);
            std::string fortranOrder = "False";
            std::string headerStr = "{'descr': '" + endianChar + dataTypeStr +
                                    "', 'fortran_order': " + fortranOrder +
                                    ", 'shape': " + shapeStr + ", }";

            armnnNumpy::HeaderInfo headerInfo;

            // Header is composed of:
            //     - 6 byte magic string
            //     - 2 byte major and minor version
            //     - 2 byte (v1.0) / 4 byte (v2.0) little-endian unsigned int
            //     - headerStr.length() bytes
            //     - 1 byte for newline termination (\n)
            size_t length = headerInfo.m_MagicStringLength + 2 + 2 + headerStr.length() + 1;
            uint8_t major_version = 1;

            // for numpy major version 2, add extra 2 bytes for little-endian int (total 4 bytes)
            if (length >= 255 * 255)
            {
                length += 2;
                major_version = 2;
            }

            // Pad with spaces so header length is modulo 16 bytes.
            size_t padding_length = 16 - length % 16;
            std::string padding(padding_length, ' ');

            // write magic string
            out.write(headerInfo.m_MagicString, headerInfo.m_MagicStringLength);
            out.put(static_cast<char>(major_version));
            out.put(0); // minor version

            // write header length
            if (major_version == 1)
            {
                auto header_len = static_cast<uint16_t>(headerStr.length() + padding.length() + 1);