• Day 85：网络构建 (代码抄写)

    1. package dl;
    2.  
    3. import java.util.Arrays;
    4. import dl.Dataset.Instance;
    5. import dl.MathUtils.Operator;
    6.  
    7. /**
    8.  * CNN.
    9.  */
    10. public class FullCnn {
    11.     /**
    12.      * The value changes.
    13.      */
    14.     private static double ALPHA = 0.85;
    15.  
    16.     /**
    17.      * A constant.
    18.      */
    19.     public static double LAMBDA = 0;
    20.  
    21.     /**
    22.      * Manage layers.
    23.      */
    24.     private static LayerBuilder layerBuilder;
    25.  
    26.     /**
    27.      * Train using a number of instances simultaneously.
    28.      */
    29.     private int batchSize;
    30.  
    31.     /**
    32.      * Divide the batch size with the given value.
    33.      */
    34.     private Operator divideBatchSize;
    35.  
    36.     /**
    37.      * Multiply alpha with the given value.
    38.      */
    39.     private Operator multiplyAlpha;
    40.  
    41.     /**
    42.      * Multiply lambda and alpha with the given value.
    43.      */
    44.     private Operator multiplyLambda;
    45.  
    46.     /**
    47.      ***********************
    48.      * The first constructor.
    49.      *
    50.      ***********************
    51.      */
    52.     public FullCnn(LayerBuilder paraLayerBuilder, int paraBatchSize) {
    53.         layerBuilder = paraLayerBuilder;
    54.         batchSize = paraBatchSize;
    55.         setup();
    56.         initOperators();
    57.     }// Of the first constructor
    58.  
    59.     /**
    60.      ***********************
    61.      * Initialize operators using temporary classes.
    62.      ***********************
    63.      */
    64.     private void initOperators() {
    65.         divideBatchSize = new Operator() {
    66.             private static final long serialVersionUID = 7424011281732651055L;
    67.  
    68.             @Override
    69.             public double process(double value) {
    70.                 return value / batchSize;
    71.             }// Of process
    72.         };
    73.  
    74.         multiplyAlpha = new Operator() {
    75.             private static final long serialVersionUID = 5761368499808006552L;
    76.  
    77.             @Override
    78.             public double process(double value) {
    79.                 return value * ALPHA;
    80.             }// Of process
    81.         };
    82.  
    83.         multiplyLambda = new Operator() {
    84.             private static final long serialVersionUID = 4499087728362870577L;
    85.  
    86.             @Override
    87.             public double process(double value) {
    88.                 return value * (1 - LAMBDA * ALPHA);
    89.             }// Of process
    90.         };
    91.     }// Of initOperators
    92.  
    93.     /**
    94.      ***********************
    95.      * Setup according to the layer builder.
    96.      ***********************
    97.      */
    98.     public void setup() {
    99.         CnnLayer tempInputLayer = layerBuilder.getLayer(0);
    100.         tempInputLayer.initOutMaps(batchSize);
    101.  
    102.         for (int i = 1; i < layerBuilder.getNumLayers(); i++) {
    103.             CnnLayer tempLayer = layerBuilder.getLayer(i);
    104.             CnnLayer tempFrontLayer = layerBuilder.getLayer(i - 1);
    105.             int tempFrontMapNum = tempFrontLayer.getOutMapNum();
    106.             switch (tempLayer.getType()) {
    107.                 case INPUT:
    108.                     // Should not be input. Maybe an error should be thrown out.
    109.                     break;
    110.                 case CONVOLUTION:
    111.                     tempLayer.setMapSize(
    112.                             tempFrontLayer.getMapSize().subtract(tempLayer.getKernelSize(), 1));
    113.                     tempLayer.initKernel(tempFrontMapNum);
    114.                     tempLayer.initBias();
    115.                     tempLayer.initErrors(batchSize);
    116.                     tempLayer.initOutMaps(batchSize);
    117.                     break;
    118.                 case SAMPLING:
    119.                     tempLayer.setOutMapNum(tempFrontMapNum);
    120.                     tempLayer.setMapSize(tempFrontLayer.getMapSize().divide(tempLayer.getScaleSize()));
    121.                     tempLayer.initErrors(batchSize);
    122.                     tempLayer.initOutMaps(batchSize);
    123.                     break;
    124.                 case OUTPUT:
    125.                     tempLayer.initOutputKernel(tempFrontMapNum, tempFrontLayer.getMapSize());
    126.                     tempLayer.initBias();
    127.                     tempLayer.initErrors(batchSize);
    128.                     tempLayer.initOutMaps(batchSize);
    129.                     break;
    130.             }// Of switch
    131.         } // Of for i
    132.     }// Of setup
    133.  
    134.     /**
    135.      ***********************
    136.      * Forward computing.
    137.      ***********************
    138.      */
    139.     private void forward(Instance instance) {
    140.         setInputLayerOutput(instance);
    141.         for (int l = 1; l < layerBuilder.getNumLayers(); l++) {
    142.             CnnLayer tempCurrentLayer = layerBuilder.getLayer(l);
    143.             CnnLayer tempLastLayer = layerBuilder.getLayer(l - 1);
    144.             switch (tempCurrentLayer.getType()) {
    145.                 case CONVOLUTION:
    146.                     setConvolutionOutput(tempCurrentLayer, tempLastLayer);
    147.                     break;
    148.                 case SAMPLING:
    149.                     setSampOutput(tempCurrentLayer, tempLastLayer);
    150.                     break;
    151.                 case OUTPUT:
    152.                     setConvolutionOutput(tempCurrentLayer, tempLastLayer);
    153.                     break;
    154.                 default:
    155.                     break;
    156.             }// Of switch
    157.         } // Of for l
    158.     }// Of forward
    159.  
    160.     /**
    161.      ***********************
    162.      * Set the in layer output. Given a record, copy its values to the input
    163.      * map.
    164.      ***********************
    165.      */
    166.     private void setInputLayerOutput(Instance paraRecord) {
    167.         CnnLayer tempInputLayer = layerBuilder.getLayer(0);
    168.         Size tempMapSize = tempInputLayer.getMapSize();
    169.         double[] tempAttributes = paraRecord.getAttributes();
    170.         if (tempAttributes.length != tempMapSize.width * tempMapSize.height)
    171.             throw new RuntimeException("input record does not match the map size.");
    172.  
    173.         for (int i = 0; i < tempMapSize.width; i++) {
    174.             for (int j = 0; j < tempMapSize.height; j++) {
    175.                 tempInputLayer.setMapValue(0, i, j, tempAttributes[tempMapSize.height * i + j]);
    176.             } // Of for j
    177.         } // Of for i
    178.     }// Of setInputLayerOutput
    179.  
    180.     /**
    181.      ***********************
    182.      * Compute the convolution output according to the output of the last layer.
    183.      *
    184.      * @param paraLastLayer
    185.      *            the last layer.
    186.      * @param paraLayer
    187.      *            the current layer.
    188.      ***********************
    189.      */
    190.     private void setConvolutionOutput(final CnnLayer paraLayer, final CnnLayer paraLastLayer) {
    191.         // int mapNum = paraLayer.getOutMapNum();
    192.         final int lastMapNum = paraLastLayer.getOutMapNum();
    193.  
    194.         // Attention: paraLayer.getOutMapNum() may not be right.
    195.         for (int j = 0; j < paraLayer.getOutMapNum(); j++) {
    196.             double[][] tempSumMatrix = null;
    197.             for (int i = 0; i < lastMapNum; i++) {
    198.                 double[][] lastMap = paraLastLayer.getMap(i);
    199.                 double[][] kernel = paraLayer.getKernel(i, j);
    200.                 if (tempSumMatrix == null) {
    201.                     // On the first map.
    202.                     tempSumMatrix = MathUtils.convnValid(lastMap, kernel);
    203.                 } else {
    204.                     // Sum up convolution maps
    205.                     tempSumMatrix = MathUtils.matrixOp(MathUtils.convnValid(lastMap, kernel),
    206.                             tempSumMatrix, null, null, MathUtils.plus);
    207.                 } // Of if
    208.             } // Of for i
    209.  
    210.             // Activation.
    211.             final double bias = paraLayer.getBias(j);
    212.             tempSumMatrix = MathUtils.matrixOp(tempSumMatrix, new Operator() {
    213.                 private static final long serialVersionUID = 2469461972825890810L;
    214.  
    215.                 @Override
    216.                 public double process(double value) {
    217.                     return MathUtils.sigmod(value + bias);
    218.                 }
    219.  
    220.             });
    221.  
    222.             paraLayer.setMapValue(j, tempSumMatrix);
    223.         } // Of for j
    224.     }// Of setConvolutionOutput
    225.  
    226.     /**
    227.      ***********************
    228.      * Compute the convolution output according to the output of the last layer.
    229.      *
    230.      * @param paraLastLayer
    231.      *            the last layer.
    232.      * @param paraLayer
    233.      *            the current layer.
    234.      ***********************
    235.      */
    236.     private void setSampOutput(final CnnLayer paraLayer, final CnnLayer paraLastLayer) {
    237.         // int tempLastMapNum = paraLastLayer.getOutMapNum();
    238.  
    239.         // Attention: paraLayer.outMapNum may not be right.
    240.         for (int i = 0; i < paraLayer.outMapNum; i++) {
    241.             double[][] lastMap = paraLastLayer.getMap(i);
    242.             Size scaleSize = paraLayer.getScaleSize();
    243.             double[][] sampMatrix = MathUtils.scaleMatrix(lastMap, scaleSize);
    244.             paraLayer.setMapValue(i, sampMatrix);
    245.         } // Of for i
    246.     }// Of setSampOutput
    247.  
    248.     /**
    249.      ***********************
    250.      * Train the cnn.
    251.      ***********************
    252.      */
    253.     public void train(Dataset paraDataset, int paraRounds) {
    254.         for (int t = 0; t < paraRounds; t++) {
    255.             System.out.println("Iteration: " + t);
    256.             int tempNumEpochs = paraDataset.size() / batchSize;
    257.             if (paraDataset.size() % batchSize != 0)
    258.                 tempNumEpochs++;
    259.             // logger.info("第{}次迭代，epochsNum: {}", t, epochsNum);
    260.             double tempNumCorrect = 0;
    261.             int tempCount = 0;
    262.             for (int i = 0; i < tempNumEpochs; i++) {
    263.                 int[] tempRandomPerm = MathUtils.randomPerm(paraDataset.size(), batchSize);
    264.                 CnnLayer.prepareForNewBatch();
    265.  
    266.                 for (int index : tempRandomPerm) {
    267.                     boolean isRight = train(paraDataset.getInstance(index));
    268.                     if (isRight)
    269.                         tempNumCorrect++;
    270.                     tempCount++;
    271.                     CnnLayer.prepareForNewRecord();
    272.                 } // Of for index
    273.  
    274.                 updateParameters();
    275.                 if (i % 50 == 0) {
    276.                     System.out.print("..");
    277.                     if (i + 50 > tempNumEpochs)
    278.                         System.out.println();
    279.                 }
    280.             }
    281.             double p = 1.0 * tempNumCorrect / tempCount;
    282.             if (t % 10 == 1 && p > 0.96) {
    283.                 ALPHA = 0.001 + ALPHA * 0.9;
    284.                 // logger.info("设置 alpha = {}", ALPHA);
    285.             } // Of iff
    286.             System.out.println("Training precision: " + p);
    287.             // logger.info("计算精度： {}/{}={}.", right, count, p);
    288.         } // Of for i
    289.     }// Of train
    290.  
    291.     /**
    292.      ***********************
    293.      * Train the cnn with only one record.
    294.      *
    295.      * @param paraRecord
    296.      *            The given record.
    297.      ***********************
    298.      */
    299.     private boolean train(Instance paraRecord) {
    300.         forward(paraRecord);
    301.         boolean result = backPropagation(paraRecord);
    302.         return result;
    303.     }// Of train
    304.  
    305.     /**
    306.      ***********************
    307.      * Back-propagation.
    308.      *
    309.      * @param paraRecord
    310.      *            The given record.
    311.      ***********************
    312.      */
    313.     private boolean backPropagation(Instance paraRecord) {
    314.         boolean result = setOutputLayerErrors(paraRecord);
    315.         setHiddenLayerErrors();
    316.         return result;
    317.     }// Of backPropagation
    318.  
    319.     /**
    320.      ***********************
    321.      * Update parameters.
    322.      ***********************
    323.      */
    324.     private void updateParameters() {
    325.         for (int l = 1; l < layerBuilder.getNumLayers(); l++) {
    326.             CnnLayer layer = layerBuilder.getLayer(l);
    327.             CnnLayer lastLayer = layerBuilder.getLayer(l - 1);
    328.             switch (layer.getType()) {
    329.                 case CONVOLUTION:
    330.                 case OUTPUT:
    331.                     updateKernels(layer, lastLayer);
    332.                     updateBias(layer, lastLayer);
    333.                     break;
    334.                 default:
    335.                     break;
    336.             }// Of switch
    337.         } // Of for l
    338.     }// Of updateParameters
    339.  
    340.     /**
    341.      ***********************
    342.      * Update bias.
    343.      ***********************
    344.      */
    345.     private void updateBias(final CnnLayer paraLayer, CnnLayer paraLastLayer) {
    346.         final double[][][][] errors = paraLayer.getErrors();
    347.         // int mapNum = paraLayer.getOutMapNum();
    348.  
    349.         // Attention: getOutMapNum() may not be correct.
    350.         for (int j = 0; j < paraLayer.getOutMapNum(); j++) {
    351.             double[][] error = MathUtils.sum(errors, j);
    352.             double deltaBias = MathUtils.sum(error) / batchSize;
    353.             double bias = paraLayer.getBias(j) + ALPHA * deltaBias;
    354.             paraLayer.setBias(j, bias);
    355.         } // Of for j
    356.     }// Of updateBias
    357.  
    358.     /**
    359.      ***********************
    360.      * Update kernels.
    361.      ***********************
    362.      */
    363.     private void updateKernels(final CnnLayer paraLayer, final CnnLayer paraLastLayer) {
    364.         // int mapNum = paraLayer.getOutMapNum();
    365.         int tempLastMapNum = paraLastLayer.getOutMapNum();
    366.  
    367.         // Attention: getOutMapNum() may not be right
    368.         for (int j = 0; j < paraLayer.getOutMapNum(); j++) {
    369.             for (int i = 0; i < tempLastMapNum; i++) {
    370.                 double[][] tempDeltaKernel = null;
    371.                 for (int r = 0; r < batchSize; r++) {
    372.                     double[][] error = paraLayer.getError(r, j);
    373.                     if (tempDeltaKernel == null)
    374.                         tempDeltaKernel = MathUtils.convnValid(paraLastLayer.getMap(r, i), error);
    375.                     else {
    376.                         tempDeltaKernel = MathUtils.matrixOp(
    377.                                 MathUtils.convnValid(paraLastLayer.getMap(r, i), error),
    378.                                 tempDeltaKernel, null, null, MathUtils.plus);
    379.                     } // Of if
    380.                 } // Of for r
    381.  
    382.                 tempDeltaKernel = MathUtils.matrixOp(tempDeltaKernel, divideBatchSize);
    383.                 if (!rangeCheck(tempDeltaKernel, -10, 10)) {
    384.                     System.exit(0);
    385.                 } // Of if
    386.                 double[][] kernel = paraLayer.getKernel(i, j);
    387.                 tempDeltaKernel = MathUtils.matrixOp(kernel, tempDeltaKernel, multiplyLambda,
    388.                         multiplyAlpha, MathUtils.plus);
    389.                 paraLayer.setKernel(i, j, tempDeltaKernel);
    390.             } // Of for i
    391.         } // Of for j
    392.     }// Of updateKernels
    393.  
    394.     /**
    395.      ***********************
    396.      * Set errors of all hidden layers.
    397.      ***********************
    398.      */
    399.     private void setHiddenLayerErrors() {
    400.         // System.out.println("setHiddenLayerErrors");
    401.         for (int l = layerBuilder.getNumLayers() - 2; l > 0; l--) {
    402.             CnnLayer layer = layerBuilder.getLayer(l);
    403.             CnnLayer nextLayer = layerBuilder.getLayer(l + 1);
    404.             // System.out.println("layertype = " + layer.getType());
    405.             switch (layer.getType()) {
    406.                 case SAMPLING:
    407.                     setSamplingErrors(layer, nextLayer);
    408.                     break;
    409.                 case CONVOLUTION:
    410.                     setConvolutionErrors(layer, nextLayer);
    411.                     break;
    412.                 default:
    413.                     break;
    414.             }// Of switch
    415.         } // Of for l
    416.     }// Of setHiddenLayerErrors
    417.  
    418.     /**
    419.      ***********************
    420.      * Set errors of a sampling layer.
    421.      ***********************
    422.      */
    423.     private void setSamplingErrors(final CnnLayer paraLayer, final CnnLayer paraNextLayer) {
    424.         // int mapNum = layer.getOutMapNum();
    425.         int tempNextMapNum = paraNextLayer.getOutMapNum();
    426.         // Attention: getOutMapNum() may not be correct
    427.         for (int i = 0; i < paraLayer.getOutMapNum(); i++) {
    428.             double[][] sum = null;
    429.             for (int j = 0; j < tempNextMapNum; j++) {
    430.                 double[][] nextError = paraNextLayer.getError(j);
    431.                 double[][] kernel = paraNextLayer.getKernel(i, j);
    432.                 if (sum == null) {
    433.                     sum = MathUtils.convnFull(nextError, MathUtils.rot180(kernel));
    434.                 } else {
    435.                     sum = MathUtils.matrixOp(
    436.                             MathUtils.convnFull(nextError, MathUtils.rot180(kernel)), sum, null,
    437.                             null, MathUtils.plus);
    438.                 } // Of if
    439.             } // Of for j
    440.             paraLayer.setError(i, sum);
    441.  
    442.             if (!rangeCheck(sum, -2, 2)) {
    443.                 System.out.println(
    444.                         "setSampErrors, error out of range.\r\n" + Arrays.deepToString(sum));
    445.             } // Of if
    446.         } // Of for i
    447.     }// Of setSamplingErrors
    448.  
    449.     /**
    450.      ***********************
    451.      * Set errors of a sampling layer.
    452.      ***********************
    453.      */
    454.     private void setConvolutionErrors(final CnnLayer paraLayer, final CnnLayer paraNextLayer) {
    455.         // System.out.println("setConvErrors");
    456.         for (int m = 0; m < paraLayer.getOutMapNum(); m++) {
    457.             Size tempScale = paraNextLayer.getScaleSize();
    458.             double[][] tempNextLayerErrors = paraNextLayer.getError(m);
    459.             double[][] tempMap = paraLayer.getMap(m);
    460.             double[][] tempOutMatrix = MathUtils.matrixOp(tempMap, MathUtils.cloneMatrix(tempMap),
    461.                     null, MathUtils.one_value, MathUtils.multiply);
    462.             tempOutMatrix = MathUtils.matrixOp(tempOutMatrix,
    463.                     MathUtils.kronecker(tempNextLayerErrors, tempScale), null, null,
    464.                     MathUtils.multiply);
    465.             paraLayer.setError(m, tempOutMatrix);
    466.  
    467.             // System.out.println("range check nextError");
    468.             if (!rangeCheck(tempNextLayerErrors, -10, 10)) {
    469.                 System.out.println("setConvErrors, nextError out of range:\r\n"
    470.                         + Arrays.deepToString(tempNextLayerErrors));
    471.                 System.out.println("the new errors are:\r\n" + Arrays.deepToString(tempOutMatrix));
    472.  
    473.                 System.exit(0);
    474.             } // Of if
    475.  
    476.             if (!rangeCheck(tempOutMatrix, -10, 10)) {
    477.                 System.out.println("setConvErrors, error out of range.");
    478.                 System.exit(0);
    479.             } // Of if
    480.         } // Of for m
    481.     }// Of setConvolutionErrors
    482.  
    483.     /**
    484.      ***********************
    485.      * Set errors of a sampling layer.
    486.      ***********************
    487.      */
    488.     private boolean setOutputLayerErrors(Instance paraRecord) {
    489.         CnnLayer tempOutputLayer = layerBuilder.getOutputLayer();
    490.         int tempMapNum = tempOutputLayer.getOutMapNum();
    491.  
    492.         double[] tempTarget = new double[tempMapNum];
    493.         double[] tempOutMaps = new double[tempMapNum];
    494.         for (int m = 0; m < tempMapNum; m++) {
    495.             double[][] outmap = tempOutputLayer.getMap(m);
    496.             tempOutMaps[m] = outmap[0][0];
    497.         } // Of for m
    498.  
    499.         int tempLabel = paraRecord.getLabel().intValue();
    500.         tempTarget[tempLabel] = 1;
    501.         // Log.i(record.getLable() + "outmaps:" +
    502.         // Util.fomart(outmaps)
    503.         // + Arrays.toString(target));
    504.         for (int m = 0; m < tempMapNum; m++) {
    505.             tempOutputLayer.setError(m, 0, 0,
    506.                     tempOutMaps[m] * (1 - tempOutMaps[m]) * (tempTarget[m] - tempOutMaps[m]));
    507.         } // Of for m
    508.  
    509.         return tempLabel == MathUtils.getMaxIndex(tempOutMaps);
    510.     }// Of setOutputLayerErrors
    511.  
    512.     /**
    513.      ***********************
    514.      * Setup the network.
    515.      ***********************
    516.      */
    517.     public void setup(int paraBatchSize) {
    518.         CnnLayer tempInputLayer = layerBuilder.getLayer(0);
    519.         tempInputLayer.initOutMaps(paraBatchSize);
    520.  
    521.         for (int i = 1; i < layerBuilder.getNumLayers(); i++) {
    522.             CnnLayer tempLayer = layerBuilder.getLayer(i);
    523.             CnnLayer tempLastLayer = layerBuilder.getLayer(i - 1);
    524.             int tempLastMapNum = tempLastLayer.getOutMapNum();
    525.             switch (tempLayer.getType()) {
    526.                 case INPUT:
    527.                     break;
    528.                 case CONVOLUTION:
    529.                     tempLayer.setMapSize(
    530.                             tempLastLayer.getMapSize().subtract(tempLayer.getKernelSize(), 1));
    531.                     tempLayer.initKernel(tempLastMapNum);
    532.                     tempLayer.initBias();
    533.                     tempLayer.initErrors(paraBatchSize);
    534.                     tempLayer.initOutMaps(paraBatchSize);
    535.                     break;
    536.                 case SAMPLING:
    537.                     tempLayer.setOutMapNum(tempLastMapNum);
    538.                     tempLayer.setMapSize(tempLastLayer.getMapSize().divide(tempLayer.getScaleSize()));
    539.                     tempLayer.initErrors(paraBatchSize);
    540.                     tempLayer.initOutMaps(paraBatchSize);
    541.                     break;
    542.                 case OUTPUT:
    543.                     tempLayer.initOutputKernel(tempLastMapNum, tempLastLayer.getMapSize());
    544.                     tempLayer.initBias();
    545.                     tempLayer.initErrors(paraBatchSize);
    546.                     tempLayer.initOutMaps(paraBatchSize);
    547.                     break;
    548.             }// Of switch
    549.         } // Of for i
    550.     }// Of setup
    551.  
    552.     /**
    553.      ***********************
    554.      * Predict for the dataset.
    555.      ***********************
    556.      */
    557.     public int[] predict(Dataset paraDataset) {
    558.         System.out.println("Predicting ... ");
    559.         CnnLayer.prepareForNewBatch();
    560.  
    561.         int[] resultPredictions = new int[paraDataset.size()];
    562.         double tempCorrect = 0.0;
    563.  
    564.         Instance tempRecord;
    565.         for (int i = 0; i < paraDataset.size(); i++) {
    566.             tempRecord = paraDataset.getInstance(i);
    567.             forward(tempRecord);
    568.             CnnLayer outputLayer = layerBuilder.getOutputLayer();
    569.  
    570.             int tempMapNum = outputLayer.getOutMapNum();
    571.             double[] tempOut = new double[tempMapNum];
    572.             for (int m = 0; m < tempMapNum; m++) {
    573.                 double[][] outmap = outputLayer.getMap(m);
    574.                 tempOut[m] = outmap[0][0];
    575.             } // Of for m
    576.  
    577.             resultPredictions[i] = MathUtils.getMaxIndex(tempOut);
    578.             if (resultPredictions[i] == tempRecord.getLabel().intValue()) {
    579.                 tempCorrect++;
    580.             } // Of if
    581.         } // Of for
    582.  
    583.         System.out.println("Accuracy: " + tempCorrect / paraDataset.size());
    584.         return resultPredictions;
    585.     }// Of predict
    586.  
    587.     /**
    588.      ***********************
    589.      * Range check, only for debugging.
    590.      *
    591.      * @param paraMatrix
    592.      *            The given matrix.
    593.      * @param paraLowerBound
    594.      * @param paraUpperBound
    595.      ***********************
    596.      */
    597.     public boolean rangeCheck(double[][] paraMatrix, double paraLowerBound, double paraUpperBound) {
    598.         for (int i = 0; i < paraMatrix.length; i++) {
    599.             for (int j = 0; j < paraMatrix[0].length; j++) {
    600.                 if ((paraMatrix[i][j] < paraLowerBound) || (paraMatrix[i][j] > paraUpperBound)) {
    601.                     System.out.println("" + paraMatrix[i][j] + " out of range (" + paraLowerBound
    602.                             + ", " + paraUpperBound + ")\r\n");
    603.                     return false;
    604.                 } // Of if
    605.             } // Of for j
    606.         } // Of for i
    607.  
    608.         return true;
    609.     }// Of rangeCheck
    610.  
    611.     /**
    612.      ***********************
    613.      * The main entrance.
    614.      ***********************
    615.      */
    616.     public static void main(String[] args) {
    617.         LayerBuilder builder = new LayerBuilder();
    618.         // Input layer, the maps are 28*28
    619.         builder.addLayer(new CnnLayer(LayerTypeEnum.INPUT, -1, new Size(28, 28)));
    620.         // Convolution output has size 24*24, 24=28+1-5
    621.         builder.addLayer(new CnnLayer(LayerTypeEnum.CONVOLUTION, 6, new Size(5, 5)));
    622.         // Sampling output has size 12*12,12=24/2
    623.         builder.addLayer(new CnnLayer(LayerTypeEnum.SAMPLING, -1, new Size(2, 2)));
    624.         // Convolution output has size 8*8, 8=12+1-5
    625.         builder.addLayer(new CnnLayer(LayerTypeEnum.CONVOLUTION, 12, new Size(5, 5)));
    626.         // Sampling output has size4×4,4=8/2
    627.         builder.addLayer(new CnnLayer(LayerTypeEnum.SAMPLING, -1, new Size(2, 2)));
    628.         // output layer, digits 0 - 9.
    629.         builder.addLayer(new CnnLayer(LayerTypeEnum.OUTPUT, 10, null));
    630.         // Construct the full CNN.
    631.         FullCnn tempCnn = new FullCnn(builder, 10);
    632.  
    633.         Dataset tempTrainingSet = new Dataset("C:\\Users\\86183\\IdeaProjects\\deepLearning\\src\\main\\java\\resources\\train.format", ",", 784);
    634.  
    635.         // Train the model.
    636.         tempCnn.train(tempTrainingSet, 10);
    637.         // tempCnn.predict(tempTrainingSet);
    638.     }// Of main
    639. }// Of class FullCnn

    结果：

  • 相关阅读:
    Mediapipe 实现3D人脸检测
    JAVA毕业设计航空订票系统计算机源码+lw文档+系统+调试部署+数据库
    Stream竟然还有应用进阶学习？作为程序员的你知道吗
    Spring Boot国际化&&AcceptHeaderLocaleResolver 解析器
    13 redis中的复制的拓扑结构
    【每日一题Day35】LC878第N个神奇数字 | 二分查找 找规律 + 数学
    Redis不止能存储字符串，还有List、Set、Hash、Zset，用对了能给你带来哪些优势？
    Verasity Tokenomics — 社区讨论总结与下一步计划
    MACOS查看硬盘读写量
    聊天功能演示系统发布后出现有些页面滚动与鼠标点击问题解决
  • 原文地址：https://blog.csdn.net/Chunghyyn/article/details/132572110