/* ---------------------------------------------------------------------- * Project: CMSIS DSP Library * Title: arm_svm_linear_predict_f16.c * Description: SVM Linear Classifier * * $Date: 23 April 2021 * $Revision: V1.9.0 * * Target Processor: Cortex-M and Cortex-A cores * -------------------------------------------------------------------- */ /* * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved. * * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the License); you may * not use this file except in compliance with the License. * You may obtain a copy of the License at * * www.apache.org/licenses/LICENSE-2.0 * * 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. */ #include "dsp/svm_functions_f16.h" #if defined(ARM_FLOAT16_SUPPORTED) #include #include /** * @addtogroup linearsvm * @{ */ /** * @brief SVM linear prediction * @param[in] S Pointer to an instance of the linear SVM structure. * @param[in] in Pointer to input vector * @param[out] pResult Decision value * @return none. * */ #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE) #include "arm_helium_utils.h" void arm_svm_linear_predict_f16( const arm_svm_linear_instance_f16 *S, const float16_t * in, int32_t * pResult) { /* inlined Matrix x Vector function interleaved with dot prod */ uint32_t numRows = S->nbOfSupportVectors; uint32_t numCols = S->vectorDimension; const float16_t *pSupport = S->supportVectors; const float16_t *pSrcA = pSupport; const float16_t *pInA0; const float16_t *pInA1; uint32_t row; uint32_t blkCnt; /* loop counters */ const float16_t *pDualCoef = S->dualCoefficients; _Float16 sum = S->intercept; row = numRows; /* * compute 4 rows in parrallel */ while (row >= 4) { const float16_t *pInA2, *pInA3; float16_t const *pSrcA0Vec, *pSrcA1Vec, *pSrcA2Vec, *pSrcA3Vec, *pInVec; f16x8_t vecIn, acc0, acc1, acc2, acc3; float16_t const *pSrcVecPtr = in; /* * Initialize the pointers to 4 consecutive MatrixA rows */ pInA0 = pSrcA; pInA1 = pInA0 + numCols; pInA2 = pInA1 + numCols; pInA3 = pInA2 + numCols; /* * Initialize the vector pointer */ pInVec = pSrcVecPtr; /* * reset accumulators */ acc0 = vdupq_n_f16(0.0f); acc1 = vdupq_n_f16(0.0f); acc2 = vdupq_n_f16(0.0f); acc3 = vdupq_n_f16(0.0f); pSrcA0Vec = pInA0; pSrcA1Vec = pInA1; pSrcA2Vec = pInA2; pSrcA3Vec = pInA3; blkCnt = numCols >> 3; while (blkCnt > 0U) { f16x8_t vecA; vecIn = vld1q(pInVec); pInVec += 8; vecA = vld1q(pSrcA0Vec); pSrcA0Vec += 8; acc0 = vfmaq(acc0, vecIn, vecA); vecA = vld1q(pSrcA1Vec); pSrcA1Vec += 8; acc1 = vfmaq(acc1, vecIn, vecA); vecA = vld1q(pSrcA2Vec); pSrcA2Vec += 8; acc2 = vfmaq(acc2, vecIn, vecA); vecA = vld1q(pSrcA3Vec); pSrcA3Vec += 8; acc3 = vfmaq(acc3, vecIn, vecA); blkCnt--; } /* * tail * (will be merged thru tail predication) */ blkCnt = numCols & 7; if (blkCnt > 0U) { mve_pred16_t p0 = vctp16q(blkCnt); f16x8_t vecA; vecIn = vldrhq_z_f16(pInVec, p0); vecA = vldrhq_z_f16(pSrcA0Vec, p0); acc0 = vfmaq(acc0, vecIn, vecA); vecA = vldrhq_z_f16(pSrcA1Vec, p0); acc1 = vfmaq(acc1, vecIn, vecA); vecA = vldrhq_z_f16(pSrcA2Vec, p0); acc2 = vfmaq(acc2, vecIn, vecA); vecA = vldrhq_z_f16(pSrcA3Vec, p0); acc3 = vfmaq(acc3, vecIn, vecA); } /* * Sum the partial parts */ acc0 = vmulq_n_f16(acc0,*pDualCoef++); acc0 = vfmaq_n_f16(acc0,acc1,*pDualCoef++); acc0 = vfmaq_n_f16(acc0,acc2,*pDualCoef++); acc0 = vfmaq_n_f16(acc0,acc3,*pDualCoef++); sum += (_Float16)vecAddAcrossF16Mve(acc0); pSrcA += numCols * 4; /* * Decrement the row loop counter */ row -= 4; } /* * compute 2 rows in parallel */ if (row >= 2) { float16_t const *pSrcA0Vec, *pSrcA1Vec, *pInVec; f16x8_t vecIn, acc0, acc1; float16_t const *pSrcVecPtr = in; /* * Initialize the pointers to 2 consecutive MatrixA rows */ pInA0 = pSrcA; pInA1 = pInA0 + numCols; /* * Initialize the vector pointer */ pInVec = pSrcVecPtr; /* * reset accumulators */ acc0 = vdupq_n_f16(0.0f); acc1 = vdupq_n_f16(0.0f); pSrcA0Vec = pInA0; pSrcA1Vec = pInA1; blkCnt = numCols >> 3; while (blkCnt > 0U) { f16x8_t vecA; vecIn = vld1q(pInVec); pInVec += 8; vecA = vld1q(pSrcA0Vec); pSrcA0Vec += 8; acc0 = vfmaq(acc0, vecIn, vecA); vecA = vld1q(pSrcA1Vec); pSrcA1Vec += 8; acc1 = vfmaq(acc1, vecIn, vecA); blkCnt--; } /* * tail * (will be merged thru tail predication) */ blkCnt = numCols & 7; if (blkCnt > 0U) { mve_pred16_t p0 = vctp16q(blkCnt); f16x8_t vecA; vecIn = vldrhq_z_f16(pInVec, p0); vecA = vldrhq_z_f16(pSrcA0Vec, p0); acc0 = vfmaq(acc0, vecIn, vecA); vecA = vldrhq_z_f16(pSrcA1Vec, p0); acc1 = vfmaq(acc1, vecIn, vecA); } /* * Sum the partial parts */ acc0 = vmulq_n_f16(acc0,*pDualCoef++); acc0 = vfmaq_n_f16(acc0,acc1,*pDualCoef++); sum += (_Float16)vecAddAcrossF16Mve(acc0); pSrcA += numCols * 2; row -= 2; } if (row >= 1) { f16x8_t vecIn, acc0; float16_t const *pSrcA0Vec, *pInVec; float16_t const *pSrcVecPtr = in; /* * Initialize the pointers to last MatrixA row */ pInA0 = pSrcA; /* * Initialize the vector pointer */ pInVec = pSrcVecPtr; /* * reset accumulators */ acc0 = vdupq_n_f16(0.0f); pSrcA0Vec = pInA0; blkCnt = numCols >> 3; while (blkCnt > 0U) { f16x8_t vecA; vecIn = vld1q(pInVec); pInVec += 8; vecA = vld1q(pSrcA0Vec); pSrcA0Vec += 8; acc0 = vfmaq(acc0, vecIn, vecA); blkCnt--; } /* * tail * (will be merged thru tail predication) */ blkCnt = numCols & 7; if (blkCnt > 0U) { mve_pred16_t p0 = vctp16q(blkCnt); f16x8_t vecA; vecIn = vldrhq_z_f16(pInVec, p0); vecA = vldrhq_z_f16(pSrcA0Vec, p0); acc0 = vfmaq(acc0, vecIn, vecA); } /* * Sum the partial parts */ sum += (_Float16)*pDualCoef++ * (_Float16)vecAddAcrossF16Mve(acc0); } *pResult = S->classes[STEP(sum)]; } #else void arm_svm_linear_predict_f16( const arm_svm_linear_instance_f16 *S, const float16_t * in, int32_t * pResult) { _Float16 sum=S->intercept; _Float16 dot=0; uint32_t i,j; const float16_t *pSupport = S->supportVectors; for(i=0; i < S->nbOfSupportVectors; i++) { dot=0; for(j=0; j < S->vectorDimension; j++) { dot = dot + in[j]* *pSupport++; } sum += S->dualCoefficients[i] * dot; } *pResult=S->classes[STEP(sum)]; } #endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */ /** * @} end of linearsvm group */ #endif /* #if defined(ARM_FLOAT16_SUPPORTED) */