Buffer* ConvNode::run(Buffer* input) { if (_output != NULL) { delete _output; } Dimensions inputDims = input->_dims; const int inputChannels = inputDims[inputDims._length - 1]; const int valuesPerKernel = (inputChannels * _kernelWidth * _kernelWidth); if (_areKernelsTransposed) { Dimensions expectedKernelsDims(_kernelCount, valuesPerKernel); assert(expectedKernelsDims == _kernels->_dims); } else { Dimensions expectedKernelsDims(valuesPerKernel, _kernelCount); assert(expectedKernelsDims == _kernels->_dims); } Buffer* inputWithMargin; if (_marginSize == 0) { inputWithMargin = input; } else { inputWithMargin = matrix_insert_margin(input, _marginSize, _marginSize); } _output = matrix_correlate(inputWithMargin, _kernels, _kernelWidth, _kernelCount, _sampleStride, _areKernelsTransposed); _output->setName(_name); matrix_add_inplace(_output, _bias, 1.0); if (_marginSize != 0) { delete inputWithMargin; } return _output; }
void StrassenSingleProblem::merge(std::vector<Problem*> problems) { float *C11 = C; float *C21 = C + m/2; float *C12 = C + ldc*n/2; float *C22 = C + ldc*n/2 + m/2; float *Q[7]; int counter = 0; for(std::vector<Problem*>::iterator problemIterator = problems.begin(); problemIterator != problems.end(); problemIterator++) { StrassenSingleProblem *problem = (StrassenSingleProblem*)*problemIterator; Q[counter++] = (float*) problem->C; } matrix_add_inplace(m/2, n/2, C11, ldc, C12, ldc); matrix_add_inplace(m/2, n/2, C12, ldc, C21, ldc); matrix_add_inplace(m/2, n/2, C22, ldc, C12, ldc); matrix_add_inplace(m/2, n/2, C21, ldc, C22, ldc); matrix_subtract_inplace(m/2, n/2, Q[6], m/2, C21, ldc); matrix_add_inplace(m/2, n/2, Q[5], m/2, C12, ldc); matrix_add_inplace(m/2, n/2, Q[1], m/2, C11, ldc); for(std::vector<Problem*>::iterator problemIterator = problems.begin(); problemIterator != problems.end(); problemIterator++) { StrassenSingleProblem *problem = (StrassenSingleProblem*)*problemIterator; if (problem->lda == m/2) { free(problem->A); } if (problem->ldb == k/2) { free(problem->B); } if (problem->ldc == m/2) { free(problem->C); } } }
void jpcnn_classify_image(void* networkHandle, void* inputHandle, unsigned int flags, int layerOffset, float** outPredictionsValues, int* outPredictionsLength, char*** outPredictionsNames, int* outPredictionsNamesLength) { const bool doMultiSample = (flags & JPCNN_MULTISAMPLE); const bool doRandomSample = (flags & JPCNN_RANDOM_SAMPLE); const bool skipRescale = (flags & JPCNN_SKIP_RESCALE); Graph* graph = (Graph*)(networkHandle); Buffer* input = (Buffer*)(inputHandle); bool doFlip; int imageSize; bool isMeanChanneled; if (graph->_isHomebrewed) { imageSize = 224; doFlip = false; isMeanChanneled = true; } else { imageSize = 227; doFlip = true; isMeanChanneled = false; } Buffer* rescaledInput; if (skipRescale) { // substract mean rescaledInput = new Buffer(Dimensions(input->_dims[0], graph->_inputSize, graph->_inputSize, 1)); rescaledInput->copyDataFrom(input); matrix_add_inplace(rescaledInput, graph->_dataMean, -1.0f); } else { const int rescaledSize = graph->_inputSize; PrepareInput prepareInput(graph->_dataMean, !doMultiSample, doFlip, doRandomSample, imageSize, rescaledSize, isMeanChanneled); rescaledInput = prepareInput.run(input); } Buffer* predictions = graph->run(rescaledInput, layerOffset); *outPredictionsValues = predictions->_data; *outPredictionsLength = predictions->_dims.elementCount(); if (layerOffset == 0) { *outPredictionsNames = graph->_labelNames; *outPredictionsNamesLength = graph->_labelNamesLength; } else { *outPredictionsNames = NULL; *outPredictionsNamesLength = predictions->_dims.removeDimensions(1).elementCount(); } }
Buffer* PrepareInput::run(Buffer* input) { if (_output != NULL) { delete _output; } Dimensions rescaledDims(_rescaledSize, _rescaledSize, kOutputChannels); Buffer* rescaled = new Buffer(rescaledDims); rescaled->setName("rescaled"); input->setName("input"); rescale_image_to_fit(input, rescaled, _needsFlip); const int deltaX = (_rescaledSize - _imageSize); const int deltaY = (_rescaledSize - _imageSize); const int marginX = (deltaX / 2); const int marginY = (deltaY / 2); if (_useCenterOnly) { Dimensions outputDims(1, _imageSize, _imageSize, kOutputChannels); _output = new Buffer(outputDims); _output->setName("prepareInput_output"); int sourceX; int sourceY; if (_doRandomSample) { sourceX = (int)(rand() * (deltaX / (float)(RAND_MAX))); sourceY = (int)(rand() * (deltaY / (float)(RAND_MAX))); } else { sourceX = marginX; sourceY = marginY; } Buffer* blitDestination = buffer_view_at_top_index(_output, 0); crop_and_flip_image(blitDestination, rescaled, sourceX, sourceY, false); matrix_add_inplace(blitDestination, _dataMean, -1.0f); } else { Dimensions outputDims(10, _imageSize, _imageSize, kOutputChannels); _output = new Buffer(outputDims); _output->setName("prepareInput_output"); for (int flipPass = 0; flipPass < 2; flipPass += 1) { const bool doFlip = (flipPass == 1); Buffer* blitDestination = buffer_view_at_top_index(_output, (flipPass * 5)); crop_and_flip_image(blitDestination, rescaled, marginX, marginY, doFlip); for (int yIndex = 0; yIndex < 2; yIndex += 1) { for (int xIndex = 0; xIndex < 2; xIndex += 1) { const int viewIndex = ((flipPass * 5) + (yIndex * 2) + xIndex + 1); Buffer* blitDestination = buffer_view_at_top_index(_output, viewIndex); const int sourceX = (xIndex * deltaX); const int sourceY = (yIndex * deltaY); crop_and_flip_image(blitDestination, rescaled, sourceX, sourceY, doFlip); } } } } delete rescaled; return _output; }