{

ShapesVec in, out, internal;

// No guarantees that layer which support in-place computations

// will be computed in-place (input.data_ptr == output.data_ptr).

// If layer said that it could work in-place and layers after it

// no longer use input blob, we'll set output = input.

bool supportInPlace;

LayerShapes() {supportInPlace = false;}

{

std::ostringstream ss;

ss << v;

return ss.str();

const Scalar& mean, bool swapRB, bool crop)

{

CV_TRACE_FUNCTION();

std::vector<Mat> images(1, image.getMat());

return blobFromImages(images, scalefactor, size, mean, swapRB, crop);

const Scalar& mean_, bool swapRB, bool crop)

{

CV_TRACE_FUNCTION();

std::vector<Mat> images = images_;

for (int i = 0; i < images.size(); i++)

{

Size imgSize = images[i].size();

if (size == Size())

size = imgSize;

if (size != imgSize)

{

if(crop)

{

float resizeFactor = std::max(size.width / (float)imgSize.width,

size.height / (float)imgSize.height);

resize(images[i], images[i], Size(), resizeFactor, resizeFactor, INTER_LINEAR);

Rect crop(Point(0.5 * (images[i].cols - size.width),

0.5 * (images[i].rows - size.height)),

size);

images[i] = images[i](crop);

}

else

resize(images[i], images[i], size, 0, 0, INTER_LINEAR);

}

if(images[i].depth() == CV_8U)

images[i].convertTo(images[i], CV_32F);

Scalar mean = mean_;

if (swapRB)

std::swap(mean[0], mean[2]);

images[i] -= mean;

images[i] *= scalefactor;

}

size_t i, nimages = images.size();

if(nimages == 0)

return Mat();

Mat image0 = images[0];

int nch = image0.channels();

CV_Assert(image0.dims == 2);

Mat blob, image;

if (nch == 3 || nch == 4)

{

int sz[] = { (int)nimages, nch, image0.rows, image0.cols };

blob = Mat(4, sz, CV_32F);

Mat ch[4];

for( i = 0; i < nimages; i++ )

{

image = images[i];

CV_Assert(image.depth() == CV_32F);

nch = image.channels();

CV_Assert(image.dims == 2 && (nch == 3 || nch == 4));

CV_Assert(image.size() == image0.size());

for( int j = 0; j < nch; j++ )

ch[j] = Mat(image.rows, image.cols, CV_32F, blob.ptr((int)i, j));

if(swapRB)

std::swap(ch[0], ch[2]);

split(image, ch);

}

}

else

{

CV_Assert(nch == 1);

int sz[] = { (int)nimages, 1, image0.rows, image0.cols };

blob = Mat(4, sz, CV_32F);

for( i = 0; i < nimages; i++ )

{

Mat image = images[i];

CV_Assert(image.depth() == CV_32F);

nch = image.channels();

CV_Assert(image.dims == 2 && (nch == 1));

CV_Assert(image.size() == image0.size());

image.copyTo(Mat(image.rows, image.cols, CV_32F, blob.ptr((int)i, 0)));

}

}

return blob;

{

int lid;

int oid;

LayerPin(int layerId = -1, int outputId = -1)

: lid(layerId), oid(outputId) {}

bool valid() const

{

return (lid >= 0 && oid >= 0);

}

bool equal(const LayerPin &r) const

{

return (lid == r.lid && oid == r.oid);

}

bool operator<(const LayerPin &r) const

{

return lid < r.lid || lid == r.lid && oid < r.oid;

}

bool operator ==(const LayerPin &r) const

{

return lid == r.lid && oid == r.oid;

}

{

LayerData() : id(-1), flag(0) {}

LayerData(int _id, const String &_name, const String &_type, LayerParams &_params)

: id(_id), name(_name), type(_type), params(_params), flag(0)

{

CV_TRACE_FUNCTION();

//add logging info

params.name = name;

params.type = type;

}

int id;

String name;

String type;

LayerParams params;

std::vector<LayerPin> inputBlobsId;

std::set<int> inputLayersId;

std::set<int> requiredOutputs;

std::vector<LayerPin> consumers;

std::vector<Ptr<BackendWrapper> > outputBlobsWrappers;

std::vector<Ptr<BackendWrapper> > inputBlobsWrappers;

Ptr<Layer> layerInstance;

std::vector<Mat> outputBlobs;

std::vector<Mat*> inputBlobs;

std::vector<Mat> internals;

std::vector<UMat> umat_outputBlobs;

std::vector<UMat> umat_inputBlobs;

std::vector<UMat> umat_internals;

// Computation nodes of implemented backends (except DEFAULT).

std::map<int, Ptr<BackendNode> > backendNodes;

// Flag for skip layer computation for specific backend.

std::map<int, bool> skipFlags;

int flag;

Ptr<Layer> getLayerInstance()

{

CV_TRACE_FUNCTION();

CV_TRACE_ARG_VALUE(type, "type", type.c_str());

if (layerInstance)

return layerInstance;

layerInstance = LayerFactory::createLayerInstance(type, params);

if (!layerInstance)

{

CV_Error(Error::StsError, "Can't create layer \"" + name + "\" of type \"" + type + "\"");

}

return layerInstance;

}

{

void finalize(const std::vector<Mat*>&, std::vector<Mat>&) {}

void forward(std::vector<Mat*>&, std::vector<Mat>&, std::vector<Mat> &) {}

void forward(InputArrayOfArrays inputs, OutputArrayOfArrays outputs, OutputArrayOfArrays internals) {}

int outputNameToIndex(String tgtName)

{

int idx = (int)(std::find(outNames.begin(), outNames.end(), tgtName) - outNames.begin());

return (idx < (int)outNames.size()) ? idx : -1;

}

void setNames(const std::vector<String> &names)

{

outNames.assign(names.begin(), names.end());

}

bool getMemoryShapes(const std::vector<MatShape> &inputs,

const int requiredOutputs,

std::vector<MatShape> &outputs,

std::vector<MatShape> &internals) const

{

CV_Assert(inputs.size() == requiredOutputs);

outputs.assign(inputs.begin(), inputs.end());

return false;

}

std::vector<String> outNames;

{

// Increase references counter to layer output.

void addReference(const LayerPin& lp)

{

std::map<LayerPin, int>::iterator it = refCounter.find(lp);

if (it == refCounter.end())

refCounter[lp] = 1;

else

it->second += 1;

}

void addReferences(const std::vector<LayerPin>& pins)

{

for (int i = 0; i < pins.size(); i++)

{

addReference(pins[i]);

}

}

// Returns number of references to allocated memory that used in specific

// layer blob.

int numReferences(const LayerPin& lp)

{

std::map<LayerPin, LayerPin>::iterator mapIt = reuseMap.find(lp);

CV_Assert(mapIt != reuseMap.end());

LayerPin memHost = mapIt->second;

std::map<LayerPin, int>::iterator refIt = refCounter.find(memHost);

CV_Assert(refIt != refCounter.end());

return refIt->second;

}

// Reuse data allocated in <host> inside the <user> blob.

void reuse(const LayerPin& host, const LayerPin& user)

{

CV_Assert(reuseMap.find(user) == reuseMap.end());

CV_Assert(reuseMap.find(host) != reuseMap.end());

LayerPin memHost = reuseMap[host];

reuseMap[user] = memHost;

if (refCounter.find(memHost) != refCounter.end())

{

std::map<LayerPin, int>::iterator userRefIt = refCounter.find(user);

if (userRefIt != refCounter.end())

{

refCounter[memHost] += userRefIt->second;

refCounter.erase(userRefIt);

}

else

refCounter[memHost] += 1;

}

}

// Decrease references counter to allocated memory inside specific blob.

void releaseReference(const LayerPin& lp)

{

std::map<LayerPin, LayerPin>::iterator mapIt = reuseMap.find(lp);

CV_Assert(mapIt != reuseMap.end());

std::map<LayerPin, int>::iterator refIt = refCounter.find(mapIt->second);

CV_Assert(refIt != refCounter.end());

CV_Assert(refIt->second > 0);

refIt->second -= 1;

}

void releaseReferences(const std::vector<LayerPin>& pins)

{

for (int i = 0; i < pins.size(); i++)

{

releaseReference(pins[i]);

}

}

void reuseOrCreate(const MatShape& shape, const LayerPin& lp, Mat& dst)

{

#ifdef REUSE_DNN_MEMORY

Mat bestBlob;

LayerPin bestBlobPin;

std::map<LayerPin, Mat>::iterator hostIt;

std::map<LayerPin, int>::iterator refIt;

const int targetTotal = total(shape);

int bestBlobTotal = INT_MAX;

for (hostIt = memHosts.begin(); hostIt != memHosts.end(); ++hostIt)

{

refIt = refCounter.find(hostIt->first);

// Use only blobs that had references before because if not,

// it might be used as output.

if (refIt != refCounter.end() && refIt->second == 0)

{

Mat& unusedBlob = hostIt->second;

if (unusedBlob.total() >= targetTotal &&

unusedBlob.total() < bestBlobTotal)

{

bestBlobPin = hostIt->first;

bestBlob = unusedBlob;

bestBlobTotal = unusedBlob.total();

}

}

}

if (!bestBlob.empty())

{

reuse(bestBlobPin, lp);

dst = bestBlob.reshape(1, 1).colRange(0, targetTotal).reshape(1, shape);

}

else

#endif // REUSE_DNN_MEMORY

{

// if dst already has been allocated with total(shape) elements,

// it won't be recrreated and pointer of dst.data remains the same.

dst.create(shape, CV_32F);

addHost(lp, dst);

}

}

void reuseOrCreate(const MatShape& shape, const LayerPin& lp, UMat &umat_dst)

{

#ifdef REUSE_DNN_MEMORY

UMat bestBlob;

LayerPin bestBlobPin;

std::map<LayerPin, UMat>::iterator hostIt;

std::map<LayerPin, int>::iterator refIt;

const int targetTotal = total(shape);

int bestBlobTotal = INT_MAX;

for (hostIt = umat_memHosts.begin(); hostIt != umat_memHosts.end(); ++hostIt)

{

refIt = refCounter.find(hostIt->first);

// Use only blobs that had references before because if not,

// it might be used as output.

if (refIt != refCounter.end() && refIt->second == 0)

{

UMat& unusedBlob = hostIt->second;

if (unusedBlob.total() >= targetTotal &&

unusedBlob.total() < bestBlobTotal)

{

bestBlobPin = hostIt->first;

bestBlob = unusedBlob;

bestBlobTotal = unusedBlob.total();

}

}

}

if (!bestBlob.empty())

{

reuse(bestBlobPin, lp);

umat_dst.create(shape, CV_32F);

}

else

#endif // REUSE_DNN_MEMORY

{

// if dst already has been allocated with total(shape) elements,

// it won't be recrreated and pointer of dst.data remains the same.

umat_dst.create(shape, CV_32F);

addHost(lp, umat_dst);

}

}

void allocateBlobsForLayer(LayerData &ld, const LayerShapes& layerShapes,

std::vector<LayerPin>& pinsForInternalBlobs)

{

CV_TRACE_FUNCTION();

bool use_umat = (preferableBackend == DNN_BACKEND_DEFAULT &&

preferableTarget == DNN_TARGET_OPENCL);

pinsForInternalBlobs.clear();

std::vector<Mat>& outputBlobs = ld.outputBlobs,

&internalBlobs = ld.internals;

std::vector<UMat>& umat_outputBlobs = ld.umat_outputBlobs,

&umat_internalBlobs = ld.umat_internals;

const ShapesVec& outShapes = layerShapes.out,

internalShapes = layerShapes.internal;

outputBlobs.resize(std::max((size_t)1, outShapes.size())); //layer produce at least one output blob

internalBlobs.resize(internalShapes.size());

if (use_umat)

{

umat_outputBlobs.resize(std::max((size_t)1, outShapes.size()));

umat_internalBlobs.resize(internalShapes.size());

}

CV_Assert(ld.requiredOutputs.size() <= outShapes.size());

// Check that layer could work in-place.

bool inPlace = false;

if (layerShapes.supportInPlace)

{

if (ld.inputBlobs.size() == 1)

{

// Get number of references to the input memory.

int numRef = numReferences(ld.inputBlobsId[0]);

// If current layer is one and only customer of this blob.

inPlace = numRef == 1;

}

}

ShapesVec shapes(outShapes);

shapes.insert(shapes.end(), internalShapes.begin(), internalShapes.end());

std::vector<Mat*> blobs;

std::vector<UMat*> umat_blobs;

for(int i = 0; i < outputBlobs.size(); i++)

{

blobs.push_back(&outputBlobs[i]);

if (use_umat)

umat_blobs.push_back(&umat_outputBlobs[i]);

}

for(int i = 0; i < internalBlobs.size(); i++)

{

blobs.push_back(&internalBlobs[i]);

if (use_umat)

umat_blobs.push_back(&umat_internalBlobs[i]);

if (total(internalShapes[i]))

{

pinsForInternalBlobs.push_back(LayerPin(ld.id, ld.outputBlobs.size() + i));

}

}

addReferences(pinsForInternalBlobs);

std::map<int, std::vector<int> > idxSizes;

for(int i = 0; i < shapes.size(); i++)

{

idxSizes[total(shapes[i])].push_back(i);

}

std::map<int, std::vector<int> >::reverse_iterator it;

for(it = idxSizes.rbegin(); it != idxSizes.rend(); it++)

{

for(int j = 0; j < it->second.size(); j++)

{

int index = it->second[j];

if (total(shapes[index]))

{

LayerPin blobPin(ld.id, index);

if (index < outShapes.size() && inPlace)

{

if (use_umat)

{

CV_Assert(ld.umat_inputBlobs[0].total() == total(shapes[index]));

ld.umat_outputBlobs[index] =

ld.umat_inputBlobs[0].reshape(1, shapes[index].size(),

&shapes[index][0]);

}

else

{

CV_Assert(ld.inputBlobs[0]->total() == total(shapes[index]));

ld.outputBlobs[index] = ld.inputBlobs[0]->reshape(1, shapes[index]);

}

reuse(ld.inputBlobsId[0], blobPin);

}

else

{

if (use_umat)

reuseOrCreate(shapes[index], blobPin, *umat_blobs[index]);

else

reuseOrCreate(shapes[index], blobPin, *blobs[index]);

}

}

}

}

}

// Clear internal state. Calls before an every reallocation.

void reset()

{

CV_TRACE_FUNCTION();

refCounter.clear();

reuseMap.clear();

memHosts.clear();

umat_memHosts.clear();

preferableTarget = DNN_TARGET_CPU;

preferableBackend = DNN_BACKEND_DEFAULT;

}

void setPreferableTarget(int targetId)

{

preferableTarget = targetId;

}

void setPreferableBackend(int backendId)

{

preferableBackend = backendId;

}

// Register allocated memory.

void addHost(const LayerPin& lp, const Mat& mat)

{

CV_Assert(memHosts.find(lp) == memHosts.end());

reuseMap[lp] = lp;

memHosts[lp] = mat;

}

void addHost(const LayerPin& lp, const UMat& umat)

{

CV_Assert(umat_memHosts.find(lp) == umat_memHosts.end());

reuseMap[lp] = lp;

umat_memHosts[lp] = umat;

}

std::map<LayerPin, int> refCounter;

// Maps pin to origin blob (for whom memory was allocated firstly).

// For origin blobs key == value.

std::map<LayerPin, LayerPin> reuseMap;

std::map<LayerPin, Mat> memHosts;

std::map<LayerPin, UMat> umat_memHosts;

int preferableTarget;

int preferableBackend;

{

if (backendId == DNN_BACKEND_DEFAULT)

{

return Ptr<BackendWrapper>();

}

else if (backendId == DNN_BACKEND_HALIDE)

{

CV_Assert(haveHalide());

#ifdef HAVE_HALIDE

return Ptr<BackendWrapper>(new HalideBackendWrapper(targetId, m));

#endif // HAVE_HALIDE

}

else

CV_Error(Error::StsNotImplemented, "Unknown backend identifier");

return Ptr<BackendWrapper>();

{

//allocate fake net input layer

netInputLayer = Ptr<DataLayer>(new DataLayer());

LayerData &inpl = layers.insert( make_pair(0, LayerData()) ).first->second;

inpl.id = 0;

inpl.name = "_input";

inpl.type = "__NetInputLayer__";

inpl.layerInstance = netInputLayer;

layerNameToId.insert(std::make_pair(inpl.name, inpl.id));

lastLayerId = 0;

netWasAllocated = false;

fusion = true;

preferableBackend = DNN_BACKEND_DEFAULT;

preferableTarget = DNN_TARGET_CPU;

blobManager.setPreferableBackend(DNN_BACKEND_DEFAULT);

blobManager.setPreferableTarget(DNN_TARGET_CPU);

{

if (preferableBackend == DNN_BACKEND_DEFAULT)

return Ptr<BackendWrapper>();

MatShape shape(host.dims);

for (int i = 0; i < host.dims; ++i)

shape[i] = host.size[i];

void* data = host.data;

if (backendWrappers.find(data) != backendWrappers.end())

{

Ptr<BackendWrapper> baseBuffer = backendWrappers[data];

if (preferableBackend == DNN_BACKEND_HALIDE)

{

CV_Assert(haveHalide());

#ifdef HAVE_HALIDE

return Ptr<BackendWrapper>(new HalideBackendWrapper(baseBuffer, shape));

#endif // HAVE_HALIDE

}

else

CV_Error(Error::StsNotImplemented, "Unknown backend identifier");

}

Ptr<BackendWrapper> wrapper = wrapMat(preferableBackend, preferableTarget, host);

backendWrappers[data] = wrapper;

return wrapper;

{

CV_TRACE_FUNCTION();

CV_Assert(preferableBackend == DNN_BACKEND_HALIDE);

HalideScheduler scheduler(halideConfigFile);

std::vector< std::reference_wrapper<LayerData> > compileList; compileList.reserve(64);

for (MapIdToLayerData::iterator it = layers.begin(); it != layers.end(); ++it)

{

LayerData &ld = it->second;

Ptr<Layer> layer = ld.layerInstance;

if (layer->supportBackend(DNN_BACKEND_HALIDE) && !ld.skipFlags[DNN_BACKEND_HALIDE])

{

CV_Assert(!ld.backendNodes[DNN_BACKEND_HALIDE].empty());

bool scheduled = scheduler.process(ld.backendNodes[DNN_BACKEND_HALIDE]);

if (!scheduled)

{

// Use automatic scheduling provided by layer.

layer->applyHalideScheduler(ld.backendNodes[DNN_BACKEND_HALIDE],

ld.inputBlobs, ld.outputBlobs,

preferableTarget);

}

compileList.emplace_back(ld);

}

}

std::atomic<int> progress(0);

auto fn = ([&] () -> void

{

for (;;)

{

int id = progress.fetch_add(1);

if ((size_t)id >= compileList.size())

return;

const LayerData& ld = compileList[id].get();

Ptr<BackendNode> node = ld.backendNodes.find(DNN_BACKEND_HALIDE)->second;

dnn::compileHalide(ld.outputBlobs, node, preferableTarget);

}

});

size_t num_threads = std::min(compileList.size(), (size_t)std::thread::hardware_concurrency());

num_threads = std::max((size_t)1u, std::min((size_t)8u, num_threads));

std::vector<std::thread> threads(num_threads - 1);

for (auto& t: threads) t = std::thread(fn);

fn(); // process own tasks

for (auto& t: threads) t.join();

{

CV_TRACE_FUNCTION();

MapIdToLayerData::iterator it;

for (it = layers.begin(); it != layers.end(); it++)

{

if (it->second.id != 0) {

it->second.inputBlobs.clear();

it->second.outputBlobs.clear();

it->second.internals.clear();

it->second.umat_inputBlobs.clear();

it->second.umat_outputBlobs.clear();

it->second.umat_internals.clear();

}

it->second.skipFlags.clear();

//it->second.consumers.clear();

Ptr<Layer> currLayer = it->second.layerInstance;

if( currLayer.empty() )

continue;

currLayer->unsetAttached();

Ptr<PoolingLayer> poolingLayer = currLayer.dynamicCast<PoolingLayer>();

if( !poolingLayer.empty() )

{

poolingLayer->computeMaxIdx = true;

}

}

it = layers.find(0);

CV_Assert(it != layers.end());

it->second.skipFlags[DNN_BACKEND_DEFAULT] = true;

layersTimings.clear();

{

CV_TRACE_FUNCTION();

if (!netWasAllocated || this->blobsToKeep != blobsToKeep_)

{

clear();

allocateLayers(blobsToKeep_);

computeNetOutputLayers();

initBackend();

if (!netWasAllocated )

{

#ifdef HAVE_HALIDE

if (preferableBackend == DNN_BACKEND_HALIDE)

compileHalide();

#else

CV_Assert(preferableBackend != DNN_BACKEND_HALIDE);

#endif

}

netWasAllocated = true;

this->blobsToKeep = blobsToKeep_;

}

{

std::map<String, int>::iterator it = layerNameToId.find(layerName);

return (it != layerNameToId.end()) ? it->second : -1;

{

MapIdToLayerData::iterator it = layers.find(id);

return (it != layers.end()) ? id : -1;

{

if (layerDesc.isInt())

return getLayerId(layerDesc.get<int>());

else if (layerDesc.isString())

return getLayerId(layerDesc.get<String>());

CV_Assert(layerDesc.isInt() || layerDesc.isString());

return -1;

{

MapIdToLayerData::iterator it = layers.find(id);

return (it != layers.end()) ? it->second.name : "(unknown layer)";

{

if ((int)ld.inputBlobsId.size() <= inNum)

{

ld.inputBlobsId.resize(inNum + 1);

}

else

{

LayerPin storedFrom = ld.inputBlobsId[inNum];

if (storedFrom.valid() && !storedFrom.equal(from))

CV_Error(Error::StsError, "Input #" + toString(inNum) + "of layer \"" + ld.name + "\" already was connected");

}

ld.inputBlobsId[inNum] = from;

{

size_t delimPos = pinAlias.find('.');

layerName = pinAlias.substr(0, delimPos);

outName = (delimPos == String::npos) ? String() : pinAlias.substr(delimPos + 1);

{

if (outName.empty())

return 0;

if (std::isdigit(outName[0]))

{

char *lastChar;

long inum = std::strtol(outName.c_str(), &lastChar, 10);

if (*lastChar == 0)

{

CV_Assert(inum == (int)inum);

return (int)inum;

}

}

return ld.getLayerInstance()->outputNameToIndex(outName);

{

LayerPin pin;

String layerName, outName;

splitPin(pinAlias, layerName, outName);

pin.lid = (layerName.empty()) ? 0 : getLayerId(layerName);

if (pin.lid >= 0)

pin.oid = resolvePinOutputName(getLayerData(pin.lid), outName);

return pin;

{

String layerName, outName;

splitPin(pinAlias, layerName, outName);

int lid = (layerName.empty()) ? 0 : getLayerId(layerName);

std::vector<LayerPin> pins;

for (int i = 0; i < layers[lid].outputBlobs.size(); i++)

{

pins.push_back(LayerPin(lid, i));

}

return pins;

{

CV_Assert(outLayerId < inLayerId);

LayerData &ldOut = getLayerData(outLayerId);

LayerData &ldInp = getLayerData(inLayerId);

addLayerInput(ldInp, inNum, LayerPin(outLayerId, outNum));

ldOut.requiredOutputs.insert(outNum);

ldOut.consumers.push_back(LayerPin(inLayerId, outNum));

{

CV_TRACE_FUNCTION();

netOutputs.clear();

MapIdToLayerData::iterator it;

for (it = layers.begin(); it != layers.end(); it++)

{

int lid = it->first;

LayerData &ld = it->second;

if (ld.requiredOutputs.size() == 0)

netOutputs.push_back(lid);

}

#ifndef NDEBUG

std::cout << "\nNet Outputs(" << netOutputs.size() << "):\n";

for (size_t i = 0; i < netOutputs.size(); i++)

std::cout << layers[netOutputs[i]].name << "\n";

#endif

{

CV_TRACE_FUNCTION();

if (preferableBackend == DNN_BACKEND_DEFAULT)

{

CV_Assert(preferableTarget == DNN_TARGET_CPU || preferableTarget == DNN_TARGET_OPENCL);

return;

}

// Iterator to current layer.

MapIdToLayerData::iterator it = layers.begin();

// Iterator to base layer for fusion. In example, in case of conv+bn+relu

// it'll be a conv layer.

MapIdToLayerData::iterator baseIt = layers.begin();

for (; it != layers.end(); it++)

{