mirror of https://github.com/opencv/opencv.git
Merge pull request #24294 from alexlyulkov:al/remove-torch7-from-dnn
Remove torch (old torch7) from dnn in 5.x #24294 Merge with https://github.com/opencv/opencv_extra/pull/1097 Completely removed torch (old torch7) from dnn: - removed modules/dnn/src/torch directory that contained torch7 model parser - removed readNetFromTorch() and readTorchBlob() public functions - removed torch7 references from comments and help texts - replaced links to t7 models by links to similar onnx models in js_style_transfer turtorial (similar to https://github.com/opencv/opencv/pull/24245/files)pull/24486/head
alexlyulkov
1 year ago
committed by
GitHub
parent
97620c053f
commit
b71be65f57
26 changed files with 41 additions and 3079 deletions
@ -1,76 +1,44 @@ |
||||
{ |
||||
"torch": [ |
||||
"onnx": [ |
||||
{ |
||||
"model": "candy.t7", |
||||
"model": "mosaic-9.onnx", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"mean": "0, 0, 0", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/candy.t7" |
||||
"swapRB": "true", |
||||
"modelUrl": "https://media.githubusercontent.com/media/onnx/models/main/vision/style_transfer/fast_neural_style/model/mosaic-9.onnx" |
||||
}, |
||||
{ |
||||
"model": "composition_vii.t7", |
||||
"model": "candy-9.onnx", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"mean": "0, 0, 0", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//eccv16/composition_vii.t7" |
||||
"swapRB": "true", |
||||
"modelUrl": "https://media.githubusercontent.com/media/onnx/models/main/vision/style_transfer/fast_neural_style/model/candy-9.onnx" |
||||
}, |
||||
{ |
||||
"model": "feathers.t7", |
||||
"model": "rain-princess-9.onnx", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"mean": "0, 0, 0", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/feathers.t7" |
||||
"swapRB": "true", |
||||
"modelUrl": "https://media.githubusercontent.com/media/onnx/models/main/vision/style_transfer/fast_neural_style/model/rain-princess-9.onnx" |
||||
}, |
||||
{ |
||||
"model": "la_muse.t7", |
||||
"model": "udnie-9.onnx", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"mean": "0, 0, 0", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/la_muse.t7" |
||||
"swapRB": "true", |
||||
"modelUrl": "https://media.githubusercontent.com/media/onnx/models/main/vision/style_transfer/fast_neural_style/model/udnie-9.onnx" |
||||
}, |
||||
{ |
||||
"model": "mosaic.t7", |
||||
"model": "pointilism-9.onnx", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"mean": "0, 0, 0", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/mosaic.t7" |
||||
}, |
||||
{ |
||||
"model": "starry_night.t7", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//eccv16/starry_night.t7" |
||||
}, |
||||
{ |
||||
"model": "the_scream.t7", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/the_scream.t7" |
||||
}, |
||||
{ |
||||
"model": "the_wave.t7", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//eccv16/the_wave.t7" |
||||
}, |
||||
{ |
||||
"model": "udnie.t7", |
||||
"inputSize": "224, 224", |
||||
"mean": "104, 117, 123", |
||||
"std": "1", |
||||
"swapRB": "false", |
||||
"modelUrl": "https://cs.stanford.edu/people/jcjohns/fast-neural-style/models//instance_norm/udnie.t7" |
||||
"swapRB": "true", |
||||
"modelUrl": "https://media.githubusercontent.com/media/onnx/models/main/vision/style_transfer/fast_neural_style/model/pointilism-9.onnx" |
||||
} |
||||
] |
||||
} |
||||
} |
||||
|
||||
@ -1,36 +0,0 @@ |
||||
Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) |
||||
Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) |
||||
Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) |
||||
Copyright (c) 2011-2013 NYU (Clement Farabet) |
||||
Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) |
||||
Copyright (c) 2006 Idiap Research Institute (Samy Bengio) |
||||
Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) |
||||
|
||||
All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are met: |
||||
|
||||
1. Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright |
||||
notice, this list of conditions and the following disclaimer in the |
||||
documentation and/or other materials provided with the distribution. |
||||
|
||||
3. Neither the names of Deepmind Technologies, NYU, NEC Laboratories America |
||||
and IDIAP Research Institute nor the names of its contributors may be |
||||
used to endorse or promote products derived from this software without |
||||
specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
||||
POSSIBILITY OF SUCH DAMAGE. |
||||
@ -1,530 +0,0 @@ |
||||
#include "../precomp.hpp" |
||||
#include "THGeneral.h" |
||||
#include "THDiskFile.h" |
||||
#include "THFilePrivate.h" |
||||
|
||||
namespace TH |
||||
{ |
||||
|
||||
typedef struct THDiskFile__ |
||||
{ |
||||
THFile file; |
||||
|
||||
FILE *handle; |
||||
int isNativeEncoding; |
||||
int longSize; |
||||
|
||||
} THDiskFile; |
||||
|
||||
static int THDiskFile_isOpened(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)self; |
||||
return (dfself->handle != NULL); |
||||
} |
||||
|
||||
/* workaround mac osx lion ***insane*** fread bug */ |
||||
#ifdef __APPLE__ |
||||
static size_t fread__(void *ptr, size_t size, size_t nitems, FILE *stream) |
||||
{ |
||||
size_t nread = 0; |
||||
while(!feof(stream) && !ferror(stream) && (nread < nitems)) |
||||
nread += fread((char*)ptr+nread*size, size, std::min<size_t>(2147483648UL/size, nitems-nread), stream); |
||||
return nread; |
||||
} |
||||
#else |
||||
#define fread__ fread |
||||
#endif |
||||
|
||||
#define READ_WRITE_METHODS(TYPE, TYPEC, ASCII_READ_ELEM, ASCII_WRITE_ELEM) \ |
||||
static long THDiskFile_read##TYPEC(THFile *self, TYPE *data, long n) \
|
||||
{ \
|
||||
THDiskFile *dfself = (THDiskFile*)(self); \
|
||||
long nread = 0L; \
|
||||
\
|
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); \
|
||||
THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); \
|
||||
\
|
||||
if(dfself->file.isBinary) \
|
||||
{ \
|
||||
nread = fread__(data, sizeof(TYPE), n, dfself->handle); \
|
||||
if(!dfself->isNativeEncoding && (sizeof(TYPE) > 1) && (nread > 0)) \
|
||||
THDiskFile_reverseMemory(data, data, sizeof(TYPE), nread); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
long i; \
|
||||
for(i = 0; i < n; i++) \
|
||||
{ \
|
||||
ASCII_READ_ELEM; /* increment here result and break if wrong */ \
|
||||
} \
|
||||
if(dfself->file.isAutoSpacing && (n > 0)) \
|
||||
{ \
|
||||
int c = fgetc(dfself->handle); \
|
||||
if( (c != '\n') && (c != EOF) ) \
|
||||
ungetc(c, dfself->handle); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
if(nread != n) \
|
||||
{ \
|
||||
dfself->file.hasError = 1; /* shouldn't we put hasError to 0 all the time ? */ \
|
||||
if(!dfself->file.isQuiet) \
|
||||
THError("read error: read %ld blocks instead of %ld", nread, n);\
|
||||
} \
|
||||
\
|
||||
return nread; \
|
||||
} |
||||
|
||||
static int THDiskFile_mode(const char *mode, int *isReadable, int *isWritable) |
||||
{ |
||||
*isReadable = 0; |
||||
*isWritable = 0; |
||||
if(strlen(mode) == 1) |
||||
{ |
||||
if(*mode == 'r') |
||||
{ |
||||
*isReadable = 1; |
||||
return 1; |
||||
} |
||||
else if(*mode == 'w') |
||||
{ |
||||
*isWritable = 1; |
||||
return 1; |
||||
} |
||||
} |
||||
else if(strlen(mode) == 2) |
||||
{ |
||||
if(mode[0] == 'r' && mode[1] == 'w') |
||||
{ |
||||
*isReadable = 1; |
||||
*isWritable = 1; |
||||
return 1; |
||||
} |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static void THDiskFile_seek(THFile *self, long position) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
|
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
|
||||
#if defined(_WIN64) |
||||
if(_fseeki64(dfself->handle, (__int64)position, SEEK_SET) < 0) |
||||
#elif defined(_WIN32) |
||||
if(fseek(dfself->handle, (long)position, SEEK_SET) < 0) |
||||
#else |
||||
if(fseeko(dfself->handle, (off_t)position, SEEK_SET) < 0) |
||||
#endif |
||||
{ |
||||
dfself->file.hasError = 1; |
||||
if(!dfself->file.isQuiet) |
||||
THError("unable to seek at position %ld", position); |
||||
} |
||||
} |
||||
|
||||
static void THDiskFile_seekEnd(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
|
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
|
||||
#if defined(_WIN64) |
||||
if(_fseeki64(dfself->handle, 0L, SEEK_END) < 0) |
||||
#elif defined(_WIN32) |
||||
if(fseek(dfself->handle, 0L, SEEK_END) < 0) |
||||
#else |
||||
if(fseeko(dfself->handle, 0L, SEEK_END) < 0) |
||||
#endif |
||||
{ |
||||
dfself->file.hasError = 1; |
||||
if(!dfself->file.isQuiet) |
||||
THError("unable to seek at end of file"); |
||||
} |
||||
} |
||||
|
||||
static long THDiskFile_position(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
|
||||
#if defined(_WIN64) |
||||
__int64 offset = _ftelli64(dfself->handle); |
||||
#elif defined(_WIN32) |
||||
long offset = ftell(dfself->handle); |
||||
#else |
||||
off_t offset = ftello(dfself->handle); |
||||
#endif |
||||
if (offset > -1) |
||||
return (long)offset; |
||||
else if(!dfself->file.isQuiet) |
||||
THError("unable to obtain disk file offset (maybe a long overflow occurred)"); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void THDiskFile_close(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
fclose(dfself->handle); |
||||
dfself->handle = NULL; |
||||
} |
||||
|
||||
/* Little and Big Endian */ |
||||
|
||||
static void THDiskFile_reverseMemory(void *dst, const void *src, long blockSize, long numBlocks) |
||||
{ |
||||
if(blockSize != 1) |
||||
{ |
||||
long halfBlockSize = blockSize/2; |
||||
char *charSrc = (char*)src; |
||||
char *charDst = (char*)dst; |
||||
long b, i; |
||||
for(b = 0; b < numBlocks; b++) |
||||
{ |
||||
for(i = 0; i < halfBlockSize; i++) |
||||
{ |
||||
char z = charSrc[i]; |
||||
charDst[i] = charSrc[blockSize-1-i]; |
||||
charDst[blockSize-1-i] = z; |
||||
} |
||||
charSrc += blockSize; |
||||
charDst += blockSize; |
||||
} |
||||
} |
||||
} |
||||
|
||||
int THDiskFile_isLittleEndianCPU(void) |
||||
{ |
||||
int x = 7; |
||||
char *ptr = (char *)&x; |
||||
|
||||
if(ptr[0] == 0) |
||||
return 0; |
||||
else |
||||
return 1; |
||||
} |
||||
|
||||
int THDiskFile_isBigEndianCPU(void) |
||||
{ |
||||
return(!THDiskFile_isLittleEndianCPU()); |
||||
} |
||||
|
||||
void THDiskFile_nativeEndianEncoding(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
dfself->isNativeEncoding = 1; |
||||
} |
||||
|
||||
void THDiskFile_littleEndianEncoding(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
dfself->isNativeEncoding = THDiskFile_isLittleEndianCPU(); |
||||
} |
||||
|
||||
void THDiskFile_bigEndianEncoding(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
dfself->isNativeEncoding = !THDiskFile_isLittleEndianCPU(); |
||||
} |
||||
|
||||
/* End of Little and Big Endian Stuff */ |
||||
|
||||
void THDiskFile_longSize(THFile *self, int size) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
THArgCheck(size == 0 || size == 4 || size == 8, 1, "Invalid long size specified"); |
||||
dfself->longSize = size; |
||||
} |
||||
|
||||
void THDiskFile_noBuffer(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
if (setvbuf(dfself->handle, NULL, _IONBF, 0)) { |
||||
THError("error: cannot disable buffer"); |
||||
} |
||||
} |
||||
|
||||
static void THDiskFile_free(THFile *self) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
if(dfself->handle) |
||||
fclose(dfself->handle); |
||||
THFree(dfself); |
||||
} |
||||
|
||||
/* Note that we do a trick */ |
||||
READ_WRITE_METHODS(unsigned char, Byte, |
||||
nread = fread(data, 1, n, dfself->handle); break, |
||||
nwrite = fwrite(data, 1, n, dfself->handle); break) |
||||
|
||||
READ_WRITE_METHODS(char, Char, |
||||
nread = fread(data, 1, n, dfself->handle); break, |
||||
nwrite = fwrite(data, 1, n, dfself->handle); break) |
||||
|
||||
READ_WRITE_METHODS(short, Short, |
||||
int ret = fscanf(dfself->handle, "%hd", &data[i]); if(ret <= 0) break; else nread++, |
||||
int ret = fprintf(dfself->handle, "%hd", data[i]); if(ret <= 0) break; else nwrite++) |
||||
|
||||
READ_WRITE_METHODS(int, Int, |
||||
int ret = fscanf(dfself->handle, "%d\n\r", &data[i]); if(ret <= 0) break; else nread++, |
||||
int ret = fprintf(dfself->handle, "%d", data[i]); if(ret <= 0) break; else nwrite++) |
||||
|
||||
/*READ_WRITE_METHODS(long, Long,
|
||||
int ret = fscanf(dfself->handle, "%ld", &data[i]); if(ret <= 0) break; else nread++, |
||||
int ret = fprintf(dfself->handle, "%ld", data[i]); if(ret <= 0) break; else nwrite++)*/ |
||||
|
||||
READ_WRITE_METHODS(float, Float, |
||||
int ret = fscanf(dfself->handle, "%g", &data[i]); if(ret <= 0) break; else nread++, |
||||
int ret = fprintf(dfself->handle, "%.9g", data[i]); if(ret <= 0) break; else nwrite++) |
||||
|
||||
READ_WRITE_METHODS(double, Double, |
||||
int ret = fscanf(dfself->handle, "%lg", &data[i]); if(ret <= 0) break; else nread++, |
||||
int ret = fprintf(dfself->handle, "%.17g", data[i]); if(ret <= 0) break; else nwrite++) |
||||
|
||||
|
||||
/* For Long we need to rewrite everything, because of the special management of longSize */ |
||||
static long THDiskFile_readLong(THFile *self, int64 *data, long n) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
long nread = 0L; |
||||
|
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); |
||||
|
||||
if(dfself->file.isBinary) |
||||
{ |
||||
if(dfself->longSize == 0 || dfself->longSize == sizeof(int64)) |
||||
{ |
||||
nread = fread__(data, sizeof(int64), n, dfself->handle); |
||||
if(!dfself->isNativeEncoding && (sizeof(int64) > 1) && (nread > 0)) |
||||
THDiskFile_reverseMemory(data, data, sizeof(int64), nread); |
||||
} else if(dfself->longSize == 4) |
||||
{ |
||||
nread = fread__(data, 4, n, dfself->handle); |
||||
if(!dfself->isNativeEncoding && (nread > 0)) |
||||
THDiskFile_reverseMemory(data, data, 4, nread); |
||||
long i; |
||||
for(i = nread; i > 0; i--) |
||||
data[i-1] = ((int *)data)[i-1]; |
||||
} |
||||
else /* if(dfself->longSize == 8) */ |
||||
{ |
||||
int big_endian = !THDiskFile_isLittleEndianCPU(); |
||||
int32_t *buffer = (int32_t*)THAlloc(8*n); |
||||
if (!buffer) |
||||
THError("can not allocate buffer"); |
||||
nread = fread__(buffer, 8, n, dfself->handle); |
||||
long i; |
||||
for(i = nread; i > 0; i--) |
||||
data[i-1] = buffer[2*(i-1) + big_endian]; |
||||
THFree(buffer); |
||||
if(!dfself->isNativeEncoding && (nread > 0)) |
||||
THDiskFile_reverseMemory(data, data, 4, nread); |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
long i; |
||||
for(i = 0; i < n; i++) |
||||
{ |
||||
long d; |
||||
int ret = fscanf(dfself->handle, "%ld", &d); if(ret <= 0) break; else nread++; |
||||
data[i] = d; |
||||
} |
||||
if(dfself->file.isAutoSpacing && (n > 0)) |
||||
{ |
||||
int c = fgetc(dfself->handle); |
||||
if( (c != '\n') && (c != EOF) ) |
||||
ungetc(c, dfself->handle); |
||||
} |
||||
} |
||||
|
||||
if(nread != n) |
||||
{ |
||||
dfself->file.hasError = 1; /* shouldn't we put hasError to 0 all the time ? */ |
||||
if(!dfself->file.isQuiet) |
||||
THError("read error: read %ld blocks instead of %ld", nread, n); |
||||
} |
||||
|
||||
return nread; |
||||
} |
||||
|
||||
|
||||
static long THDiskFile_readString(THFile *self, const char *format, char **str_) |
||||
{ |
||||
THDiskFile *dfself = (THDiskFile*)(self); |
||||
THArgCheck(dfself->handle != NULL, 1, "attempt to use a closed file"); |
||||
THArgCheck(dfself->file.isReadable, 1, "attempt to read in a write-only file"); |
||||
THArgCheck((strlen(format) >= 2 ? (format[0] == '*') && (format[1] == 'a' || format[1] == 'l') : 0), 2, "format must be '*a' or '*l'"); |
||||
|
||||
/* note: the string won't survive long, as it is copied into lua */ |
||||
/* so 1024 is not that big... */ |
||||
#define TBRS_BSZ 1024L |
||||
|
||||
if(format[1] == 'a') |
||||
{ |
||||
char *p = (char*)THAlloc(TBRS_BSZ); |
||||
long total = TBRS_BSZ; |
||||
long pos = 0L; |
||||
|
||||
if (p == NULL) |
||||
THError("read error: failed to allocate buffer"); |
||||
for (;;) |
||||
{ |
||||
if(total-pos == 0) /* we need more space! */ |
||||
{ |
||||
total += TBRS_BSZ; |
||||
char *new_p = (char*)THRealloc(p, total); |
||||
if (new_p == NULL) |
||||
{ |
||||
THFree(p); |
||||
THError("read error: failed to reallocate buffer"); |
||||
} |
||||
p = new_p; |
||||
} |
||||
pos += fread(p+pos, 1, total-pos, dfself->handle); |
||||
if (pos < total) /* eof? */ |
||||
{ |
||||
if(pos == 0L) |
||||
{ |
||||
THFree(p); |
||||
dfself->file.hasError = 1; |
||||
if(!dfself->file.isQuiet) |
||||
THError("read error: read 0 blocks instead of 1"); |
||||
|
||||
*str_ = NULL; |
||||
return 0; |
||||
} |
||||
*str_ = p; |
||||
return pos; |
||||
} |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
char *p = (char*)THAlloc(TBRS_BSZ); |
||||
long total = TBRS_BSZ; |
||||
long pos = 0L; |
||||
long size; |
||||
|
||||
if (p == NULL) |
||||
THError("read error: failed to allocate buffer"); |
||||
for (;;) |
||||
{ |
||||
if(total-pos <= 1) /* we can only write '\0' in there! */ |
||||
{ |
||||
total += TBRS_BSZ; |
||||
char *new_p = (char*)THRealloc(p, total); |
||||
if (new_p == NULL) |
||||
{ |
||||
THFree(p); |
||||
THError("read error: failed to reallocate buffer"); |
||||
} |
||||
p = new_p; |
||||
} |
||||
if (fgets(p+pos, total-pos, dfself->handle) == NULL) /* eof? */ |
||||
{ |
||||
if(pos == 0L) |
||||
{ |
||||
THFree(p); |
||||
dfself->file.hasError = 1; |
||||
if(!dfself->file.isQuiet) |
||||
THError("read error: read 0 blocks instead of 1"); |
||||
|
||||
*str_ = NULL; |
||||
return 0; |
||||
} |
||||
*str_ = p; |
||||
return pos; |
||||
} |
||||
size = strlen(p+pos); |
||||
if (size == 0L || (p+pos)[size-1] != '\n') |
||||
{ |
||||
pos += size; |
||||
} |
||||
else |
||||
{ |
||||
pos += size-1L; /* do not include `eol' */ |
||||
*str_ = p; |
||||
return pos; |
||||
} |
||||
} |
||||
} |
||||
|
||||
*str_ = NULL; |
||||
return 0; |
||||
} |
||||
|
||||
THFile *THDiskFile_new(const std::string &name, const char *mode, int isQuiet) |
||||
{ |
||||
static struct THFileVTable vtable = { |
||||
THDiskFile_isOpened, |
||||
|
||||
THDiskFile_readByte, |
||||
THDiskFile_readChar, |
||||
THDiskFile_readShort, |
||||
THDiskFile_readInt, |
||||
THDiskFile_readLong, |
||||
THDiskFile_readFloat, |
||||
THDiskFile_readDouble, |
||||
THDiskFile_readString, |
||||
|
||||
THDiskFile_seek, |
||||
THDiskFile_seekEnd, |
||||
THDiskFile_position, |
||||
THDiskFile_close, |
||||
THDiskFile_free |
||||
}; |
||||
|
||||
int isReadable; |
||||
int isWritable; |
||||
FILE *handle; |
||||
THDiskFile *self; |
||||
|
||||
THArgCheck(THDiskFile_mode(mode, &isReadable, &isWritable), 2, "file mode should be 'r','w' or 'rw'"); |
||||
|
||||
CV_Assert(isReadable && !isWritable); |
||||
|
||||
#ifdef _MSC_VER |
||||
if (fopen_s(&handle, name.c_str(), "rb") != 0) |
||||
handle = NULL; |
||||
#else |
||||
handle = fopen(name.c_str(),"rb"); |
||||
#endif |
||||
|
||||
if(!handle) |
||||
{ |
||||
if(isQuiet) |
||||
return 0; |
||||
else |
||||
THError("cannot open <%s> in mode %c%c", name.c_str(), (isReadable ? 'r' : ' '), (isWritable ? 'w' : ' ')); |
||||
} |
||||
|
||||
self = (THDiskFile*)THAlloc(sizeof(THDiskFile)); |
||||
if (!self) |
||||
THError("cannot allocate memory for self"); |
||||
|
||||
self->handle = handle; |
||||
self->isNativeEncoding = 1; |
||||
self->longSize = 0; |
||||
|
||||
self->file.vtable = &vtable; |
||||
self->file.isQuiet = isQuiet; |
||||
self->file.isReadable = isReadable; |
||||
self->file.isWritable = isWritable; |
||||
self->file.isBinary = 0; |
||||
self->file.isAutoSpacing = 1; |
||||
self->file.hasError = 0; |
||||
|
||||
return (THFile*)self; |
||||
} |
||||
|
||||
} |
||||
@ -1,22 +0,0 @@ |
||||
#ifndef TH_DISK_FILE_INC |
||||
#define TH_DISK_FILE_INC |
||||
|
||||
#include "THFile.h" |
||||
#include <string> |
||||
|
||||
namespace TH |
||||
{ |
||||
|
||||
TH_API THFile *THDiskFile_new(const std::string &name, const char *mode, int isQuiet); |
||||
|
||||
TH_API int THDiskFile_isLittleEndianCPU(void); |
||||
TH_API int THDiskFile_isBigEndianCPU(void); |
||||
TH_API void THDiskFile_nativeEndianEncoding(THFile *self); |
||||
TH_API void THDiskFile_littleEndianEncoding(THFile *self); |
||||
TH_API void THDiskFile_bigEndianEncoding(THFile *self); |
||||
TH_API void THDiskFile_longSize(THFile *self, int size); |
||||
TH_API void THDiskFile_noBuffer(THFile *self); |
||||
|
||||
} // namespace
|
||||
|
||||
#endif |
||||
@ -1,120 +0,0 @@ |
||||
#include "../precomp.hpp" |
||||
#include "THFile.h" |
||||
#include "THFilePrivate.h" |
||||
|
||||
namespace TH { |
||||
|
||||
#define IMPLEMENT_THFILE_RW(TYPEC, TYPE) \ |
||||
long THFile_read##TYPEC##Raw(THFile *self, TYPE *data, long n) \
|
||||
{ \
|
||||
return (*self->vtable->read##TYPEC)(self, data, n); \
|
||||
} |
||||
|
||||
IMPLEMENT_THFILE_RW(Byte, unsigned char) |
||||
IMPLEMENT_THFILE_RW(Char, char) |
||||
IMPLEMENT_THFILE_RW(Short, short) |
||||
IMPLEMENT_THFILE_RW(Int, int) |
||||
IMPLEMENT_THFILE_RW(Long, int64) |
||||
IMPLEMENT_THFILE_RW(Float, float) |
||||
IMPLEMENT_THFILE_RW(Double, double) |
||||
|
||||
long THFile_readStringRaw(THFile *self, const char *format, char **str_) |
||||
{ |
||||
return self->vtable->readString(self, format, str_); |
||||
} |
||||
|
||||
void THFile_seek(THFile *self, long position) |
||||
{ |
||||
self->vtable->seek(self, position); |
||||
} |
||||
|
||||
void THFile_seekEnd(THFile *self) |
||||
{ |
||||
self->vtable->seekEnd(self); |
||||
} |
||||
|
||||
long THFile_position(THFile *self) |
||||
{ |
||||
return self->vtable->position(self); |
||||
} |
||||
|
||||
void THFile_close(THFile *self) |
||||
{ |
||||
self->vtable->close(self); |
||||
} |
||||
|
||||
void THFile_free(THFile *self) |
||||
{ |
||||
self->vtable->free(self); |
||||
} |
||||
|
||||
int THFile_isOpened(THFile *self) |
||||
{ |
||||
return self->vtable->isOpened(self); |
||||
} |
||||
|
||||
#define IMPLEMENT_THFILE_FLAGS(FLAG) \ |
||||
int THFile_##FLAG(THFile *self) \
|
||||
{ \
|
||||
return self->FLAG; \
|
||||
} |
||||
|
||||
IMPLEMENT_THFILE_FLAGS(isQuiet) |
||||
IMPLEMENT_THFILE_FLAGS(isReadable) |
||||
IMPLEMENT_THFILE_FLAGS(isWritable) |
||||
IMPLEMENT_THFILE_FLAGS(isBinary) |
||||
IMPLEMENT_THFILE_FLAGS(isAutoSpacing) |
||||
IMPLEMENT_THFILE_FLAGS(hasError) |
||||
|
||||
void THFile_binary(THFile *self) |
||||
{ |
||||
self->isBinary = 1; |
||||
} |
||||
|
||||
void THFile_ascii(THFile *self) |
||||
{ |
||||
self->isBinary = 0; |
||||
} |
||||
|
||||
void THFile_autoSpacing(THFile *self) |
||||
{ |
||||
self->isAutoSpacing = 1; |
||||
} |
||||
|
||||
void THFile_noAutoSpacing(THFile *self) |
||||
{ |
||||
self->isAutoSpacing = 0; |
||||
} |
||||
|
||||
void THFile_quiet(THFile *self) |
||||
{ |
||||
self->isQuiet = 1; |
||||
} |
||||
|
||||
void THFile_pedantic(THFile *self) |
||||
{ |
||||
self->isQuiet = 0; |
||||
} |
||||
|
||||
void THFile_clearError(THFile *self) |
||||
{ |
||||
self->hasError = 0; |
||||
} |
||||
|
||||
#define IMPLEMENT_THFILE_SCALAR(TYPEC, TYPE) \ |
||||
TYPE THFile_read##TYPEC##Scalar(THFile *self) \
|
||||
{ \
|
||||
TYPE scalar; \
|
||||
THFile_read##TYPEC##Raw(self, &scalar, 1); \
|
||||
return scalar; \
|
||||
} |
||||
|
||||
IMPLEMENT_THFILE_SCALAR(Byte, unsigned char) |
||||
IMPLEMENT_THFILE_SCALAR(Char, char) |
||||
IMPLEMENT_THFILE_SCALAR(Short, short) |
||||
IMPLEMENT_THFILE_SCALAR(Int, int) |
||||
IMPLEMENT_THFILE_SCALAR(Long, int64) |
||||
IMPLEMENT_THFILE_SCALAR(Float, float) |
||||
IMPLEMENT_THFILE_SCALAR(Double, double) |
||||
|
||||
} // namespace
|
||||
@ -1,53 +0,0 @@ |
||||
#ifndef TH_FILE_INC |
||||
#define TH_FILE_INC |
||||
|
||||
//#include "THStorage.h"
|
||||
#include "opencv2/core/hal/interface.h" |
||||
#include "THGeneral.h" |
||||
|
||||
namespace TH |
||||
{ |
||||
typedef struct THFile__ THFile; |
||||
|
||||
TH_API int THFile_isOpened(THFile *self); |
||||
TH_API int THFile_isQuiet(THFile *self); |
||||
TH_API int THFile_isReadable(THFile *self); |
||||
TH_API int THFile_isWritable(THFile *self); |
||||
TH_API int THFile_isBinary(THFile *self); |
||||
TH_API int THFile_isAutoSpacing(THFile *self); |
||||
TH_API int THFile_hasError(THFile *self); |
||||
|
||||
TH_API void THFile_binary(THFile *self); |
||||
TH_API void THFile_ascii(THFile *self); |
||||
TH_API void THFile_autoSpacing(THFile *self); |
||||
TH_API void THFile_noAutoSpacing(THFile *self); |
||||
TH_API void THFile_quiet(THFile *self); |
||||
TH_API void THFile_pedantic(THFile *self); |
||||
TH_API void THFile_clearError(THFile *self); |
||||
|
||||
/* scalar */ |
||||
TH_API unsigned char THFile_readByteScalar(THFile *self); |
||||
TH_API char THFile_readCharScalar(THFile *self); |
||||
TH_API short THFile_readShortScalar(THFile *self); |
||||
TH_API int THFile_readIntScalar(THFile *self); |
||||
TH_API int64 THFile_readLongScalar(THFile *self); |
||||
TH_API float THFile_readFloatScalar(THFile *self); |
||||
TH_API double THFile_readDoubleScalar(THFile *self); |
||||
|
||||
/* raw */ |
||||
TH_API long THFile_readByteRaw(THFile *self, unsigned char *data, long n); |
||||
TH_API long THFile_readCharRaw(THFile *self, char *data, long n); |
||||
TH_API long THFile_readShortRaw(THFile *self, short *data, long n); |
||||
TH_API long THFile_readIntRaw(THFile *self, int *data, long n); |
||||
TH_API long THFile_readLongRaw(THFile *self, int64 *data, long n); |
||||
TH_API long THFile_readFloatRaw(THFile *self, float *data, long n); |
||||
TH_API long THFile_readDoubleRaw(THFile *self, double *data, long n); |
||||
TH_API long THFile_readStringRaw(THFile *self, const char *format, char **str_); /* you must deallocate str_ */ |
||||
|
||||
TH_API void THFile_seek(THFile *self, long position); |
||||
TH_API void THFile_seekEnd(THFile *self); |
||||
TH_API long THFile_position(THFile *self); |
||||
TH_API void THFile_close(THFile *self); |
||||
TH_API void THFile_free(THFile *self); |
||||
} // namespace
|
||||
#endif //TH_FILE_INC
|
||||
@ -1,37 +0,0 @@ |
||||
namespace TH { |
||||
|
||||
struct THFile__ |
||||
{ |
||||
struct THFileVTable *vtable; |
||||
|
||||
int isQuiet; |
||||
int isReadable; |
||||
int isWritable; |
||||
int isBinary; |
||||
int isAutoSpacing; |
||||
int hasError; |
||||
}; |
||||
|
||||
/* virtual table definition */ |
||||
|
||||
struct THFileVTable |
||||
{ |
||||
int (*isOpened)(THFile *self); |
||||
|
||||
long (*readByte)(THFile *self, unsigned char *data, long n); |
||||
long (*readChar)(THFile *self, char *data, long n); |
||||
long (*readShort)(THFile *self, short *data, long n); |
||||
long (*readInt)(THFile *self, int *data, long n); |
||||
long (*readLong)(THFile *self, int64 *data, long n); |
||||
long (*readFloat)(THFile *self, float *data, long n); |
||||
long (*readDouble)(THFile *self, double *data, long n); |
||||
long (*readString)(THFile *self, const char *format, char **str_); |
||||
|
||||
void (*seek)(THFile *self, long position); |
||||
void (*seekEnd)(THFile *self); |
||||
long (*position)(THFile *self); |
||||
void (*close)(THFile *self); |
||||
void (*free)(THFile *self); |
||||
}; |
||||
|
||||
} // namespace
|
||||
@ -1,2 +0,0 @@ |
||||
#include "../precomp.hpp" |
||||
#include "THGeneral.h" |
||||
@ -1,22 +0,0 @@ |
||||
#ifndef TH_GENERAL_INC |
||||
#define TH_GENERAL_INC |
||||
|
||||
#include <stdlib.h> |
||||
#include <stdio.h> |
||||
#include <stdarg.h> |
||||
#include <math.h> |
||||
#include <limits.h> |
||||
#include <float.h> |
||||
#include <time.h> |
||||
#include <string.h> |
||||
|
||||
#define TH_API |
||||
|
||||
#define THError(...) CV_Error(cv::Error::StsError, cv::format(__VA_ARGS__)) |
||||
#define THArgCheck(cond, ...) CV_Assert(cond) |
||||
|
||||
#define THAlloc malloc |
||||
#define THRealloc realloc |
||||
#define THFree free |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -1,140 +0,0 @@ |
||||
import numpy as np |
||||
import sys |
||||
import os |
||||
import fnmatch |
||||
import argparse |
||||
|
||||
try: |
||||
import cv2 as cv |
||||
except ImportError: |
||||
raise ImportError('Can\'t find OpenCV Python module. If you\'ve built it from sources without installation, ' |
||||
'configure environment variable PYTHONPATH to "opencv_build_dir/lib" directory (with "python3" subdirectory if required)') |
||||
try: |
||||
import torch |
||||
except ImportError: |
||||
raise ImportError('Can\'t find pytorch. Please install it by following instructions on the official site') |
||||
|
||||
from torch.utils.serialization import load_lua |
||||
from pascal_semsegm_test_fcn import eval_segm_result, get_conf_mat, get_metrics, DatasetImageFetch, SemSegmEvaluation |
||||
from imagenet_cls_test_alexnet import Framework, DnnCaffeModel |
||||
|
||||
|
||||
class NormalizePreproc: |
||||
def __init__(self): |
||||
pass |
||||
|
||||
@staticmethod |
||||
def process(img): |
||||
image_data = np.array(img).transpose(2, 0, 1).astype(np.float32) |
||||
image_data = np.expand_dims(image_data, 0) |
||||
image_data /= 255.0 |
||||
return image_data |
||||
|
||||
|
||||
class CityscapesDataFetch(DatasetImageFetch): |
||||
img_dir = '' |
||||
segm_dir = '' |
||||
segm_files = [] |
||||
colors = [] |
||||
i = 0 |
||||
|
||||
def __init__(self, img_dir, segm_dir, preproc): |
||||
self.img_dir = img_dir |
||||
self.segm_dir = segm_dir |
||||
self.segm_files = sorted([img for img in self.locate('*_color.png', segm_dir)]) |
||||
self.colors = self.get_colors() |
||||
self.data_prepoc = preproc |
||||
self.i = 0 |
||||
|
||||
@staticmethod |
||||
def get_colors(): |
||||
result = [] |
||||
colors_list = ( |
||||
(0, 0, 0), (128, 64, 128), (244, 35, 232), (70, 70, 70), (102, 102, 156), (190, 153, 153), (153, 153, 153), |
||||
(250, 170, 30), (220, 220, 0), (107, 142, 35), (152, 251, 152), (70, 130, 180), (220, 20, 60), (255, 0, 0), |
||||
(0, 0, 142), (0, 0, 70), (0, 60, 100), (0, 80, 100), (0, 0, 230), (119, 11, 32)) |
||||
|
||||
for c in colors_list: |
||||
result.append(DatasetImageFetch.pix_to_c(c)) |
||||
return result |
||||
|
||||
def __iter__(self): |
||||
return self |
||||
|
||||
def next(self): |
||||
if self.i < len(self.segm_files): |
||||
segm_file = self.segm_files[self.i] |
||||
segm = cv.imread(segm_file, cv.IMREAD_COLOR)[:, :, ::-1] |
||||
segm = cv.resize(segm, (1024, 512), interpolation=cv.INTER_NEAREST) |
||||
|
||||
img_file = self.rreplace(self.img_dir + segm_file[len(self.segm_dir):], 'gtFine_color', 'leftImg8bit') |
||||
assert os.path.exists(img_file) |
||||
img = cv.imread(img_file, cv.IMREAD_COLOR)[:, :, ::-1] |
||||
img = cv.resize(img, (1024, 512)) |
||||
|
||||
self.i += 1 |
||||
gt = self.color_to_gt(segm, self.colors) |
||||
img = self.data_prepoc.process(img) |
||||
return img, gt |
||||
else: |
||||
self.i = 0 |
||||
raise StopIteration |
||||
|
||||
def get_num_classes(self): |
||||
return len(self.colors) |
||||
|
||||
@staticmethod |
||||
def locate(pattern, root_path): |
||||
for path, dirs, files in os.walk(os.path.abspath(root_path)): |
||||
for filename in fnmatch.filter(files, pattern): |
||||
yield os.path.join(path, filename) |
||||
|
||||
@staticmethod |
||||
def rreplace(s, old, new, occurrence=1): |
||||
li = s.rsplit(old, occurrence) |
||||
return new.join(li) |
||||
|
||||
|
||||
class TorchModel(Framework): |
||||
net = object |
||||
|
||||
def __init__(self, model_file): |
||||
self.net = load_lua(model_file) |
||||
|
||||
def get_name(self): |
||||
return 'Torch' |
||||
|
||||
def get_output(self, input_blob): |
||||
tensor = torch.FloatTensor(input_blob) |
||||
out = self.net.forward(tensor).numpy() |
||||
return out |
||||
|
||||
|
||||
class DnnTorchModel(DnnCaffeModel): |
||||
net = cv.dnn.Net() |
||||
|
||||
def __init__(self, model_file): |
||||
self.net = cv.dnn.readNetFromTorch(model_file) |
||||
|
||||
def get_output(self, input_blob): |
||||
self.net.setBlob("", input_blob) |
||||
self.net.forward() |
||||
return self.net.getBlob(self.net.getLayerNames()[-1]) |
||||
|
||||
if __name__ == "__main__": |
||||
parser = argparse.ArgumentParser() |
||||
parser.add_argument("--imgs_dir", help="path to Cityscapes validation images dir, imgsfine/leftImg8bit/val") |
||||
parser.add_argument("--segm_dir", help="path to Cityscapes dir with segmentation, gtfine/gtFine/val") |
||||
parser.add_argument("--model", help="path to torch model, download it here: " |
||||
"https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa") |
||||
parser.add_argument("--log", help="path to logging file") |
||||
args = parser.parse_args() |
||||
|
||||
prep = NormalizePreproc() |
||||
df = CityscapesDataFetch(args.imgs_dir, args.segm_dir, prep) |
||||
|
||||
fw = [TorchModel(args.model), |
||||
DnnTorchModel(args.model)] |
||||
|
||||
segm_eval = SemSegmEvaluation(args.log) |
||||
segm_eval.process(fw, df) |
||||
@ -1,664 +0,0 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp" |
||||
#include "npy_blob.hpp" |
||||
#include <opencv2/dnn/shape_utils.hpp> |
||||
#include <opencv2/dnn/layer.details.hpp> // CV_DNN_REGISTER_LAYER_CLASS |
||||
|
||||
namespace opencv_test |
||||
{ |
||||
|
||||
using namespace std; |
||||
using namespace testing; |
||||
using namespace cv; |
||||
using namespace cv::dnn; |
||||
|
||||
template<typename TStr> |
||||
static std::string _tf(TStr filename, bool inTorchDir = true, bool required = true) |
||||
{ |
||||
String path = "dnn/"; |
||||
if (inTorchDir) |
||||
path += "torch/"; |
||||
path += filename; |
||||
return findDataFile(path, required); |
||||
} |
||||
|
||||
TEST(Torch_Importer, simple_read) |
||||
{ |
||||
Net net; |
||||
ASSERT_NO_THROW(net = readNetFromTorch(_tf("net_simple_net.txt"), false)); |
||||
ASSERT_FALSE(net.empty()); |
||||
} |
||||
|
||||
class Test_Torch_layers : public DNNTestLayer |
||||
{ |
||||
public: |
||||
void runTorchNet(const String& prefix, String outLayerName = "", |
||||
bool check2ndBlob = false, bool isBinary = false, bool evaluate = true, |
||||
double l1 = 0.0, double lInf = 0.0) |
||||
{ |
||||
String suffix = (isBinary) ? ".dat" : ".txt"; |
||||
|
||||
Mat inp, outRef; |
||||
ASSERT_NO_THROW( inp = readTorchBlob(_tf(prefix + "_input" + suffix), isBinary) ); |
||||
ASSERT_NO_THROW( outRef = readTorchBlob(_tf(prefix + "_output" + suffix), isBinary) ); |
||||
|
||||
checkBackend(backend, target, &inp, &outRef); |
||||
|
||||
Net net = readNetFromTorch(_tf(prefix + "_net" + suffix), isBinary, evaluate); |
||||
ASSERT_FALSE(net.empty()); |
||||
|
||||
net.setPreferableBackend(backend); |
||||
net.setPreferableTarget(target); |
||||
|
||||
if (outLayerName.empty()) |
||||
outLayerName = net.getLayerNames().back(); |
||||
|
||||
net.setInput(inp); |
||||
std::vector<Mat> outBlobs; |
||||
net.forward(outBlobs, outLayerName); |
||||
l1 = l1 ? l1 : default_l1; |
||||
lInf = lInf ? lInf : default_lInf; |
||||
normAssert(outRef, outBlobs[0], "", l1, lInf); |
||||
|
||||
if (check2ndBlob && backend == DNN_BACKEND_OPENCV) |
||||
{ |
||||
Mat out2 = outBlobs[1]; |
||||
Mat ref2 = readTorchBlob(_tf(prefix + "_output_2" + suffix), isBinary); |
||||
normAssert(out2, ref2, "", l1, lInf); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
TEST_P(Test_Torch_layers, run_convolution) |
||||
{ |
||||
// Output reference values are in range [23.4018, 72.0181]
|
||||
double l1 = default_l1, lInf = default_lInf; |
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD || target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
l1 = 0.08; |
||||
lInf = 0.43; |
||||
} |
||||
else if (target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
l1 = 0.08; |
||||
lInf = 0.5; |
||||
} |
||||
runTorchNet("net_conv", "", false, true, true, l1, lInf); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_pool_max) |
||||
{ |
||||
if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); |
||||
if (target == DNN_TARGET_CUDA_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA_FP16); |
||||
if (target == DNN_TARGET_CPU_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); |
||||
double l1 = 0.0, lInf = 0.0; |
||||
runTorchNet("net_pool_max", "", true, false, true, l1, lInf); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_pool_ave) |
||||
{ |
||||
runTorchNet("net_pool_ave"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_reshape_change_batch_size) |
||||
{ |
||||
runTorchNet("net_reshape"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_reshape) |
||||
{ |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
runTorchNet("net_reshape_batch"); |
||||
runTorchNet("net_reshape_channels", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_reshape_single_sample) |
||||
{ |
||||
// Reference output values in range [14.4586, 18.4492].
|
||||
double l1 = default_l1, lInf = default_lInf; |
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD || target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
l1 = 0.033; |
||||
lInf = 0.05; |
||||
} |
||||
else if (target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
l1 = 0.02; |
||||
lInf = 0.04; |
||||
} |
||||
runTorchNet("net_reshape_single_sample", "", false, false, true, l1, lInf); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_linear) |
||||
{ |
||||
if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16); |
||||
if (target == DNN_TARGET_CPU_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); |
||||
runTorchNet("net_linear_2d"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_concat) |
||||
{ |
||||
runTorchNet("net_concat", "l5_torchMerge"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_depth_concat) |
||||
{ |
||||
double lInf = 0.0; |
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD || target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
lInf = 0.032; |
||||
} |
||||
else if (target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
lInf = 0.03; |
||||
} |
||||
runTorchNet("net_depth_concat", "", false, true, true, 0.0, lInf); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_deconv) |
||||
{ |
||||
runTorchNet("net_deconv"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_batch_norm) |
||||
{ |
||||
runTorchNet("net_batch_norm", "", false, true); |
||||
runTorchNet("net_batch_norm_train", "", false, true, false); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_prelu) |
||||
{ |
||||
runTorchNet("net_prelu"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_cadd_table) |
||||
{ |
||||
runTorchNet("net_cadd_table"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_softmax) |
||||
{ |
||||
runTorchNet("net_softmax"); |
||||
runTorchNet("net_softmax_spatial"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_logsoftmax) |
||||
{ |
||||
runTorchNet("net_logsoftmax"); |
||||
runTorchNet("net_logsoftmax_spatial"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_lp_pooling_square) |
||||
{ |
||||
runTorchNet("net_lp_pooling_square", "", false, true); |
||||
} |
||||
TEST_P(Test_Torch_layers, net_lp_pooling_power) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION); |
||||
#endif |
||||
runTorchNet("net_lp_pooling_power", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_conv_gemm_lrn) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
#endif |
||||
double l1 = 0.0, lInf = 0.0; |
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
l1 = 0.046; |
||||
lInf = 0.023; |
||||
} |
||||
else if (target == DNN_TARGET_MYRIAD) |
||||
{ |
||||
l1 = 0.02; |
||||
lInf = 0.05; |
||||
} |
||||
else if (target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
l1 = 0.0042; |
||||
lInf = 0.021; |
||||
} |
||||
// The OpenCL kernels use the native_ math functions which have
|
||||
// implementation defined accuracy, so we use relaxed thresholds. See
|
||||
// https://github.com/opencv/opencv/issues/9821 for more details.
|
||||
else if (target == DNN_TARGET_OPENCL) |
||||
{ |
||||
l1 = 0.02; |
||||
lInf = 0.02; |
||||
} |
||||
runTorchNet("net_conv_gemm_lrn", "", false, true, true, l1, lInf); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_inception_block) |
||||
{ |
||||
runTorchNet("net_inception_block", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_normalize) |
||||
{ |
||||
if(backend == DNN_BACKEND_CUDA) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); /* only L1 and L2 norms are supported */ |
||||
|
||||
runTorchNet("net_normalize", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_padding) |
||||
{ |
||||
runTorchNet("net_padding", "", false, true); |
||||
runTorchNet("net_spatial_zero_padding", "", false, true); |
||||
runTorchNet("net_spatial_reflection_padding", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_non_spatial) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && ( \ |
||||
INF_ENGINE_VER_MAJOR_EQ(2021030000) || \
|
||||
INF_ENGINE_VER_MAJOR_EQ(2021040000) \
|
||||
) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) |
||||
// 2021.3: crash
|
||||
// 2021.4: [ GENERAL_ERROR ] AssertionFailed: !out.networkInputs.empty()
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); // exception
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); // exception
|
||||
#endif |
||||
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && |
||||
(target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)) |
||||
applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, |
||||
CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION); |
||||
runTorchNet("net_non_spatial", "", false, true); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, run_paralel) |
||||
{ |
||||
if (backend != DNN_BACKEND_OPENCV || target != DNN_TARGET_CPU) |
||||
throw SkipTestException(""); // TODO: Check this
|
||||
runTorchNet("net_parallel", "l5_torchMerge"); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_layers, net_residual) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000 |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && (target == DNN_TARGET_OPENCL || |
||||
target == DNN_TARGET_OPENCL_FP16)) |
||||
applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, |
||||
CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION); |
||||
#endif |
||||
runTorchNet("net_residual", "", false, true); |
||||
} |
||||
|
||||
class Test_Torch_nets : public DNNTestLayer {}; |
||||
|
||||
TEST_P(Test_Torch_nets, OpenFace_accuracy) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2018050000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
#endif |
||||
checkBackend(); |
||||
|
||||
const string model = findDataFile("dnn/openface_nn4.small2.v1.t7", false); |
||||
Net net = readNetFromTorch(model); |
||||
|
||||
net.setPreferableBackend(backend); |
||||
net.setPreferableTarget(target); |
||||
|
||||
Mat sample = imread(findDataFile("cv/shared/lena.png")); |
||||
Mat sampleF32(sample.size(), CV_32FC3); |
||||
sample.convertTo(sampleF32, sampleF32.type()); |
||||
sampleF32 /= 255; |
||||
resize(sampleF32, sampleF32, Size(96, 96), 0, 0, INTER_NEAREST); |
||||
|
||||
Mat inputBlob = blobFromImage(sampleF32, 1.0, Size(), Scalar(), /*swapRB*/true); |
||||
|
||||
net.setInput(inputBlob); |
||||
Mat out = net.forward(); |
||||
|
||||
// Reference output values are in range [-0.17212, 0.263492]
|
||||
// on Myriad problem layer: l4_Pooling - does not use pads_begin
|
||||
float l1 = 1e-5, lInf = 1e-3; |
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD || target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
l1 = 2e-3; |
||||
lInf = 5e-3; |
||||
} |
||||
else if (target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
l1 = 0.0004; |
||||
lInf = 0.0012; |
||||
} |
||||
Mat outRef = readTorchBlob(_tf("net_openface_output.dat"), true); |
||||
normAssert(out, outRef, "", l1, lInf); |
||||
} |
||||
|
||||
static Mat getSegmMask(const Mat& scores) |
||||
{ |
||||
const int rows = scores.size[2]; |
||||
const int cols = scores.size[3]; |
||||
const int numClasses = scores.size[1]; |
||||
|
||||
Mat maxCl = Mat::zeros(rows, cols, CV_8UC1); |
||||
Mat maxVal(rows, cols, CV_32FC1, Scalar(0)); |
||||
for (int ch = 0; ch < numClasses; ch++) |
||||
{ |
||||
for (int row = 0; row < rows; row++) |
||||
{ |
||||
const float *ptrScore = scores.ptr<float>(0, ch, row); |
||||
uint8_t *ptrMaxCl = maxCl.ptr<uint8_t>(row); |
||||
float *ptrMaxVal = maxVal.ptr<float>(row); |
||||
for (int col = 0; col < cols; col++) |
||||
{ |
||||
if (ptrScore[col] > ptrMaxVal[col]) |
||||
{ |
||||
ptrMaxVal[col] = ptrScore[col]; |
||||
ptrMaxCl[col] = (uchar)ch; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return maxCl; |
||||
} |
||||
|
||||
// Computer per-class intersection over union metric.
|
||||
static void normAssertSegmentation(const Mat& ref, const Mat& test) |
||||
{ |
||||
CV_Assert_N(ref.dims == 4, test.dims == 4); |
||||
const int numClasses = ref.size[1]; |
||||
CV_Assert(numClasses == test.size[1]); |
||||
|
||||
Mat refMask = getSegmMask(ref); |
||||
Mat testMask = getSegmMask(test); |
||||
EXPECT_EQ(countNonZero(refMask != testMask), 0); |
||||
} |
||||
|
||||
TEST_P(Test_Torch_nets, ENet_accuracy) |
||||
{ |
||||
applyTestTag(target == DNN_TARGET_CPU ? "" : CV_TEST_TAG_MEMORY_512MB); |
||||
checkBackend(); |
||||
if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) |
||||
throw SkipTestException(""); |
||||
if (backend == DNN_BACKEND_CUDA && target == DNN_TARGET_CUDA_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA_FP16); |
||||
if (target == DNN_TARGET_CPU_FP16) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_CPU_FP16); |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020010000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION); |
||||
#else |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU) |
||||
{ |
||||
if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
if (target == DNN_TARGET_OPENCL) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
throw SkipTestException(""); |
||||
} |
||||
#endif |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2023000000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
#endif |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU) |
||||
{ |
||||
if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
if (target == DNN_TARGET_OPENCL) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
throw SkipTestException(""); |
||||
} |
||||
|
||||
Net net; |
||||
{ |
||||
const string model = findDataFile("dnn/Enet-model-best.net", false); |
||||
net = readNetFromTorch(model, true); |
||||
ASSERT_TRUE(!net.empty()); |
||||
} |
||||
|
||||
net.enableWinograd(false); |
||||
net.setPreferableBackend(backend); |
||||
net.setPreferableTarget(target); |
||||
|
||||
Mat sample = imread(_tf("street.png", false)); |
||||
Mat inputBlob = blobFromImage(sample, 1./255, Size(), Scalar(), /*swapRB*/true); |
||||
|
||||
net.setInput(inputBlob, ""); |
||||
Mat out = net.forward(); |
||||
Mat ref = blobFromNPY(_tf("torch_enet_prob.npy", false)); |
||||
// Due to numerical instability in Pooling-Unpooling layers (indexes jittering)
|
||||
// thresholds for ENet must be changed. Accuracy of results was checked on
|
||||
// Cityscapes dataset and difference in mIOU with Torch is 10E-4%
|
||||
normAssert(ref, out, "", 0.0005, /*target == DNN_TARGET_CPU ? 0.453 : */0.552); |
||||
normAssertSegmentation(ref, out); |
||||
|
||||
const int N = 3; |
||||
for (int i = 0; i < N; i++) |
||||
{ |
||||
net.setInput(inputBlob, ""); |
||||
Mat out = net.forward(); |
||||
normAssert(ref, out, "", 0.0005, /*target == DNN_TARGET_CPU ? 0.453 : */0.552); |
||||
normAssertSegmentation(ref, out); |
||||
} |
||||
} |
||||
|
||||
// Check accuracy of style transfer models from https://github.com/jcjohnson/fast-neural-style
|
||||
// th fast_neural_style.lua \
|
||||
// -input_image ~/opencv_extra/testdata/dnn/googlenet_1.png \
|
||||
// -output_image lena.png \
|
||||
// -median_filter 0 \
|
||||
// -image_size 0 \
|
||||
// -model models/eccv16/starry_night.t7
|
||||
// th fast_neural_style.lua \
|
||||
// -input_image ~/opencv_extra/testdata/dnn/googlenet_1.png \
|
||||
// -output_image lena.png \
|
||||
// -median_filter 0 \
|
||||
// -image_size 0 \
|
||||
// -model models/instance_norm/feathers.t7
|
||||
TEST_P(Test_Torch_nets, FastNeuralStyle_accuracy) |
||||
{ |
||||
#if defined INF_ENGINE_RELEASE |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD |
||||
&& getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER); |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD |
||||
&& getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); |
||||
#endif |
||||
|
||||
checkBackend(); |
||||
|
||||
#if defined(INF_ENGINE_RELEASE) |
||||
#if INF_ENGINE_RELEASE <= 2018050000 |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_OPENCL) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION); |
||||
#endif |
||||
#endif |
||||
|
||||
std::string models[] = {"dnn/fast_neural_style_eccv16_starry_night.t7", |
||||
"dnn/fast_neural_style_instance_norm_feathers.t7"}; |
||||
std::string targets[] = {"dnn/lena_starry_night.png", "dnn/lena_feathers.png"}; |
||||
|
||||
for (int i = 0; i < 2; ++i) |
||||
{ |
||||
const string model = findDataFile(models[i], false); |
||||
Net net = readNetFromTorch(model); |
||||
|
||||
net.setPreferableBackend(backend); |
||||
net.setPreferableTarget(target); |
||||
|
||||
Mat img = imread(findDataFile("dnn/googlenet_1.png")); |
||||
Mat inputBlob = blobFromImage(img, 1.0, Size(), Scalar(103.939, 116.779, 123.68), false); |
||||
|
||||
net.setInput(inputBlob); |
||||
Mat out = net.forward(); |
||||
|
||||
// Deprocessing.
|
||||
getPlane(out, 0, 0) += 103.939; |
||||
getPlane(out, 0, 1) += 116.779; |
||||
getPlane(out, 0, 2) += 123.68; |
||||
out = cv::min(cv::max(0, out), 255); |
||||
|
||||
Mat ref = imread(findDataFile(targets[i])); |
||||
Mat refBlob = blobFromImage(ref, 1.0, Size(), Scalar(), false); |
||||
|
||||
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) |
||||
{ |
||||
double normL1 = cvtest::norm(refBlob, out, cv::NORM_L1) / refBlob.total(); |
||||
if (target == DNN_TARGET_MYRIAD) |
||||
EXPECT_LE(normL1, 4.0f); |
||||
else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16) |
||||
EXPECT_LE(normL1, 1.0f); |
||||
else |
||||
EXPECT_LE(normL1, 0.6f); |
||||
} |
||||
else if(target == DNN_TARGET_CUDA_FP16) |
||||
{ |
||||
normAssert(out, refBlob, "", 0.6, 26); |
||||
} |
||||
else if (target == DNN_TARGET_CPU_FP16) |
||||
{ |
||||
normAssert(out, refBlob, "", 0.62, 25); |
||||
} |
||||
else |
||||
normAssert(out, refBlob, "", 0.5, 1.11); |
||||
} |
||||
} |
||||
|
||||
INSTANTIATE_TEST_CASE_P(/**/, Test_Torch_nets, dnnBackendsAndTargets()); |
||||
|
||||
// Test a custom layer
|
||||
// https://github.com/torch/nn/blob/master/doc/convolution.md#nn.SpatialUpSamplingNearest
|
||||
class SpatialUpSamplingNearestLayer CV_FINAL : public Layer |
||||
{ |
||||
public: |
||||
SpatialUpSamplingNearestLayer(const LayerParams ¶ms) : Layer(params) |
||||
{ |
||||
scale = params.get<int>("scale_factor"); |
||||
} |
||||
|
||||
static Ptr<Layer> create(LayerParams& params) |
||||
{ |
||||
return Ptr<Layer>(new SpatialUpSamplingNearestLayer(params)); |
||||
} |
||||
|
||||
virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs, |
||||
const int requiredOutputs, |
||||
std::vector<std::vector<int> > &outputs, |
||||
std::vector<std::vector<int> > &internals) const CV_OVERRIDE |
||||
{ |
||||
std::vector<int> outShape(4); |
||||
outShape[0] = inputs[0][0]; // batch size
|
||||
outShape[1] = inputs[0][1]; // number of channels
|
||||
outShape[2] = scale * inputs[0][2]; |
||||
outShape[3] = scale * inputs[0][3]; |
||||
outputs.assign(1, outShape); |
||||
return false; |
||||
} |
||||
|
||||
void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays) CV_OVERRIDE |
||||
{ |
||||
CV_TRACE_FUNCTION(); |
||||
CV_TRACE_ARG_VALUE(name, "name", name.c_str()); |
||||
|
||||
std::vector<Mat> inputs, outputs; |
||||
inputs_arr.getMatVector(inputs); |
||||
outputs_arr.getMatVector(outputs); |
||||
|
||||
Mat& inp = inputs[0]; |
||||
Mat& out = outputs[0]; |
||||
const int outHeight = out.size[2]; |
||||
const int outWidth = out.size[3]; |
||||
for (size_t n = 0; n < inp.size[0]; ++n) |
||||
{ |
||||
for (size_t ch = 0; ch < inp.size[1]; ++ch) |
||||
{ |
||||
resize(getPlane(inp, n, ch), getPlane(out, n, ch), |
||||
Size(outWidth, outHeight), 0, 0, INTER_NEAREST); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private: |
||||
int scale; |
||||
}; |
||||
|
||||
TEST_P(Test_Torch_layers, upsampling_nearest) |
||||
{ |
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000) |
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD) |
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH); // TODO
|
||||
#endif |
||||
|
||||
// Test a custom layer.
|
||||
CV_DNN_REGISTER_LAYER_CLASS(SpatialUpSamplingNearest, SpatialUpSamplingNearestLayer); |
||||
try |
||||
{ |
||||
runTorchNet("net_spatial_upsampling_nearest", "", false, true); |
||||
} |
||||
catch (...) |
||||
{ |
||||
LayerFactory::unregisterLayer("SpatialUpSamplingNearest"); |
||||
throw; |
||||
} |
||||
LayerFactory::unregisterLayer("SpatialUpSamplingNearest"); |
||||
|
||||
// Test an implemented layer.
|
||||
runTorchNet("net_spatial_upsampling_nearest", "", false, true); |
||||
} |
||||
|
||||
INSTANTIATE_TEST_CASE_P(/**/, Test_Torch_layers, dnnBackendsAndTargets()); |
||||
|
||||
} |
||||
Loading…
Reference in new issue