From 52d50c45447a467d9369e9c5f339323e1201b553 Mon Sep 17 00:00:00 2001 From: ChrisKong <609027949@qq.com> Date: Mon, 30 Dec 2019 16:05:49 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E6=88=90=E5=9F=BA=E6=9C=AC=E5=8A=9F?= =?UTF-8?q?=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 完成基本功能c Co-Authored-By: Chris Kong <609027949@qq.com> --- result.jpg | Bin 18163 -> 7914 bytes src/facenet.cpp | 1869 +++++++++++++++++++++++++---------------------- src/facenet.h | 13 +- src/network.cpp | 229 ++++-- src/network.h | 22 +- src/pBox.cpp | 10 +- src/pBox.h | 42 +- src/pikaqiu.cpp | 56 +- 8 files changed, 1228 insertions(+), 1013 deletions(-) diff --git a/result.jpg b/result.jpg index 5f3a47d41eb9ff9fe84621dd39cd944e9b68342e..4f9b867719235e70b598f90f3f0f079216e1205e 100644 GIT binary patch delta 7365 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 delta 17695 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, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_var->pdata, conv5_mean->pdata, conv5_beta->pdata, \ + conv6_wb->pdata, conv6_var->pdata, conv6_mean->pdata, conv6_beta->pdata}; + string filename = "../model_" + to_string(Num) + "/stem_list.txt"; + readData(filename, dataNumber, pointTeam, 24); + +// if (firstFlag) { + image2MatrixInit(image, rgb); + image2Matrix(image, rgb, 1); + + convolutionInit(conv1_wb, rgb, conv1_out); + //conv1 149 x 149 x 32 + convolution(conv1_wb, rgb, conv1_out); +// printData(conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); +// printData(conv1_out); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, conv1_out, conv2_out); + //conv2 147 x 147 x 32 + convolution(conv2_wb, conv1_out, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 147 x 147 x 64 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + maxPoolingInit(conv3_out, pooling1_out, 3, 2); + //maxPooling 73 x 73 x 64 + maxPooling(conv3_out, pooling1_out, 3, 2); + + convolutionInit(conv4_wb, pooling1_out, conv4_out); + //conv4 73 x 73 x 80 + convolution(conv4_wb, pooling1_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + + convolutionInit(conv5_wb, conv4_out, conv5_out); + //conv5 71 x 71 x 192 + convolution(conv5_wb, conv4_out, conv5_out); + BatchNorm(conv5_out, conv5_var, conv5_mean, conv5_beta); + relu(conv5_out, conv5_wb->pbias); + + + convolutionInit(conv6_wb, conv5_out, output); + //conv6 35 x 35 x 256 + convolution(conv6_wb, conv5_out, output); + BatchNorm(output, conv6_var, conv6_mean, conv6_beta); + relu(output, conv6_wb->pbias); +// firstFlag = false; +// } + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(pooling1_out); + + freepBox(rgb); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + freeWeight(conv6_wb); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); + + freeBN(conv5_var); + freeBN(conv5_mean); + freeBN(conv5_beta); + + freeBN(conv6_var); + freeBN(conv6_mean); + freeBN(conv6_beta); +} + +void facenet::Inception_resnet_A(pBox *input, pBox *output, string filepath, float scale) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + pBox *conv5_out = new pBox; + pBox *conv6_out = new pBox; + pBox *conv7_out = new pBox; + pBox *conv8_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + struct Weight *conv5_wb = new Weight; + struct Weight *conv6_wb = new Weight; + struct Weight *conv7_wb = new Weight; + struct Weight *conv8_wb = new Weight; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + + struct BN *conv5_var = new BN; + struct BN *conv5_mean = new BN; + struct BN *conv5_beta = new BN; + + struct BN *conv6_var = new BN; + struct BN *conv6_mean = new BN; + struct BN *conv6_beta = new BN; + + + long conv1 = ConvAndFcInit(conv1_wb, 32, 256, 1, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 32); + + long conv2 = ConvAndFcInit(conv2_wb, 32, 256, 1, 1, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 32); + long conv3 = ConvAndFcInit(conv3_wb, 32, 32, 3, 1, 1); + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 32); + + long conv4 = ConvAndFcInit(conv4_wb, 32, 256, 1, 1, 0); + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 32); + long conv5 = ConvAndFcInit(conv5_wb, 32, 32, 3, 1, 1); + BatchNormInit(conv5_var, conv5_mean, conv5_beta, 32); + long conv6 = ConvAndFcInit(conv6_wb, 32, 32, 3, 1, 1); + BatchNormInit(conv6_var, conv6_mean, conv6_beta, 32); + + long conv7 = ConvAndFcInit(conv7_wb, 256, 96, 1, 1, 0); + + long conv8 = ConvAndFcInit(conv8_wb, 256, 0, 0, 0, 0); + + long dataNumber[28] = {conv1, 32, 32, 32, conv2, 32, 32, 32, conv3, 32, 32, 32, conv4, 32, 32, 32, + conv5, 32, 32, 32, conv6, 32, 32, 32, conv7, 256, conv8, 0}; + + mydataFmt *pointTeam[28] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_var->pdata, conv5_mean->pdata, conv5_beta->pdata, \ + conv6_wb->pdata, conv6_var->pdata, conv6_mean->pdata, conv6_beta->pdata, \ + conv7_wb->pdata, conv7_wb->pbias, \ + conv8_wb->pdata, conv8_wb->pbias}; + + readData(filepath, dataNumber, pointTeam, 28); + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 35 x 35 x 32 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, input, conv2_out); + //conv2 35 x 35 x 32 + convolution(conv2_wb, input, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 35 x 35 x 32 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + convolutionInit(conv4_wb, input, conv4_out); + //conv4 35 x 35 x 32 + convolution(conv4_wb, input, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + convolutionInit(conv5_wb, conv4_out, conv5_out); + //conv5 35 x 35 x 32 + convolution(conv5_wb, conv4_out, conv5_out); + BatchNorm(conv5_out, conv5_var, conv5_mean, conv5_beta); + relu(conv5_out, conv5_wb->pbias); + convolutionInit(conv6_wb, conv5_out, conv6_out); + //conv6 35 x 35 x 32 + convolution(conv6_wb, conv5_out, conv6_out); + BatchNorm(conv6_out, conv6_var, conv6_mean, conv6_beta); + relu(conv6_out, conv6_wb->pbias); + + conv_mergeInit(conv7_out, conv1_out, conv3_out, conv6_out); + //35 × 35 × 96 + conv_merge(conv7_out, conv1_out, conv3_out, conv6_out); + + convolutionInit(conv7_wb, conv7_out, conv8_out); + //35*35*256 + convolution(conv7_wb, conv7_out, conv8_out); + addbias(conv8_out, conv7_wb->pbias); + + mulandaddInit(input, conv8_out, output, scale); + mulandadd(input, conv8_out, output, scale); + relu(output, conv8_wb->pbias); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(conv6_out); + freepBox(conv7_out); + freepBox(conv8_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + freeWeight(conv6_wb); + freeWeight(conv7_wb); + freeWeight(conv8_wb); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); + + freeBN(conv5_var); + freeBN(conv5_mean); + freeBN(conv5_beta); + + freeBN(conv6_var); + freeBN(conv6_mean); + freeBN(conv6_beta); +} + +void facenet::Reduction_A(pBox *input, pBox *output) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + + struct pBox *pooling1_out = new pBox; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + + + long conv1 = ConvAndFcInit(conv1_wb, 384, 256, 3, 2, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 384); + + long conv2 = ConvAndFcInit(conv2_wb, 192, 256, 1, 1, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 192); + long conv3 = ConvAndFcInit(conv3_wb, 192, 192, 3, 1, 0); + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 192); + long conv4 = ConvAndFcInit(conv4_wb, 256, 192, 3, 2, 0); + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 256); + long dataNumber[16] = {conv1, 384, 384, 384, conv2, 192, 192, 192, conv3, 192, 192, 192, conv4, 256, 256, 256}; + + mydataFmt *pointTeam[16] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata}; + string filename = "../model_" + to_string(Num) + "/Mixed_6a_list.txt"; + readData(filename, dataNumber, pointTeam, 16); + + maxPoolingInit(input, pooling1_out, 3, 2); + // 17*17*256 + maxPooling(input, pooling1_out, 3, 2); + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 17 x 17 x 384 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, input, conv2_out); + //conv2 35 x 35 x 192 + convolution(conv2_wb, input, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 35 x 35 x 192 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + convolutionInit(conv4_wb, conv3_out, conv4_out); + //conv4 17 x 17 x 256 + convolution(conv4_wb, conv3_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + conv_mergeInit(output, pooling1_out, conv1_out, conv4_out); + //17×17×896 + conv_merge(output, pooling1_out, conv1_out, conv4_out); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + + freepBox(pooling1_out); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); +} + +void facenet::Inception_resnet_B(pBox *input, pBox *output, string filepath, float scale) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + pBox *conv5_out = new pBox; + pBox *conv6_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + struct Weight *conv5_wb = new Weight; + struct Weight *conv6_wb = new Weight; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + + + long conv1 = ConvAndFcInit(conv1_wb, 128, 896, 1, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 128); + + long conv2 = ConvAndFcInit(conv2_wb, 128, 896, 1, 1, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 128); + long conv3 = ConvAndFcInit(conv3_wb, 128, 128, 0, 1, -1, 7, 1, 3, 0);//[1,7] + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 128); + long conv4 = ConvAndFcInit(conv4_wb, 128, 128, 0, 1, -1, 1, 7, 0, 3);//[7,1] + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 128); + + long conv5 = ConvAndFcInit(conv5_wb, 896, 256, 1, 1, 0); + + long conv6 = ConvAndFcInit(conv6_wb, 896, 0, 0, 0, 0); + + long dataNumber[20] = {conv1, 128, 128, 128, conv2, 128, 128, 128, conv3, 128, 128, 128, conv4, 128, 128, 128, + conv5, 896, conv6, 0}; + + mydataFmt *pointTeam[20] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_wb->pbias, \ + conv6_wb->pdata, conv6_wb->pbias}; + + + readData(filepath, dataNumber, pointTeam, 20); + + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 17*17*128 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, input, conv2_out); + //conv2 17*17*128 + convolution(conv2_wb, input, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 17*17*128 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + convolutionInit(conv4_wb, conv3_out, conv4_out); + //conv4 17*17*128 + convolution(conv4_wb, conv3_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + + conv_mergeInit(conv5_out, conv1_out, conv4_out); + //17*17*256 + conv_merge(conv5_out, conv1_out, conv4_out); + + convolutionInit(conv5_wb, conv5_out, conv6_out); + //conv5 17*17*896 + convolution(conv5_wb, conv5_out, conv6_out); + addbias(conv6_out, conv5_wb->pbias); + + mulandaddInit(input, conv6_out, output, scale); + mulandadd(input, conv6_out, output, scale); + relu(output, conv6_wb->pbias); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(conv6_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + freeWeight(conv6_wb); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); +} + +void facenet::Reduction_B(pBox *input, pBox *output) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + pBox *conv5_out = new pBox; + pBox *conv6_out = new pBox; + pBox *conv7_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + struct Weight *conv5_wb = new Weight; + struct Weight *conv6_wb = new Weight; + struct Weight *conv7_wb = new Weight; + + struct pBox *pooling1_out = new pBox; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + struct BN *conv5_var = new BN; + struct BN *conv5_mean = new BN; + struct BN *conv5_beta = new BN; + struct BN *conv6_var = new BN; + struct BN *conv6_mean = new BN; + struct BN *conv6_beta = new BN; + struct BN *conv7_var = new BN; + struct BN *conv7_mean = new BN; + struct BN *conv7_beta = new BN; + + + long conv1 = ConvAndFcInit(conv1_wb, 256, 896, 1, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 256); + long conv2 = ConvAndFcInit(conv2_wb, 384, 256, 3, 2, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 384); + + long conv3 = ConvAndFcInit(conv3_wb, 256, 896, 1, 1, 0); + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 256); + long conv4 = ConvAndFcInit(conv4_wb, 256, 256, 3, 2, 0); + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 256); + + long conv5 = ConvAndFcInit(conv5_wb, 256, 896, 1, 1, 0); + BatchNormInit(conv5_var, conv5_mean, conv5_beta, 256); + long conv6 = ConvAndFcInit(conv6_wb, 256, 256, 3, 1, 1); + BatchNormInit(conv6_var, conv6_mean, conv6_beta, 256); + long conv7 = ConvAndFcInit(conv7_wb, 256, 256, 3, 2, 0); + BatchNormInit(conv7_var, conv7_mean, conv7_beta, 256); + + long dataNumber[28] = {conv1, 256, 256, 256, conv2, 384, 384, 384, conv3, 256, 256, 256, conv4, 256, 256, 256, + conv5, 256, 256, 256, conv6, 256, 256, 256, conv7, 256, 256, 256}; + + mydataFmt *pointTeam[28] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_var->pdata, conv5_mean->pdata, conv5_beta->pdata, \ + conv6_wb->pdata, conv6_var->pdata, conv6_mean->pdata, conv6_beta->pdata, \ + conv7_wb->pdata, conv7_var->pdata, conv7_mean->pdata, conv7_beta->pdata}; + string filename = "../model_" + to_string(Num) + "/Mixed_7a_list.txt"; + readData(filename, dataNumber, pointTeam, 28); + + + maxPoolingInit(input, pooling1_out, 3, 2, 1); + // 8*8*896 + maxPooling(input, pooling1_out, 3, 2); + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 17 x 17 x 256 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, conv1_out, conv2_out); + //conv2 8 x 8 x 384 + convolution(conv2_wb, conv1_out, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, input, conv3_out); + //conv3 17 x 17 x 256 + convolution(conv3_wb, input, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + convolutionInit(conv4_wb, conv3_out, conv4_out); + //conv4 8 x 8 x 256 + convolution(conv4_wb, conv3_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + + convolutionInit(conv5_wb, input, conv5_out); + //conv5 17 x 17 x 256 + convolution(conv5_wb, input, conv5_out); + BatchNorm(conv5_out, conv5_var, conv5_mean, conv5_beta); + relu(conv5_out, conv5_wb->pbias); + + convolutionInit(conv6_wb, conv5_out, conv6_out); + //conv6 17 x 17 x 256 + convolution(conv6_wb, conv5_out, conv6_out); + BatchNorm(conv6_out, conv6_var, conv6_mean, conv6_beta); + relu(conv6_out, conv6_wb->pbias); + + convolutionInit(conv7_wb, conv6_out, conv7_out); + //conv6 8 x 8 x 256 + convolution(conv7_wb, conv6_out, conv7_out); + BatchNorm(conv7_out, conv7_var, conv7_mean, conv7_beta); + relu(conv7_out, conv7_wb->pbias); + + conv_mergeInit(output, conv2_out, conv4_out, conv7_out, pooling1_out); + //8*8*1792 + conv_merge(output, conv2_out, conv4_out, conv7_out, pooling1_out); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(conv6_out); + freepBox(conv7_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + freeWeight(conv6_wb); + freeWeight(conv7_wb); + + freepBox(pooling1_out); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); + freeBN(conv5_var); + freeBN(conv5_mean); + freeBN(conv5_beta); + freeBN(conv6_var); + freeBN(conv6_mean); + freeBN(conv6_beta); + freeBN(conv7_var); + freeBN(conv7_mean); + freeBN(conv7_beta); +} + +void facenet::Inception_resnet_C(pBox *input, pBox *output, string filepath, float scale) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + pBox *conv5_out = new pBox; + pBox *conv6_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + struct Weight *conv5_wb = new Weight; + struct Weight *conv6_wb = new Weight; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + + + long conv1 = ConvAndFcInit(conv1_wb, 192, 1792, 1, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 192); + long conv2 = ConvAndFcInit(conv2_wb, 192, 1792, 1, 1, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 192); + long conv3 = ConvAndFcInit(conv3_wb, 192, 192, 0, 1, -1, 3, 1, 1, 0); + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 192); + long conv4 = ConvAndFcInit(conv4_wb, 192, 192, 0, 1, -1, 1, 3, 0, 1); + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 192); + + long conv5 = ConvAndFcInit(conv5_wb, 1792, 384, 1, 1, 0); + + long conv6 = ConvAndFcInit(conv6_wb, 1792, 0, 0, 0, 0); + + long dataNumber[20] = {conv1, 192, 192, 192, conv2, 192, 192, 192, conv3, 192, 192, 192, conv4, 192, 192, 192, + conv5, 1792, conv6, 0}; + + + mydataFmt *pointTeam[20] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_wb->pbias, \ + conv6_wb->pdata, conv6_wb->pbias}; + +// string filename = "../model_128/Repeat_2_list.txt"; +// int length = sizeof(dataNumber) / sizeof(*dataNumber); + readData(filepath, dataNumber, pointTeam, 20); + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 8 x 8 x 192 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, input, conv2_out); + //conv2 8 x 8 x 192 + convolution(conv2_wb, input, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 8 x 8 x 192 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + convolutionInit(conv4_wb, conv3_out, conv4_out); + //conv4 8 x 8 x 192 + convolution(conv4_wb, conv3_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + + conv_mergeInit(conv5_out, conv1_out, conv4_out); + // 8*8*384 + conv_merge(conv5_out, conv1_out, conv4_out); + + convolutionInit(conv5_wb, conv5_out, conv6_out); + //conv5 8 x 8 x 1792 + convolution(conv5_wb, conv5_out, conv6_out); + addbias(conv6_out, conv5_wb->pbias); + + mulandaddInit(input, conv6_out, output, scale); + mulandadd(input, conv6_out, output, scale); + relu(output, conv6_wb->pbias); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(conv6_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + freeWeight(conv6_wb); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); +} + +void facenet::Inception_resnet_C_None(pBox *input, pBox *output, string filepath) { + pBox *conv1_out = new pBox; + pBox *conv2_out = new pBox; + pBox *conv3_out = new pBox; + pBox *conv4_out = new pBox; + pBox *conv5_out = new pBox; + pBox *conv6_out = new pBox; + + struct Weight *conv1_wb = new Weight; + struct Weight *conv2_wb = new Weight; + struct Weight *conv3_wb = new Weight; + struct Weight *conv4_wb = new Weight; + struct Weight *conv5_wb = new Weight; + + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + struct BN *conv2_var = new BN; + struct BN *conv2_mean = new BN; + struct BN *conv2_beta = new BN; + struct BN *conv3_var = new BN; + struct BN *conv3_mean = new BN; + struct BN *conv3_beta = new BN; + struct BN *conv4_var = new BN; + struct BN *conv4_mean = new BN; + struct BN *conv4_beta = new BN; + + long conv1 = ConvAndFcInit(conv1_wb, 192, 1792, 1, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, 192); + long conv2 = ConvAndFcInit(conv2_wb, 192, 1792, 1, 1, 0); + BatchNormInit(conv2_var, conv2_mean, conv2_beta, 192); + long conv3 = ConvAndFcInit(conv3_wb, 192, 192, 0, 1, -1, 3, 1, 1, 0); + BatchNormInit(conv3_var, conv3_mean, conv3_beta, 192); + long conv4 = ConvAndFcInit(conv4_wb, 192, 192, 0, 1, -1, 1, 3, 0, 1); + BatchNormInit(conv4_var, conv4_mean, conv4_beta, 192); + long conv5 = ConvAndFcInit(conv5_wb, 1792, 384, 1, 1, 0); + + long dataNumber[18] = {conv1, 192, 192, 192, conv2, 192, 192, 192, conv3, 192, 192, 192, conv4, 192, 192, 192, + conv5, 1792}; + + + mydataFmt *pointTeam[18] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata, \ + conv2_wb->pdata, conv2_var->pdata, conv2_mean->pdata, conv2_beta->pdata, \ + conv3_wb->pdata, conv3_var->pdata, conv3_mean->pdata, conv3_beta->pdata, \ + conv4_wb->pdata, conv4_var->pdata, conv4_mean->pdata, conv4_beta->pdata, \ + conv5_wb->pdata, conv5_wb->pbias}; + +// string filename = "../model_128/Repeat_2_list.txt"; +// int length = sizeof(dataNumber) / sizeof(*dataNumber); + readData(filepath, dataNumber, pointTeam, 18); + + convolutionInit(conv1_wb, input, conv1_out); + //conv1 8 x 8 x 192 + convolution(conv1_wb, input, conv1_out); + BatchNorm(conv1_out, conv1_var, conv1_mean, conv1_beta); + relu(conv1_out, conv1_wb->pbias); + + convolutionInit(conv2_wb, input, conv2_out); + //conv2 8 x 8 x 192 + convolution(conv2_wb, input, conv2_out); + BatchNorm(conv2_out, conv2_var, conv2_mean, conv2_beta); + relu(conv2_out, conv2_wb->pbias); + + convolutionInit(conv3_wb, conv2_out, conv3_out); + //conv3 8 x 8 x 192 + convolution(conv3_wb, conv2_out, conv3_out); + BatchNorm(conv3_out, conv3_var, conv3_mean, conv3_beta); + relu(conv3_out, conv3_wb->pbias); + + convolutionInit(conv4_wb, conv3_out, conv4_out); + //conv4 8 x 8 x 192 + convolution(conv4_wb, conv3_out, conv4_out); + BatchNorm(conv4_out, conv4_var, conv4_mean, conv4_beta); + relu(conv4_out, conv4_wb->pbias); + + conv_mergeInit(conv5_out, conv1_out, conv4_out); + // 8*8*384 + conv_merge(conv5_out, conv1_out, conv4_out); + + convolutionInit(conv5_wb, conv5_out, conv6_out); + //conv5 8 x 8 x 1792 + convolution(conv5_wb, conv5_out, conv6_out); + addbias(conv6_out, conv5_wb->pbias); + + mulandaddInit(input, conv6_out, output, 1); + mulandadd(input, conv6_out, output); + + freepBox(conv1_out); + freepBox(conv2_out); + freepBox(conv3_out); + freepBox(conv4_out); + freepBox(conv5_out); + freepBox(conv6_out); + + freeWeight(conv1_wb); + freeWeight(conv2_wb); + freeWeight(conv3_wb); + freeWeight(conv4_wb); + freeWeight(conv5_wb); + + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); + freeBN(conv2_var); + freeBN(conv2_mean); + freeBN(conv2_beta); + freeBN(conv3_var); + freeBN(conv3_mean); + freeBN(conv3_beta); + freeBN(conv4_var); + freeBN(conv4_mean); + freeBN(conv4_beta); +} + +void facenet::AveragePooling(pBox *input, pBox *output) { +// cout << "size:" << input->height << endl; + avePoolingInit(input, output, input->height, 2); + avePooling(input, output, input->height, 2); +} + +void facenet::Flatten(pBox *input, pBox *output) { + output->width = input->channel; + output->height = 1; + output->channel = 1; + output->pdata = (mydataFmt *) malloc(output->channel * output->width * output->height * sizeof(mydataFmt)); + if (output->pdata == NULL)cout << "the maxPoolingInit is failed!!" << endl; + memcpy(output->pdata, input->pdata, output->channel * output->width * output->height * sizeof(mydataFmt)); +} + +//参数还未设置 +void facenet::fully_connect(pBox *input, pBox *output, string filepath) { + struct Weight *conv1_wb = new Weight; + struct BN *conv1_var = new BN; + struct BN *conv1_mean = new BN; + struct BN *conv1_beta = new BN; + long conv1 = ConvAndFcInit(conv1_wb, Num, 1792, input->height, 1, 0); + BatchNormInit(conv1_var, conv1_mean, conv1_beta, Num); + long dataNumber[4] = {conv1, Num, Num, Num}; + +// cout << to_string(sum) << endl; + mydataFmt *pointTeam[4] = {conv1_wb->pdata, conv1_var->pdata, conv1_mean->pdata, conv1_beta->pdata}; +// string filename = "../model_128/Bottleneck_list.txt"; +// int length = sizeof(dataNumber) / sizeof(*dataNumber); + readData(filepath, dataNumber, pointTeam, 4); + + fullconnectInit(conv1_wb, output); + + //conv1 8 x 8 x 192 + fullconnect(conv1_wb, input, output); + BatchNorm(output, conv1_var, conv1_mean, conv1_beta); + + freeWeight(conv1_wb); + freeBN(conv1_var); + freeBN(conv1_mean); + freeBN(conv1_beta); +} + facenet::facenet() { } @@ -14,16 +1003,16 @@ facenet::~facenet() { void facenet::printData(pBox *in) { for (long i = 0; i < in->height * in->width * in->channel; ++i) { +// if (in->pdata[i] != 0) printf("%f\n", in->pdata[i]); } cout << "printData" << endl; } -void facenet::run(Mat &image, mydataFmt *o, int count) { +void facenet::run(Mat &image, vector &o, int count) { cout << "=====This is No." + to_string(count) + " Picture=====" << endl; pBox *output = new pBox; pBox *input; -// prewhiten(image); Stem(image, output); // printData(output); // return; @@ -74,11 +1063,10 @@ void facenet::run(Mat &image, mydataFmt *o, int count) { AveragePooling(input, output); cout << "AveragePooling Finally" << endl; input = output; -// freepBox(output); - output = new pBox; - Flatten(input, output); - cout << "Flatten Finally" << endl; - input = output; +// output = new pBox; +// Flatten(input, output); +// cout << "Flatten Finally" << endl; +// input = output; output = new pBox; fully_connect(input, output, "../model_" + to_string(Num) + "/Bottleneck_list.txt"); cout << "Fully_Connect Finally" << endl; @@ -94,872 +1082,9 @@ void facenet::run(Mat &image, mydataFmt *o, int count) { divisor = sqrt(sum); } for (int j = 0; j < Num; ++j) { - o[j] = output->pdata[j] / divisor; +// o[j] = output->pdata[j] / divisor; + o.push_back(output->pdata[j] / divisor); } // memcpy(o, output->pdata, Num * sizeof(mydataFmt)); freepBox(output); -} - -void facenet::Stem(Mat &image, pBox *output) { - pBox *rgb = new pBox; - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - struct Weight *conv6_wb = new Weight; - - struct pBox *pooling1_out = new pBox; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - struct pRelu *prelu_gmma5 = new pRelu; - struct pRelu *prelu_gmma6 = new pRelu; - - - long conv1 = initConvAndFc(conv1_wb, 32, 3, 3, 2, 0); - initpRelu(prelu_gmma1, 32); - long conv2 = initConvAndFc(conv2_wb, 32, 32, 3, 1, 0); - initpRelu(prelu_gmma2, 32); - long conv3 = initConvAndFc(conv3_wb, 64, 32, 3, 1, 1); - initpRelu(prelu_gmma3, 64); - long conv4 = initConvAndFc(conv4_wb, 80, 64, 1, 1, 0); - initpRelu(prelu_gmma4, 80); - long conv5 = initConvAndFc(conv5_wb, 192, 80, 3, 1, 0); - initpRelu(prelu_gmma5, 192); - long conv6 = initConvAndFc(conv6_wb, 256, 192, 3, 2, 0); - initpRelu(prelu_gmma6, 256); - long dataNumber[18] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 0, 0, conv6, 0, - 0}; - - mydataFmt *pointTeam[18] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias, prelu_gmma5->pdata, \ - conv6_wb->pdata, conv6_wb->pbias, prelu_gmma6->pdata,}; - string filename = "../model_" + to_string(Num) + "/stem_list.txt"; - readData(filename, dataNumber, pointTeam); - - - -// if (firstFlag) { - image2MatrixInit(image, rgb); - image2Matrix(image, rgb, 1); - - convolutionInit(conv1_wb, rgb, conv1_out); - //conv1 149 x 149 x 32 - convolution(conv1_wb, rgb, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - convolutionInit(conv2_wb, conv1_out, conv2_out); - //conv2 147 x 147 x 32 - convolution(conv2_wb, conv1_out, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 147 x 147 x 64 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - maxPoolingInit(conv3_out, pooling1_out, 3, 2); - //maxPooling 73 x 73 x 64 - maxPooling(conv3_out, pooling1_out, 3, 2); - - convolutionInit(conv4_wb, pooling1_out, conv4_out); - //conv4 73 x 73 x 80 - convolution(conv4_wb, pooling1_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - - convolutionInit(conv5_wb, conv4_out, conv5_out); - //conv5 71 x 71 x 192 - convolution(conv5_wb, conv4_out, conv5_out); - prelu(conv5_out, conv5_wb->pbias, prelu_gmma5->pdata); - - - convolutionInit(conv6_wb, conv5_out, output); - //conv6 35 x 35 x 256 - convolution(conv6_wb, conv5_out, output); - prelu(output, conv6_wb->pbias, prelu_gmma6->pdata); -// firstFlag = false; -// } - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(pooling1_out); - - freepBox(rgb); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - freeWeight(conv6_wb); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); - freepRelu(prelu_gmma5); - freepRelu(prelu_gmma6); -} - -void facenet::Inception_resnet_A(pBox *input, pBox *output, string filepath, float scale) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - pBox *conv6_out = new pBox; - pBox *conv7_out = new pBox; - pBox *conv8_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - struct Weight *conv6_wb = new Weight; - struct Weight *conv7_wb = new Weight; - struct Weight *conv8_wb = new Weight; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - struct pRelu *prelu_gmma5 = new pRelu; - struct pRelu *prelu_gmma6 = new pRelu; - struct pRelu *prelu_gmma8 = new pRelu; - - long conv1 = initConvAndFc(conv1_wb, 32, 256, 1, 1, 0); - initpRelu(prelu_gmma1, 32); - - long conv2 = initConvAndFc(conv2_wb, 32, 256, 1, 1, 0); - initpRelu(prelu_gmma2, 32); - long conv3 = initConvAndFc(conv3_wb, 32, 32, 3, 1, 1); - initpRelu(prelu_gmma3, 32); - - long conv4 = initConvAndFc(conv4_wb, 32, 256, 1, 1, 0); - initpRelu(prelu_gmma4, 32); - long conv5 = initConvAndFc(conv5_wb, 32, 32, 3, 1, 1); - initpRelu(prelu_gmma5, 32); - long conv6 = initConvAndFc(conv6_wb, 32, 32, 3, 1, 1); - initpRelu(prelu_gmma6, 32); - - long conv7 = initConvAndFc(conv7_wb, 256, 96, 1, 1, 0); - - long conv8 = initConvAndFc(conv8_wb, 256, 0, 0, 0, 0); - initpRelu(prelu_gmma8, 256); - - long dataNumber[23] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 0, 0, conv6, 0, - 0, conv7, 256, conv8, 0, 0}; - - mydataFmt *pointTeam[23] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias, prelu_gmma5->pdata, \ - conv6_wb->pdata, conv6_wb->pbias, prelu_gmma6->pdata, \ - conv7_wb->pdata, conv7_wb->pbias, \ - conv8_wb->pdata, conv8_wb->pbias, prelu_gmma8->pdata}; - - readData(filepath, dataNumber, pointTeam); - - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 35 x 35 x 32 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, input, conv2_out); - //conv2 35 x 35 x 32 - convolution(conv2_wb, input, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 35 x 35 x 32 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, input, conv4_out); - //conv4 35 x 35 x 32 - convolution(conv4_wb, input, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - convolutionInit(conv5_wb, conv4_out, conv5_out); - //conv5 35 x 35 x 32 - convolution(conv5_wb, conv4_out, conv5_out); - prelu(conv5_out, conv5_wb->pbias, prelu_gmma5->pdata); - convolutionInit(conv6_wb, conv5_out, conv6_out); - //conv6 35 x 35 x 32 - convolution(conv6_wb, conv5_out, conv6_out); - prelu(conv6_out, conv6_wb->pbias, prelu_gmma6->pdata); - - conv_mergeInit(conv7_out, conv1_out, conv3_out, conv6_out); - //35 × 35 × 96 - conv_merge(conv7_out, conv1_out, conv3_out, conv6_out); - - convolutionInit(conv7_wb, conv7_out, conv8_out); - //35*35*256 - convolution(conv7_wb, conv7_out, conv8_out); - addbias(conv8_out, conv7_wb->pbias); - - mulandaddInit(input, conv8_out, output, scale); - mulandadd(input, conv8_out, output, scale); - prelu(output, conv8_wb->pbias, prelu_gmma8->pdata); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(conv6_out); - freepBox(conv7_out); - freepBox(conv8_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - freeWeight(conv6_wb); - freeWeight(conv7_wb); - freeWeight(conv8_wb); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); - freepRelu(prelu_gmma5); - freepRelu(prelu_gmma6); - freepRelu(prelu_gmma8); -} - -void facenet::Reduction_A(pBox *input, pBox *output) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - - struct pBox *pooling1_out = new pBox; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - - long conv1 = initConvAndFc(conv1_wb, 384, 256, 3, 2, 0); - initpRelu(prelu_gmma1, 384); - long conv2 = initConvAndFc(conv2_wb, 192, 256, 1, 1, 0); - initpRelu(prelu_gmma2, 192); - long conv3 = initConvAndFc(conv3_wb, 192, 192, 3, 1, 0); - initpRelu(prelu_gmma3, 192); - long conv4 = initConvAndFc(conv4_wb, 256, 192, 3, 2, 0); - initpRelu(prelu_gmma4, 256); - long dataNumber[12] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0}; - - mydataFmt *pointTeam[12] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata}; - string filename = "../model_" + to_string(Num) + "/Mixed_6a_list.txt"; - readData(filename, dataNumber, pointTeam); - - maxPoolingInit(input, pooling1_out, 3, 2); - // 17*17*256 - maxPooling(input, pooling1_out, 3, 2); - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 17 x 17 x 384 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, input, conv2_out); - //conv2 35 x 35 x 192 - convolution(conv2_wb, input, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 35 x 35 x 192 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, conv3_out, conv4_out); - //conv4 17 x 17 x 256 - convolution(conv4_wb, conv3_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - conv_mergeInit(output, pooling1_out, conv1_out, conv4_out); - //17×17×896 - conv_merge(output, pooling1_out, conv1_out, conv4_out); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - - freepBox(pooling1_out); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); -} - -void facenet::Inception_resnet_B(pBox *input, pBox *output, string filepath, float scale) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - pBox *conv6_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - struct Weight *conv6_wb = new Weight; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - struct pRelu *prelu_gmma6 = new pRelu; - - long conv1 = initConvAndFc(conv1_wb, 128, 896, 1, 1, 0); - initpRelu(prelu_gmma1, 128); - long conv2 = initConvAndFc(conv2_wb, 128, 896, 1, 1, 0); - initpRelu(prelu_gmma2, 128); - long conv3 = initConvAndFc(conv3_wb, 128, 128, 0, 1, -1, 1, 7, 0, 3);//[1,7] - initpRelu(prelu_gmma3, 128); - long conv4 = initConvAndFc(conv4_wb, 128, 128, 0, 1, -1, 7, 1, 3, 0);//[7,1] - initpRelu(prelu_gmma4, 128); - - long conv5 = initConvAndFc(conv5_wb, 896, 256, 1, 1, 0); - - long conv6 = initConvAndFc(conv6_wb, 896, 0, 0, 0, 0); - initpRelu(prelu_gmma6, 896); - - long dataNumber[17] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 896, conv6, 0, - 0}; - - mydataFmt *pointTeam[17] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias, \ - conv6_wb->pdata, conv6_wb->pbias, prelu_gmma6->pdata}; - - - readData(filepath, dataNumber, pointTeam); - - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 17*17*128 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, input, conv2_out); - //conv2 17*17*128 - convolution(conv2_wb, input, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 17*17*128 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, conv3_out, conv4_out); - //conv4 17*17*128 - convolution(conv4_wb, conv3_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - - conv_mergeInit(conv5_out, conv1_out, conv4_out); - //17*17*256 - conv_merge(conv5_out, conv1_out, conv4_out); - - convolutionInit(conv5_wb, conv5_out, conv6_out); - //conv5 17*17*896 - convolution(conv5_wb, conv5_out, conv6_out); - addbias(conv6_out, conv5_wb->pbias); - - mulandaddInit(input, conv6_out, output, scale); - mulandadd(input, conv6_out, output, scale); - prelu(output, conv6_wb->pbias, prelu_gmma6->pdata); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(conv6_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - freeWeight(conv6_wb); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); -// freepRelu(prelu_gmma5); - freepRelu(prelu_gmma6); -} - -void facenet::Reduction_B(pBox *input, pBox *output) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - pBox *conv6_out = new pBox; - pBox *conv7_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - struct Weight *conv6_wb = new Weight; - struct Weight *conv7_wb = new Weight; - - struct pBox *pooling1_out = new pBox; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - struct pRelu *prelu_gmma5 = new pRelu; - struct pRelu *prelu_gmma6 = new pRelu; - struct pRelu *prelu_gmma7 = new pRelu; - - long conv1 = initConvAndFc(conv1_wb, 256, 896, 1, 1, 0); - initpRelu(prelu_gmma1, 256); - long conv2 = initConvAndFc(conv2_wb, 384, 256, 3, 2, 0); - initpRelu(prelu_gmma2, 384); - - long conv3 = initConvAndFc(conv3_wb, 256, 896, 1, 1, 0); - initpRelu(prelu_gmma3, 256); - long conv4 = initConvAndFc(conv4_wb, 256, 256, 3, 2, 0); - initpRelu(prelu_gmma4, 256); - - long conv5 = initConvAndFc(conv5_wb, 256, 896, 1, 1, 0); - initpRelu(prelu_gmma5, 256); - long conv6 = initConvAndFc(conv6_wb, 256, 256, 3, 1, 1); - initpRelu(prelu_gmma6, 256); - long conv7 = initConvAndFc(conv7_wb, 256, 256, 3, 2, 0); - initpRelu(prelu_gmma7, 256); - - long dataNumber[21] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 0, 0, conv6, - 0, 0, conv7, 0, 0}; - - mydataFmt *pointTeam[21] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias, prelu_gmma5->pdata, \ - conv6_wb->pdata, conv6_wb->pbias, prelu_gmma6->pdata, \ - conv7_wb->pdata, conv7_wb->pbias, prelu_gmma7->pdata,}; - string filename = "../model_" + to_string(Num) + "/Mixed_7a_list.txt"; - readData(filename, dataNumber, pointTeam); - - - maxPoolingInit(input, pooling1_out, 3, 2, 1); - // 8*8*896 - maxPooling(input, pooling1_out, 3, 2); - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 17 x 17 x 256 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, conv1_out, conv2_out); - //conv2 8 x 8 x 384 - convolution(conv2_wb, conv1_out, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, input, conv3_out); - //conv3 17 x 17 x 256 - convolution(conv3_wb, input, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, conv3_out, conv4_out); - //conv4 8 x 8 x 256 - convolution(conv4_wb, conv3_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - - convolutionInit(conv5_wb, input, conv5_out); - //conv5 17 x 17 x 256 - convolution(conv5_wb, input, conv5_out); - prelu(conv5_out, conv5_wb->pbias, prelu_gmma5->pdata); - - convolutionInit(conv6_wb, conv5_out, conv6_out); - //conv6 17 x 17 x 256 - convolution(conv6_wb, conv5_out, conv6_out); - prelu(conv6_out, conv6_wb->pbias, prelu_gmma6->pdata); - - convolutionInit(conv7_wb, conv6_out, conv7_out); - //conv6 8 x 8 x 256 - convolution(conv7_wb, conv6_out, conv7_out); - prelu(conv7_out, conv7_wb->pbias, prelu_gmma7->pdata); - - conv_mergeInit(output, conv2_out, conv4_out, conv7_out, pooling1_out); - //8*8*1792 - conv_merge(output, conv2_out, conv4_out, conv7_out, pooling1_out); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(conv6_out); - freepBox(conv7_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - freeWeight(conv6_wb); - freeWeight(conv7_wb); - - freepBox(pooling1_out); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); - freepRelu(prelu_gmma5); - freepRelu(prelu_gmma6); - freepRelu(prelu_gmma7); -} - -void facenet::Inception_resnet_C(pBox *input, pBox *output, string filepath, float scale) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - pBox *conv6_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - struct Weight *conv6_wb = new Weight; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - struct pRelu *prelu_gmma6 = new pRelu; - - - long conv1 = initConvAndFc(conv1_wb, 192, 1792, 1, 1, 0); - initpRelu(prelu_gmma1, 192); - long conv2 = initConvAndFc(conv2_wb, 192, 1792, 1, 1, 0); - initpRelu(prelu_gmma2, 192); - long conv3 = initConvAndFc(conv3_wb, 192, 192, 0, 1, -1, 1, 3, 0, 1); - initpRelu(prelu_gmma3, 192); - long conv4 = initConvAndFc(conv4_wb, 192, 192, 0, 1, -1, 3, 1, 1, 0); - initpRelu(prelu_gmma4, 192); - long conv5 = initConvAndFc(conv5_wb, 1792, 384, 1, 1, 0); - - long conv6 = initConvAndFc(conv6_wb, 1792, 0, 0, 0, 0); - initpRelu(prelu_gmma6, 1792); - - long dataNumber[17] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 1792, conv6, 0, - 0}; - - - mydataFmt *pointTeam[17] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias, \ - conv6_wb->pdata, conv6_wb->pbias, prelu_gmma6->pdata}; - -// string filename = "../model_128/Repeat_2_list.txt"; -// int length = sizeof(dataNumber) / sizeof(*dataNumber); - readData(filepath, dataNumber, pointTeam); - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 8 x 8 x 192 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, input, conv2_out); - //conv2 8 x 8 x 192 - convolution(conv2_wb, input, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 8 x 8 x 192 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, conv3_out, conv4_out); - //conv4 8 x 8 x 192 - convolution(conv4_wb, conv3_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - - conv_mergeInit(conv5_out, conv1_out, conv4_out); - // 8*8*384 - conv_merge(conv5_out, conv1_out, conv4_out); - - convolutionInit(conv5_wb, conv5_out, conv6_out); - //conv5 8 x 8 x 1792 - convolution(conv5_wb, conv5_out, conv6_out); - addbias(conv6_out, conv5_wb->pbias); - - mulandaddInit(input, conv6_out, output, scale); - mulandadd(input, conv6_out, output, scale); - prelu(output, conv6_wb->pbias, prelu_gmma6->pdata); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(conv6_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - freeWeight(conv6_wb); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); -// freepRelu(prelu_gmma5); - freepRelu(prelu_gmma6); -} - -void facenet::Inception_resnet_C_None(pBox *input, pBox *output, string filepath) { - pBox *conv1_out = new pBox; - pBox *conv2_out = new pBox; - pBox *conv3_out = new pBox; - pBox *conv4_out = new pBox; - pBox *conv5_out = new pBox; - pBox *conv6_out = new pBox; - - struct Weight *conv1_wb = new Weight; - struct Weight *conv2_wb = new Weight; - struct Weight *conv3_wb = new Weight; - struct Weight *conv4_wb = new Weight; - struct Weight *conv5_wb = new Weight; - - struct pRelu *prelu_gmma1 = new pRelu; - struct pRelu *prelu_gmma2 = new pRelu; - struct pRelu *prelu_gmma3 = new pRelu; - struct pRelu *prelu_gmma4 = new pRelu; - - - long conv1 = initConvAndFc(conv1_wb, 192, 1792, 1, 1, 0); - initpRelu(prelu_gmma1, 192); - long conv2 = initConvAndFc(conv2_wb, 192, 1792, 1, 1, 0); - initpRelu(prelu_gmma2, 192); - long conv3 = initConvAndFc(conv3_wb, 192, 192, 0, 1, -1, 1, 3, 0, 1); - initpRelu(prelu_gmma3, 192); - long conv4 = initConvAndFc(conv4_wb, 192, 192, 0, 1, -1, 3, 1, 1, 0); - initpRelu(prelu_gmma4, 192); - long conv5 = initConvAndFc(conv5_wb, 1792, 384, 1, 1, 0); - - long dataNumber[14] = {conv1, 0, 0, conv2, 0, 0, conv3, 0, 0, conv4, 0, 0, conv5, 1792}; - - - mydataFmt *pointTeam[14] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata, \ - conv2_wb->pdata, conv2_wb->pbias, prelu_gmma2->pdata, \ - conv3_wb->pdata, conv3_wb->pbias, prelu_gmma3->pdata, \ - conv4_wb->pdata, conv4_wb->pbias, prelu_gmma4->pdata, \ - conv5_wb->pdata, conv5_wb->pbias}; - -// string filename = "../model_128/Repeat_2_list.txt"; -// int length = sizeof(dataNumber) / sizeof(*dataNumber); - readData(filepath, dataNumber, pointTeam); - - convolutionInit(conv1_wb, input, conv1_out); - //conv1 8 x 8 x 192 - convolution(conv1_wb, input, conv1_out); - prelu(conv1_out, conv1_wb->pbias, prelu_gmma1->pdata); - - convolutionInit(conv2_wb, input, conv2_out); - //conv2 8 x 8 x 192 - convolution(conv2_wb, input, conv2_out); - prelu(conv2_out, conv2_wb->pbias, prelu_gmma2->pdata); - - convolutionInit(conv3_wb, conv2_out, conv3_out); - //conv3 8 x 8 x 192 - convolution(conv3_wb, conv2_out, conv3_out); - prelu(conv3_out, conv3_wb->pbias, prelu_gmma3->pdata); - - convolutionInit(conv4_wb, conv3_out, conv4_out); - //conv4 8 x 8 x 192 - convolution(conv4_wb, conv3_out, conv4_out); - prelu(conv4_out, conv4_wb->pbias, prelu_gmma4->pdata); - - conv_mergeInit(conv5_out, conv1_out, conv4_out); - // 8*8*384 - conv_merge(conv5_out, conv1_out, conv4_out); - - convolutionInit(conv5_wb, conv5_out, conv6_out); - //conv5 8 x 8 x 1792 - convolution(conv5_wb, conv5_out, conv6_out); - addbias(conv6_out, conv5_wb->pbias); - - mulandaddInit(input, conv6_out, output, 1); - mulandadd(input, conv6_out, output); - - freepBox(conv1_out); - freepBox(conv2_out); - freepBox(conv3_out); - freepBox(conv4_out); - freepBox(conv5_out); - freepBox(conv6_out); - - freeWeight(conv1_wb); - freeWeight(conv2_wb); - freeWeight(conv3_wb); - freeWeight(conv4_wb); - freeWeight(conv5_wb); - - freepRelu(prelu_gmma1); - freepRelu(prelu_gmma2); - freepRelu(prelu_gmma3); - freepRelu(prelu_gmma4); -} - -void facenet::AveragePooling(pBox *input, pBox *output) { -// cout << "size:" << input->height << endl; - avePoolingInit(input, output, input->height, 2); - avePooling(input, output, input->height, 2); -} - -void facenet::Flatten(pBox *input, pBox *output) { - output->width = input->channel; - output->height = 1; - output->channel = 1; - output->pdata = (mydataFmt *) malloc(output->channel * output->width * output->height * sizeof(mydataFmt)); - if (output->pdata == NULL)cout << "the maxPoolingInit is failed!!" << endl; - memcpy(output->pdata, input->pdata, output->channel * output->width * output->height * sizeof(mydataFmt)); -} - -//参数还未设置 -void facenet::fully_connect(pBox *input, pBox *output, string filepath) { - struct Weight *conv1_wb = new Weight; - struct pRelu *prelu_gmma1 = new pRelu; - long conv1 = initConvAndFc(conv1_wb, Num, 1792, input->height, 1, 0); - initpRelu(prelu_gmma1, Num); - long dataNumber[3] = {conv1, 0, 0}; - -// cout << to_string(sum) << endl; - mydataFmt *pointTeam[3] = {conv1_wb->pdata, conv1_wb->pbias, prelu_gmma1->pdata}; -// string filename = "../model_128/Bottleneck_list.txt"; -// int length = sizeof(dataNumber) / sizeof(*dataNumber); - readData(filepath, dataNumber, pointTeam); - - fullconnectInit(conv1_wb, output); - - //conv1 8 x 8 x 192 - fullconnect(conv1_wb, input, output); -// prelu(output, conv1_wb->pbias, prelu_gmma1->pdata); - - freeWeight(conv1_wb); - freepRelu(prelu_gmma1); -} - -void facenet::conv_mergeInit(pBox *output, pBox *c1, pBox *c2, pBox *c3, pBox *c4) { - output->channel = 0; - output->height = c1->height; - output->width = c1->width; - if (c1 != 0) { - output->channel = c1->channel; - if (c2 != 0) { - output->channel += c2->channel; - if (c3 != 0) { - output->channel += c3->channel; - if (c4 != 0) { - output->channel += c4->channel; - } - } - } - } else { cout << "conv_mergeInit" << endl; } - output->pdata = (mydataFmt *) malloc(output->width * output->height * output->channel * sizeof(mydataFmt)); - if (output->pdata == NULL)cout << "the conv_mergeInit is failed!!" << endl; - memset(output->pdata, 0, output->width * output->height * output->channel * sizeof(mydataFmt)); -} - -void facenet::conv_merge(pBox *output, pBox *c1, pBox *c2, pBox *c3, pBox *c4) { -// cout << "output->channel:" << output->channel << endl; - if (c1 != 0) { - long count1 = c1->height * c1->width * c1->channel; - //output->pdata = c1->pdata; - for (long i = 0; i < count1; i++) { - output->pdata[i] = c1->pdata[i]; - } - if (c2 != 0) { - long count2 = c2->height * c2->width * c2->channel; - for (long i = 0; i < count2; i++) { - output->pdata[count1 + i] = c2->pdata[i]; - } - if (c3 != 0) { - long count3 = c3->height * c3->width * c3->channel; - for (long i = 0; i < count3; i++) { - output->pdata[count1 + count2 + i] = c3->pdata[i]; - } - if (c4 != 0) { - long count4 = c4->height * c4->width * c4->channel; - for (long i = 0; i < count4; i++) { - output->pdata[count1 + count2 + count3 + i] = c4->pdata[i]; - } - } - } - } - } else { cout << "conv_mergeInit" << endl; } -// cout << "output->pdata:" << *(output->pdata) << endl; -} - -void facenet::mulandaddInit(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale) { - outpBox->channel = temppbox->channel; - outpBox->width = temppbox->width; - outpBox->height = temppbox->height; - outpBox->pdata = (mydataFmt *) malloc(outpBox->width * outpBox->height * outpBox->channel * sizeof(mydataFmt)); - if (outpBox->pdata == NULL)cout << "the mulandaddInit is failed!!" << endl; - memset(outpBox->pdata, 0, outpBox->width * outpBox->height * outpBox->channel * sizeof(mydataFmt)); -} - -void facenet::mulandadd(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale) { - mydataFmt *ip = inpbox->pdata; - mydataFmt *tp = temppbox->pdata; - mydataFmt *op = outpBox->pdata; - long dis = inpbox->width * inpbox->height * inpbox->channel; - for (long i = 0; i < dis; i++) { - op[i] = ip[i] + tp[i] * scale; - } } \ No newline at end of file diff --git a/src/facenet.h b/src/facenet.h index 1145a66..dc8267f 100644 --- a/src/facenet.h +++ b/src/facenet.h @@ -14,7 +14,7 @@ public: ~facenet(); - void run(Mat &image, mydataFmt *o, int count = 1); + void run(Mat &image, vector &o, int count = 1); private: void Stem(Mat &image, pBox *output); @@ -35,20 +35,9 @@ private: void fully_connect(pBox *input, pBox *output, string filepath = ""); - void conv_merge(pBox *output, pBox *c1 = 0, pBox *c2 = 0, pBox *c3 = 0, pBox *c4 = 0); - - void conv_mergeInit(pBox *output, pBox *c1 = 0, pBox *c2 = 0, pBox *c3 = 0, pBox *c4 = 0); - - void mulandaddInit(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale); - - void mulandadd(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale = 1); - void Flatten(pBox *input, pBox *output); void printData(pBox *output); - - - }; #endif //MAIN_FACENET_H diff --git a/src/network.cpp b/src/network.cpp index 5373fc7..b21e1d6 100644 --- a/src/network.cpp +++ b/src/network.cpp @@ -45,44 +45,57 @@ void image2Matrix(const Mat &image, const struct pBox *pbox, int num) { return; } mydataFmt *p = pbox->pdata; + double sqr, stddev_adj; + int size; + mydataFmt mymean, mystddev; + // prewhiten + if (num != 0) { + MeanAndDev(image, mymean, mystddev); + cout << mymean << "----" << mystddev << endl; + size = image.cols * image.rows * image.channels(); + sqr = sqrt(double(size)); + if (mystddev >= 1.0 / sqr) { + stddev_adj = mystddev; + } else { + stddev_adj = 1.0 / sqr; + } + } for (int rowI = 0; rowI < image.rows; rowI++) { for (int colK = 0; colK < image.cols; colK++) { if (num == 0) { - *p = (image.at(rowI, colK)[0] - 127.5) * 0.0078125; + *p = (image.at(rowI, colK)[2] - 127.5) * 0.0078125; *(p + image.rows * image.cols) = (image.at(rowI, colK)[1] - 127.5) * 0.0078125; - *(p + 2 * image.rows * image.cols) = (image.at(rowI, colK)[2] - 127.5) * 0.0078125; + *(p + 2 * image.rows * image.cols) = (image.at(rowI, colK)[0] - 127.5) * 0.0078125; p++; } else { - double mean, stddev, sqr, stddev_adj; - int size; - Mat temp_m, temp_sd; - meanStdDev(image, temp_m, temp_sd); - mean = temp_m.at(0, 0); - stddev = temp_sd.at(0, 0); - size = image.cols * image.rows * image.channels(); - sqr = sqrt(double(size)); - - if (stddev >= 1.0 / sqr) { - stddev_adj = stddev; - } else { - stddev_adj = 1.0 / sqr; - } -// cout << mean << "|" << stddev << "|" << size << "|" << stddev_adj << "|" << endl; - for (int i = 0; i < image.rows; i++) { - for (int j = 0; j < image.cols; j++) { - image.at(i, j); - *p = (image.at(i, j)[0] - mean) / stddev_adj; - *(p + image.rows * image.cols) = (image.at(i, j)[1] - mean) / stddev_adj; - *(p + 2 * image.rows * image.cols) = (image.at(i, j)[2] - mean) / stddev_adj; -// cout << (image.at(i, j)[0] - mean) / stddev_adj << endl; -// return; - } - } + // brg2rgb + *(p + 0 * image.rows * image.cols) = (image.at(rowI, colK)[2] - mymean) / stddev_adj; + *(p + 1 * image.rows * image.cols) = (image.at(rowI, colK)[1] - mymean) / stddev_adj; + *(p + 2 * image.rows * image.cols) = (image.at(rowI, colK)[0] - mymean) / stddev_adj; + p++; } } } } +void MeanAndDev(const Mat &image, mydataFmt &p, mydataFmt &q) { + mydataFmt meansum = 0, stdsum = 0; + for (int rowI = 0; rowI < image.rows; rowI++) { + for (int colK = 0; colK < image.cols; colK++) { + meansum += image.at(rowI, colK)[0] + image.at(rowI, colK)[1] + image.at(rowI, colK)[2]; + } + } + p = meansum / (image.cols * image.rows * image.channels()); + for (int rowI = 0; rowI < image.rows; rowI++) { + for (int colK = 0; colK < image.cols; colK++) { + stdsum += pow((image.at(rowI, colK)[0] - p), 2) + + pow((image.at(rowI, colK)[1] - p), 2) + + pow((image.at(rowI, colK)[2] - p), 2); + } + } + q = sqrt(stdsum / (image.cols * image.rows * image.channels())); +} + void featurePadInit(const pBox *pbox, pBox *outpBox, const int pad, const int padw, const int padh) { if (pad < -1) { cout << "the data needn't to pad,please check you network!" << endl; @@ -156,12 +169,6 @@ void convolutionInit(const Weight *weight, pBox *pbox, pBox *outpBox) { } void convolution(const Weight *weight, const pBox *pbox, pBox *outpBox) { -// if (weight->pad != 0) { -// pBox *padpbox = new pBox; -// featurePadInit(outpBox, padpbox, weight->pad, weight->padw, weight->padh); -// featurePad(outpBox, padpbox, weight->pad, weight->padw, weight->padh); -// *outpBox = *padpbox; -// } int ckh, ckw, ckd, stride, cknum, ckpad, imginputh, imginputw, imginputd, Nh, Nw; mydataFmt *ck, *imginput; // float *output = outpBox->pdata; @@ -206,7 +213,6 @@ void convolution(const Weight *weight, const pBox *pbox, pBox *outpBox) { } } } -// cout << "output->pdata:" << (outpBox->pdata[10]) << endl; } void maxPoolingInit(const pBox *pbox, pBox *Matrix, int kernelSize, int stride, int flag) { @@ -315,8 +321,12 @@ void avePooling(const pBox *pbox, pBox *Matrix, int kernelSize, int stride) { } } - -void prelu(struct pBox *pbox, mydataFmt *pbias, mydataFmt *prelu_gmma) { +/** + * 激活函数 没有系数 + * @param pbox + * @param pbias + */ +void relu(struct pBox *pbox, mydataFmt *pbias) { if (pbox->pdata == NULL) { cout << "the Relu feature is NULL!!" << endl; return; @@ -327,17 +337,15 @@ void prelu(struct pBox *pbox, mydataFmt *pbias, mydataFmt *prelu_gmma) { } mydataFmt *op = pbox->pdata; mydataFmt *pb = pbias; - mydataFmt *pg = prelu_gmma; long dis = pbox->width * pbox->height; for (int channel = 0; channel < pbox->channel; channel++) { for (int col = 0; col < dis; col++) { *op = *op + *pb; - *op = (*op > 0) ? (*op) : ((*op) * (*pg)); + *op = (*op > 0) ? (*op) : ((*op) * 0); op++; } pb++; - pg++; } } @@ -364,36 +372,30 @@ void fullconnect(const Weight *weight, const pBox *pbox, pBox *outpBox) { // row no trans A's row A'col //cblas_sgemv(CblasRowMajor, CblasNoTrans, weight->selfChannel, weight->lastChannel, 1, weight->pdata, weight->lastChannel, pbox->pdata, 1, 0, outpBox->pdata, 1); vectorXmatrix(pbox->pdata, weight->pdata, - pbox->width * pbox->height * pbox->channel, weight->lastChannel, weight->selfChannel, outpBox->pdata); } -void vectorXmatrix(mydataFmt *matrix, mydataFmt *v, int size, int v_w, int v_h, mydataFmt *p) { +void vectorXmatrix(mydataFmt *matrix, mydataFmt *v, int v_w, int v_h, mydataFmt *p) { for (int i = 0; i < v_h; i++) { p[i] = 0; for (int j = 0; j < v_w; j++) { p[i] += matrix[j] * v[i * v_w + j]; -// cout << p[i] << endl; } -// cout << p[i] << endl; -// p[i] = -0.0735729; -// cout << "...." << endl; -// break; } -// cout << "...." << endl; } void readData(string filename, long dataNumber[], mydataFmt *pTeam[], int length) { ifstream in(filename.data()); string line; + long temp = dataNumber[0]; if (in) { int i = 0; int count = 0; int pos = 0; while (getline(in, line)) { try { - if (i < dataNumber[count]) { + if (i < temp) { line.erase(0, 1); pos = line.find(']'); line.erase(pos, 1); @@ -401,12 +403,14 @@ void readData(string filename, long dataNumber[], mydataFmt *pTeam[], int length if (pos != -1) { line.erase(pos, 1); } - *(pTeam[count])++ = atof(line.data()); + if (dataNumber[count] != 0) { + *(pTeam[count])++ = atof(line.data()); + } } else { count++; if ((length != 0) && (count == length)) break; - dataNumber[count] += dataNumber[count - 1]; + temp += dataNumber[count]; line.erase(0, 1); pos = line.find(']'); line.erase(pos, 1); @@ -414,7 +418,9 @@ void readData(string filename, long dataNumber[], mydataFmt *pTeam[], int length if (pos != -1) { line.erase(pos, 1); } - *(pTeam[count])++ = atof(line.data()); + if (dataNumber[count] != 0) { + *(pTeam[count])++ = atof(line.data()); + } } i++; } @@ -429,19 +435,15 @@ void readData(string filename, long dataNumber[], mydataFmt *pTeam[], int length } // w sc lc ks s p kw kh -long initConvAndFc(struct Weight *weight, int schannel, int lchannel, int kersize, +long ConvAndFcInit(struct Weight *weight, int schannel, int lchannel, int kersize, int stride, int pad, int w, int h, int padw, int padh) { weight->selfChannel = schannel; weight->lastChannel = lchannel; weight->kernelSize = kersize; -// if (kersize == 0) { weight->h = h; weight->w = w; -// } -// if (pad == -1) { weight->padh = padh; weight->padw = padw; -// } weight->stride = stride; weight->pad = pad; weight->pbias = (mydataFmt *) malloc(schannel * sizeof(mydataFmt)); @@ -459,9 +461,114 @@ long initConvAndFc(struct Weight *weight, int schannel, int lchannel, int kersiz return byteLenght; } -void initpRelu(struct pRelu *prelu, int width) { - prelu->width = width; - prelu->pdata = (mydataFmt *) malloc(width * sizeof(mydataFmt)); - if (prelu->pdata == NULL)cout << "prelu apply for memory failed!!!!"; - memset(prelu->pdata, 0, width * sizeof(mydataFmt)); +void conv_mergeInit(pBox *output, pBox *c1, pBox *c2, pBox *c3, pBox *c4) { + output->channel = 0; + output->height = c1->height; + output->width = c1->width; + if (c1 != 0) { + output->channel = c1->channel; + if (c2 != 0) { + output->channel += c2->channel; + if (c3 != 0) { + output->channel += c3->channel; + if (c4 != 0) { + output->channel += c4->channel; + } + } + } + } + output->pdata = (mydataFmt *) malloc(output->width * output->height * output->channel * sizeof(mydataFmt)); + if (output->pdata == NULL)cout << "the conv_mergeInit is failed!!" << endl; + memset(output->pdata, 0, output->width * output->height * output->channel * sizeof(mydataFmt)); +} + +void conv_merge(pBox *output, pBox *c1, pBox *c2, pBox *c3, pBox *c4) { +// cout << "output->channel:" << output->channel << endl; + if (c1 != 0) { + long count1 = c1->height * c1->width * c1->channel; + //output->pdata = c1->pdata; + for (long i = 0; i < count1; i++) { + output->pdata[i] = c1->pdata[i]; + } + if (c2 != 0) { + long count2 = c2->height * c2->width * c2->channel; + for (long i = 0; i < count2; i++) { + output->pdata[count1 + i] = c2->pdata[i]; + } + if (c3 != 0) { + long count3 = c3->height * c3->width * c3->channel; + for (long i = 0; i < count3; i++) { + output->pdata[count1 + count2 + i] = c3->pdata[i]; + } + if (c4 != 0) { + long count4 = c4->height * c4->width * c4->channel; + for (long i = 0; i < count4; i++) { + output->pdata[count1 + count2 + count3 + i] = c4->pdata[i]; + } + } + } + } + } else { cout << "conv_mergeInit" << endl; } +} + +void mulandaddInit(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale) { + outpBox->channel = temppbox->channel; + outpBox->width = temppbox->width; + outpBox->height = temppbox->height; + outpBox->pdata = (mydataFmt *) malloc(outpBox->width * outpBox->height * outpBox->channel * sizeof(mydataFmt)); + if (outpBox->pdata == NULL)cout << "the mulandaddInit is failed!!" << endl; + memset(outpBox->pdata, 0, outpBox->width * outpBox->height * outpBox->channel * sizeof(mydataFmt)); +} + +void mulandadd(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale) { + mydataFmt *ip = inpbox->pdata; + mydataFmt *tp = temppbox->pdata; + mydataFmt *op = outpBox->pdata; + long dis = inpbox->width * inpbox->height * inpbox->channel; + for (long i = 0; i < dis; i++) { + op[i] = ip[i] + tp[i] * scale; + } +} + +void BatchNormInit(struct BN *var, struct BN *mean, struct BN *beta, int width) { + var->width = width; + var->pdata = (mydataFmt *) malloc(width * sizeof(mydataFmt)); + if (var->pdata == NULL)cout << "prelu apply for memory failed!!!!"; + memset(var->pdata, 0, width * sizeof(mydataFmt)); + + mean->width = width; + mean->pdata = (mydataFmt *) malloc(width * sizeof(mydataFmt)); + if (mean->pdata == NULL)cout << "prelu apply for memory failed!!!!"; + memset(mean->pdata, 0, width * sizeof(mydataFmt)); + + beta->width = width; + beta->pdata = (mydataFmt *) malloc(width * sizeof(mydataFmt)); + if (beta->pdata == NULL)cout << "prelu apply for memory failed!!!!"; + memset(beta->pdata, 0, width * sizeof(mydataFmt)); +} + +void BatchNorm(struct pBox *pbox, struct BN *var, struct BN *mean, struct BN *beta) { + if (pbox->pdata == NULL) { + cout << "Relu feature is NULL!!" << endl; + return; + } + if ((var->pdata == NULL) || (mean->pdata == NULL) || (beta->pdata == NULL)) { + cout << "the BatchNorm bias is NULL!!" << endl; + return; + } + mydataFmt *pp = pbox->pdata; + mydataFmt *vp = var->pdata; + mydataFmt *mp = mean->pdata; + mydataFmt *bp = beta->pdata; + int gamma = 1; + float epsilon = 0.001; + long dis = pbox->width * pbox->height; + mydataFmt temp = 0; + for (int channel = 0; channel < pbox->channel; channel++) { + temp = gamma / sqrt(((vp[channel]) + epsilon)); + for (int col = 0; col < dis; col++) { + *pp = temp * (*pp) + ((bp[channel]) - temp * (mp[channel])); + pp++; + } + } } \ No newline at end of file diff --git a/src/network.h b/src/network.h index 543fb32..d7432f7 100644 --- a/src/network.h +++ b/src/network.h @@ -11,7 +11,6 @@ #include #include #include "pBox.h" -//#include using namespace cv; @@ -25,17 +24,15 @@ void avePooling(const pBox *pbox, pBox *Matrix, int kernelSize, int stride); void featurePad(const pBox *pbox, pBox *outpBox, const int pad, const int padw = 0, const int padh = 0); -void prelu(struct pBox *pbox, mydataFmt *pbias, mydataFmt *prelu_gmma); +void relu(struct pBox *pbox, mydataFmt *pbias); void fullconnect(const Weight *weight, const pBox *pbox, pBox *outpBox); void readData(string filename, long dataNumber[], mydataFmt *pTeam[], int length = 0); -long initConvAndFc(struct Weight *weight, int schannel, int lchannel, int kersize, int stride, int pad, +long ConvAndFcInit(struct Weight *weight, int schannel, int lchannel, int kersize, int stride, int pad, int w = 0, int h = 0, int padw = 0, int padh = 0); -void initpRelu(struct pRelu *prelu, int width); - void image2MatrixInit(Mat &image, struct pBox *pbox); void featurePadInit(const pBox *pbox, pBox *outpBox, const int pad, const int padw = 0, const int padh = 0); @@ -48,8 +45,21 @@ void convolutionInit(const Weight *weight, pBox *pbox, pBox *outpBox); void fullconnectInit(const Weight *weight, pBox *outpBox); -void vectorXmatrix(mydataFmt *matrix, mydataFmt *v, int size, int v_w, int v_h, mydataFmt *p); +void vectorXmatrix(mydataFmt *matrix, mydataFmt *v, int v_w, int v_h, mydataFmt *p); void convolution(const Weight *weight, const pBox *pbox, pBox *outpBox); +void MeanAndDev(const Mat &image, mydataFmt &p, mydataFmt &q); + +void conv_merge(pBox *output, pBox *c1 = 0, pBox *c2 = 0, pBox *c3 = 0, pBox *c4 = 0); + +void conv_mergeInit(pBox *output, pBox *c1 = 0, pBox *c2 = 0, pBox *c3 = 0, pBox *c4 = 0); + +void mulandaddInit(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale); + +void mulandadd(const pBox *inpbox, const pBox *temppbox, pBox *outpBox, float scale = 1); + +void BatchNormInit(struct BN *var, struct BN *mean, struct BN *beta, int width); + +void BatchNorm(struct pBox *pbox, struct BN *var, struct BN *mean, struct BN *beta); #endif \ No newline at end of file diff --git a/src/pBox.cpp b/src/pBox.cpp index 32e821a..0969cf4 100644 --- a/src/pBox.cpp +++ b/src/pBox.cpp @@ -22,4 +22,12 @@ void freeWeight(struct Weight *weight) { free(weight->pdata); weight->pdata = NULL; delete weight; -} \ No newline at end of file +} + +void freeBN(struct BN *bn) { + if (bn->pdata == NULL)cout << "weight is NULL!" << endl; + else + free(bn->pdata); + bn->pdata = NULL; + delete bn; +} diff --git a/src/pBox.h b/src/pBox.h index 41ea211..8703500 100644 --- a/src/pBox.h +++ b/src/pBox.h @@ -6,11 +6,14 @@ #include #include +/** + * 声明结构体 + */ + using namespace std; //#define mydataFmt double #define Num 128 -typedef double mydataFmt; - +typedef float mydataFmt; struct pBox : public cv::String { mydataFmt *pdata; @@ -19,12 +22,15 @@ struct pBox : public cv::String { int channel; }; - struct pRelu { mydataFmt *pdata; int width; }; +struct BN { + mydataFmt *pdata; + int width; +}; struct Weight { mydataFmt *pdata; @@ -40,23 +46,21 @@ struct Weight { int padh; }; -class pBox1 { -public: - vector>> pdata; +struct Bbox { + float score; + int x1; + int y1; + int x2; + int y2; + float area; + bool exist; + mydataFmt ppoint[10]; + mydataFmt regreCoord[4]; }; -class pRelu1 { -public: - vector pdata; -}; - -class Weight1 { -public: - vector>>> pdata; - vector pbias; - int stride; - int padw; - int padh; +struct orderScore { + mydataFmt score; + int oriOrder; }; void freepBox(struct pBox *pbox); @@ -65,4 +69,6 @@ void freeWeight(struct Weight *weight); void freepRelu(struct pRelu *prelu); +void freeBN(struct BN *bn); + #endif \ No newline at end of file diff --git a/src/pikaqiu.cpp b/src/pikaqiu.cpp index bd75578..fe90636 100644 --- a/src/pikaqiu.cpp +++ b/src/pikaqiu.cpp @@ -3,52 +3,22 @@ #include int main() { - int b = 0; - if (b == 0) { - Mat image = imread("../1.jpg"); + Mat image = imread("../1.jpg"); // Mat image = imread("../2.png"); - Mat Image; - resize(image, Image, Size(299, 299), 0, 0, cv::INTER_LINEAR); - facenet ggg; - mydataFmt *o = new mydataFmt[Num]; - ggg.run(Image, o, 0); + Mat Image; + resize(image, Image, Size(160, 160), 0, 0, cv::INTER_LINEAR); + facenet ggg; + vector o; + ggg.run(Image, o, 0); // imshow("result", Image); - imwrite("../result.jpg", Image); + imwrite("../result.jpg", Image); - for (int i = 0; i < Num; ++i) { - cout << o[i] << endl; - } - - waitKey(0); - image.release(); - } else { - Mat image; - VideoCapture cap(0); - if (!cap.isOpened()) - cout << "fail to open!" << endl; - cap >> image; - if (!image.data) { - cout << "读取视频失败" << endl; - return -1; - } - - clock_t start; - int stop = 1200; - //while (stop--) { - while (true) { - start = clock(); - cap >> image; - resize(image, image, Size(299, 299), 0, 0, cv::INTER_LINEAR); - facenet ggg; - mydataFmt *o = new mydataFmt[Num]; - ggg.run(image, o, 0); - imshow("result", image); - if (waitKey(1) >= 0) break; - start = clock() - start; - cout << "time is " << (double) start / CLOCKS_PER_SEC * 1000 << "ms" << endl; - } - waitKey(0); - image.release(); + for (int i = 0; i < Num; ++i) { + cout << o[i] << endl; } + + waitKey(0); + image.release(); + return 0; }