int main(int argc, const char** argv) { CV_TRACE_FUNCTION(); CV_TRACE_ARG(argc); CV_TRACE_ARG_VALUE(argv0, "argv0", argv[0]); CV_TRACE_ARG_VALUE(argv1, "argv1", argv[1]); cv::CommandLineParser parser(argc, argv, "{ help h usage ? | | show this help message }" "{ verbose v | | show build configuration log }" ); if (parser.has("help")) { parser.printMessage(); } else if (parser.has("verbose")) { std::cout << cv::getBuildInformation().c_str() << std::endl; } else { std::cout << CV_VERSION << std::endl; } return 0; }
void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); Layer::forward_fallback(inputs_arr, outputs_arr, internals_arr); }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); for (size_t i = 0; i < inputs.size(); i++) { Mat srcBlob = *inputs[i]; MatShape inputShape = shape(srcBlob), outShape = shape(outputs[i]); float *dstData = outputs[0].ptr<float>(); const float *srcData = srcBlob.ptr<float>(); int channels = inputShape[1], height = inputShape[2], width = inputShape[3]; int out_c = channels / (reorgStride*reorgStride); for (int k = 0; k < channels; ++k) { for (int j = 0; j < height; ++j) { for (int i = 0; i < width; ++i) { int out_index = i + width*(j + height*k); int c2 = k % out_c; int offset = k / out_c; int w2 = i*reorgStride + offset % reorgStride; int h2 = j*reorgStride + offset / reorgStride; int in_index = w2 + width*reorgStride*(h2 + height*reorgStride*c2); dstData[out_index] = srcData[in_index]; } } } } }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); CV_Assert(inputs.size() == 1 && outputs.size() == 1); CV_Assert(inputs[0]->total() == outputs[0].total()); const Mat& inp0 = *inputs[0]; Mat& buffer = internals[0]; size_t num = inp0.size[0]; size_t channels = inp0.size[1]; size_t channelSize = inp0.total() / (num * channels); for (size_t n = 0; n < num; ++n) { Mat src = Mat(channels, channelSize, CV_32F, (void*)inp0.ptr<float>(n)); Mat dst = Mat(channels, channelSize, CV_32F, (void*)outputs[0].ptr<float>(n)); cv::pow(abs(src), pnorm, buffer); if (acrossSpatial) { // add eps to avoid overflow float absSum = sum(buffer)[0] + epsilon; float norm = pow(absSum, 1.0f / pnorm); multiply(src, 1.0f / norm, dst); } else { Mat norm; reduce(buffer, norm, 0, REDUCE_SUM); norm += epsilon; // compute inverted norm to call multiply instead divide cv::pow(norm, -1.0f / pnorm, norm); repeat(norm, channels, 1, buffer); multiply(src, buffer, dst); } if (!blobs.empty()) { // scale the output Mat scale = blobs[0]; if (scale.total() == 1) { // _scale: 1 x 1 dst *= scale.at<float>(0, 0); } else { // _scale: _channels x 1 CV_Assert(scale.total() == channels); repeat(scale, 1, dst.cols, buffer); multiply(dst, buffer, dst); } } } }
void forward(std::vector<Mat *> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); Mat &input = *inputs[0]; Mat &output = outputs[0]; input(&crop_ranges[0]).copyTo(output); }
void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); CV_OCL_RUN((preferableTarget == DNN_TARGET_OPENCL) && OCL_PERFORMANCE_CHECK(ocl::Device::getDefault().isIntel()), forward_ocl(inputs_arr, outputs_arr, internals_arr)) Layer::forward_fallback(inputs_arr, outputs_arr, internals_arr); }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); for (size_t i = 0; i < inputs.size(); i++) { Mat srcBlob = *inputs[i]; if (outputs[i].data != srcBlob.data) srcBlob.reshape(1, shape(outputs[i])).copyTo(outputs[i]); } }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); if (paddingType == "constant") { outputs[0].setTo(paddingValue); inputs[0]->copyTo(outputs[0](dstRanges)); } else if (paddingType == "reflect") { CV_Assert(inputs.size() == 1); CV_Assert(outputs.size() == 1); CV_Assert(inputs[0]->dims == 4); CV_Assert(outputs[0].dims == 4); if (inputs[0]->size[0] != outputs[0].size[0] || inputs[0]->size[1] != outputs[0].size[1]) CV_Error(Error::StsNotImplemented, "Only spatial reflection padding is supported."); const int inpHeight = inputs[0]->size[2]; const int inpWidth = inputs[0]->size[3]; const int outHeight = outputs[0].size[2]; const int outWidth = outputs[0].size[3]; const int padTop = dstRanges[2].start; const int padBottom = outHeight - dstRanges[2].end; const int padLeft = dstRanges[3].start; const int padRight = outWidth - dstRanges[3].end; CV_Assert(padTop < inpHeight, padBottom < inpHeight, padLeft < inpWidth, padRight < inpWidth); for (size_t n = 0; n < inputs[0]->size[0]; ++n) { for (size_t ch = 0; ch < inputs[0]->size[1]; ++ch) { copyMakeBorder(getPlane(*inputs[0], n, ch), getPlane(outputs[0], n, ch), padTop, padBottom, padLeft, padRight, BORDER_REFLECT_101); } } } else CV_Error(Error::StsNotImplemented, "Unknown padding type: " + paddingType); }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); if (outHeight == inputs[0]->size[2] && outWidth == inputs[0]->size[3]) return; Mat& inp = *inputs[0]; Mat& out = outputs[0]; for (size_t n = 0; n < inputs[0]->size[0]; ++n) { for (size_t ch = 0; ch < inputs[0]->size[1]; ++ch) { resize(getPlane(inp, n, ch), getPlane(out, n, ch), Size(outWidth, outHeight), 0, 0, INTER_NEAREST); } } }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); for (size_t i = 0; i < inputs.size(); i++) { Mat srcBlob = *inputs[i]; MatShape inputShape = shape(srcBlob), outShape = shape(outputs[i]); if (performReordering) { float *dstData = internals[i].ptr<float>(); const float *srcData = srcBlob.ptr<float>(); int num = inputShape[0], channels = inputShape[1], height = inputShape[2], width = inputShape[3]; int total = num*channels*height*width; for(int i_n = 0; i_n < num; i_n++) { for(int i_c = 0; i_c < channels; i_c++) { for(int i_h = 0; i_h < height; i_h++) { for(int i_w = 0; i_w < width; i_w++) { int src_i = channels*height*width*i_n + height*width*i_c + width*i_h + i_w; int dst_i = channels*height*width*i_n + i_c + channels*width*i_h + channels*i_w; CV_Assert(dst_i < total); CV_Assert(src_i < total); dstData[dst_i] = srcData[src_i]; } } } } internals[i].copyTo(outputs[i]); } else { if (outputs[i].data != srcBlob.data) srcBlob.reshape(1, outShape).copyTo(outputs[i]); } } }
virtual void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); CV_Assert(inputs.size() > 0); CV_Assert(blobs.size() > 0); if(inputs[0]->dims == blobs[0].dims) { for (size_t ii = 0; ii < outputs.size(); ii++) { Mat &inpBlob = *inputs[ii]; Mat &outBlob = outputs[ii]; outBlob = inpBlob + blobs[0]; } } else { Mat biasOnesMat = internals[0]; biasOnesMat.setTo(1); for (size_t ii = 0; ii < outputs.size(); ii++) { Mat &inpBlob = *inputs[ii]; Mat &outBlob = outputs[ii]; inpBlob.copyTo(outBlob); for (int n = 0; n < inpBlob.size[0]; n++) { Mat dstMat(inpBlob.size[1], inpBlob.size[2] * inpBlob.size[3], outBlob.type(), outBlob.ptr(n)); gemm(blobs[0], biasOnesMat, 1, dstMat, 1, dstMat); //TODO: gemv } } } }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); checkInputs(inputs); Mat& buffer = internals[0], sumChannelMultiplier = internals[1], sumSpatialMultiplier = internals[2]; sumChannelMultiplier.setTo(1.0); sumSpatialMultiplier.setTo(1.0); const Mat& inp0 = *inputs[0]; size_t num = inp0.size[0]; size_t channels = inp0.size[1]; size_t channelSize = inp0.size[2] * inp0.size[3]; Mat zeroBuffer(channels, channelSize, CV_32F, Scalar(0)); Mat absDiff; Mat scale = blobs[0]; for (size_t j = 0; j < inputs.size(); j++) { for (size_t n = 0; n < num; ++n) { Mat src = Mat(channels, channelSize, CV_32F, inputs[j]->ptr<float>(n)); Mat dst = Mat(channels, channelSize, CV_32F, outputs[j].ptr<float>(n)); buffer = src.mul(src); if (_across_spatial) { absdiff(buffer, zeroBuffer, absDiff); // add eps to avoid overflow double absSum = sum(absDiff)[0] + _eps; float norm = sqrt(absSum); dst = src / norm; } else { Mat norm(channelSize, 1, buffer.type()); // 1 x channelSize // (_channels x channelSize)T * _channels x 1 -> channelSize x 1 gemm(buffer, sumChannelMultiplier, 1, norm, 0, norm, GEMM_1_T); // compute norm pow(norm, 0.5f, norm); // scale the layer // _channels x 1 * (channelSize x 1)T -> _channels x channelSize gemm(sumChannelMultiplier, norm, 1, buffer, 0, buffer, GEMM_2_T); dst = src / buffer; } // scale the output if (_channel_shared) { // _scale: 1 x 1 dst *= scale.at<float>(0, 0); } else { // _scale: _channels x 1 // _channels x 1 * 1 x channelSize -> _channels x channelSize gemm(scale, sumSpatialMultiplier, 1, buffer, 0, buffer); dst = dst.mul(buffer); } } } }
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); CV_Assert(inputs.size() >= 1); int const cell_size = classes + coords + 1; const float* biasData = blobs[0].ptr<float>(); for (size_t ii = 0; ii < outputs.size(); ii++) { Mat &inpBlob = *inputs[ii]; Mat &outBlob = outputs[ii]; int rows = inpBlob.size[1]; int cols = inpBlob.size[2]; const float *srcData = inpBlob.ptr<float>(); float *dstData = outBlob.ptr<float>(); // logistic activation for t0, for each grid cell (X x Y x Anchor-index) for (int i = 0; i < rows*cols*anchors; ++i) { int index = cell_size*i; float x = srcData[index + 4]; dstData[index + 4] = logistic_activate(x); // logistic activation } if (useSoftmaxTree) { // Yolo 9000 CV_Error(cv::Error::StsNotImplemented, "Yolo9000 is not implemented"); } else if (useSoftmax) { // Yolo v2 // softmax activation for Probability, for each grid cell (X x Y x Anchor-index) for (int i = 0; i < rows*cols*anchors; ++i) { int index = cell_size*i; softmax_activate(srcData + index + 5, classes, 1, dstData + index + 5); } for (int x = 0; x < cols; ++x) for(int y = 0; y < rows; ++y) for (int a = 0; a < anchors; ++a) { int index = (y*cols + x)*anchors + a; // index for each grid-cell & anchor int p_index = index * cell_size + 4; float scale = dstData[p_index]; if (classfix == -1 && scale < .5) scale = 0; // if(t0 < 0.5) t0 = 0; int box_index = index * cell_size; dstData[box_index + 0] = (x + logistic_activate(srcData[box_index + 0])) / cols; dstData[box_index + 1] = (y + logistic_activate(srcData[box_index + 1])) / rows; dstData[box_index + 2] = exp(srcData[box_index + 2]) * biasData[2 * a] / cols; dstData[box_index + 3] = exp(srcData[box_index + 3]) * biasData[2 * a + 1] / rows; int class_index = index * cell_size + 5; if (useSoftmaxTree) { CV_Error(cv::Error::StsNotImplemented, "Yolo9000 is not implemented"); } else { for (int j = 0; j < classes; ++j) { float prob = scale*dstData[class_index + j]; // prob = IoU(box, object) = t0 * class-probability dstData[class_index + j] = (prob > thresh) ? prob : 0; // if (IoU < threshold) IoU = 0; } } } } if (nmsThreshold > 0) { do_nms_sort(dstData, rows*cols*anchors, thresh, nmsThreshold); } } }