Dl4j-fit(DataSetIterator iterator)源码阅读（五）正向传播

蔚落 2022-06-04 05:39 87阅读 0赞

接下来执行的就是`preOutput()`如下的两条语句：

INDArray b = getParam(DefaultParamInitializer.BIAS_KEY);
    INDArray W = getParam(DefaultParamInitializer.WEIGHT_KEY);

用于获取当前层的权重和偏值。之后继续执行的是输入的有效性判断以及是否使用dropoutConnect，当前的网络架构没有使用该种网络，暂时不谈。

//Input validation:
    if (input.rank() != 2 || input.columns() != W.rows()) {
        if (input.rank() != 2) {
            throw new DL4JInvalidInputException("Input that is not a matrix; expected matrix (rank 2), got rank "
                            + input.rank() + " array with shape " + Arrays.toString(input.shape()));
        }
        throw new DL4JInvalidInputException("Input size (" + input.columns() + " columns; shape = "
                        + Arrays.toString(input.shape())
                        + ") is invalid: does not match layer input size (layer # inputs = " + W.size(0) + ")");
    }
    
    if (conf.isUseDropConnect() && training && conf.getLayer().getDropOut() > 0) {
        W = Dropout.applyDropConnect(this, DefaultParamInitializer.WEIGHT_KEY);
    }

再之后执行的就是神经元中最经典且常见的数学公式`y = xw + b`:

INDArray ret = input.mmul(W).addiRowVector(b);

然后就是判断掩码，如果使用掩码，则对计算之后的结果ret进行一个变换。

if (maskArray != null) {
        applyMask(ret);
    }
    
    //掩码对结果变换的实现方式。
    protected void applyMask(INDArray to) {
        to.muliColumnVector(maskArray);
    }

然后此时`preOutput()`方法执行结束，返回上层方法`activate(boolean training)`中：

@Override
    public INDArray activate(boolean training) {
        INDArray z = preOutput(training);
        //INDArray ret = Nd4j.getExecutioner().execAndReturn(Nd4j.getOpFactory().createTransform(
        //        conf.getLayer().getActivationFunction(), z, conf.getExtraArgs() ));
        INDArray ret = conf().getLayer().getActivationFn().getActivation(z, training);
    
        if (maskArray != null) {
            ret.muliColumnVector(maskArray);
        }
    
        return ret;
    }

在`preOutput()`方法中执行了`z = xw + b`，接下来就需要使用如下的方法进行激励函数的变换：

INDArray ret = conf().getLayer().getActivationFn().getActivation(z, training);

等同于`ret = f(z)`。运行之后继续返回上层`activationFromPrevLayer()`\->`feedForwardToLayer()`方法中。

public List<INDArray> feedForwardToLayer(int layerNum, boolean train) {
        INDArray currInput = input;
        List<INDArray> activations = new ArrayList<>();
        activations.add(currInput);
    
        for (int i = 0; i <= layerNum; i++) {
            currInput = activationFromPrevLayer(i, currInput, train);
            //applies drop connect to the activation
            activations.add(currInput);
        }
        return activations;
    }

以上单步的只是一层网络的运行方法，使用for loop不断重复以上流程，并且将中间结果添加到activations中，并进行返回。

##### 2.3.3.2 model.computeGradientAndScore() #####

这里重新粘贴正在执行的代码部分：

List<INDArray> activations = feedForwardToLayer(layers.length - 2, true);
    if (trainingListeners.size() > 0) {
        //TODO: We possibly do want output layer activations in some cases here...
        for (TrainingListener tl : trainingListeners) {
            tl.onForwardPass(this, activations);
        }
    }
    INDArray actSecondLastLayer = activations.get(activations.size() - 1);
    if (layerWiseConfigurations.getInputPreProcess(layers.length - 1) != null)
        actSecondLastLayer = layerWiseConfigurations.getInputPreProcess(layers.length - 1)
                        .preProcess(actSecondLastLayer, getInputMiniBatchSize());
    getOutputLayer().setInput(actSecondLastLayer);
    //Then: compute gradients
    backprop();

此时相当于重新返回到`model.computeGradientAndScore()`方法继续向下执行。

List<INDArray> activations = feedForwardToLayer(layers.length - 2, true);

在这条语句获取到输出层之前的所有层的中间结果之后，执行以下语句：

INDArray actSecondLastLayer = activations.get(activations.size() - 1);

此时`actSecondLastLayer`相当于获取最后一层输出层的输入。  
之后调用一下的语句：

getOutputLayer().setInput(actSecondLastLayer);

设置输出层的输入，然后就进入反向传播环节计算梯度：

backprop();