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;
}
