C++ arma::Cube类代码示例

 void Optimize(arma::Cube<eT>& weights,
               arma::Cube<eT>& gradient,
               arma::Cube<eT>& momWeights)
 {
   for (size_t s = 0; s < weights.n_slices; s++)
     Optimize(weights.slice(s), gradient.slice(s), momWeights.slice(s));
 }

  void Gradient(arma::Cube<eT>& gradient)
  {
    gradient = arma::zeros<arma::Cube<eT> >(weights.n_rows, weights.n_cols,
        weights.n_slices);

    for (size_t outputmap = 0; outputmap < outputLayer.OutputMaps(); outputmap++)
    {
      for (size_t inputmap = 0, s = outputmap; inputmap < inputLayer.OutputMaps();
        inputmap++, s += OutputLayer().OutputMaps())
      {
        arma::Cube<eT> inputSlices = inputLayer.InputActivation().slices(
            inputmap * inputLayer.LayerSlices(), (inputmap + 1) *
            inputLayer.LayerSlices() - 1);

        arma::Cube<eT> deltaSlices = outputLayer.Delta().slices(
            outputmap * inputLayer.LayerSlices(),
            (outputmap + 1) * inputLayer.LayerSlices() - 1);

        arma::Cube<eT> output;
        GradientConvolutionRule::Convolution(inputSlices, deltaSlices, output);

        for (size_t i = 0; i < output.n_slices; i++)
          gradient.slice(s) += output.slice(i);

        gradient.slice(s) /= inputLayer.LayerSlices();
      }
    }
  }

void Rotate180(const arma::Cube<eT>& input, arma::Cube<eT>& output)
{
    output = arma::Cube<eT>(input.n_rows, input.n_cols, input.n_slices);

    // * left-right flip, up-down flip */
    for (size_t s = 0; s < output.n_slices; s++)
        output.slice(s) = arma::fliplr(arma::flipud(input.slice(s)));
}

  void Forward(const arma::Cube<eT>& input, arma::Cube<eT>& output)
  {
    output = arma::zeros<arma::Cube<eT> >(input.n_rows / kSize,
                            input.n_cols / kSize, input.n_slices);

    for (size_t s = 0; s < input.n_slices; s++)
      Pooling(input.slice(s), output.slice(s));
  }

arma::Cube<double> VanillaFeedForward::feedForward(
		const arma::Cube<double>& x) {
	const arma::Mat<double>& weightVector = mW.slice(0);
	const arma::Col<double>& xVector = arma::Col<double>(
			(const double*) x.begin(), x.size());
	;
	const arma::Col<double>& biasVector = mB;
	arma::Col<double> v = weightVector * xVector + biasVector;
	return arma::Cube<double>((const double*) v.begin(), 1, 1, v.size());
}

void
NumericalTestTrialIntegrator<BasisFunctionType, ResultType, GeometryFactory>::
integrate(const std::vector<int> &elementIndices,
          const Shapeset<BasisFunctionType> &testShapeset,
          const Shapeset<BasisFunctionType> &trialShapeset,
          arma::Cube<ResultType> &result) const {
    const size_t pointCount = m_localQuadPoints.n_cols;
    const size_t elementCount = elementIndices.size();

    if (pointCount == 0 || elementCount == 0)
        return;
    // TODO: in the (pathological) case that pointCount == 0 but
    // elementCount != 0, set elements of result to 0.

    // Evaluate constants
    const int testDofCount = testShapeset.size();
    const int trialDofCount = trialShapeset.size();

    BasisData<BasisFunctionType> testBasisData, trialBasisData;
    GeometricalData<CoordinateType> geomData;

    size_t testBasisDeps = 0, trialBasisDeps = 0;
    size_t geomDeps = 0; // INTEGRATION_ELEMENTS;

    m_testTransformations.addDependencies(testBasisDeps, geomDeps);
    m_trialTransformations.addDependencies(trialBasisDeps, geomDeps);
    m_integral.addGeometricalDependencies(geomDeps);

    typedef typename GeometryFactory::Geometry Geometry;
    std::unique_ptr<Geometry> geometry(m_geometryFactory.make());

    CollectionOf3dArrays<BasisFunctionType> testValues, trialValues;

    result.set_size(testDofCount, trialDofCount, elementCount);

    testShapeset.evaluate(testBasisDeps, m_localQuadPoints, ALL_DOFS,
                          testBasisData);
    trialShapeset.evaluate(trialBasisDeps, m_localQuadPoints, ALL_DOFS,
                           trialBasisData);

    // Iterate over the elements
    for (size_t e = 0; e < elementCount; ++e) {
        const int elementIndex = elementIndices[e];
        m_rawGeometry.setupGeometry(elementIndex, *geometry);
        geometry->getData(geomDeps, m_localQuadPoints, geomData);
        if (geomDeps & DOMAIN_INDEX)
            geomData.domainIndex = m_rawGeometry.domainIndex(elementIndex);
        m_testTransformations.evaluate(testBasisData, geomData, testValues);
        m_trialTransformations.evaluate(trialBasisData, geomData, trialValues);

        m_integral.evaluate(geomData, testValues, trialValues, m_quadWeights,
                            result.slice(e));
    }
}

 void Optimize(arma::Cube<eT>& weights,
               arma::Cube<eT>& gradient,
               arma::Cube<eT>& mean,
               arma::Cube<eT>& variance)
 {
   for (size_t s = 0; s < weights.n_slices; s++)
   {
     Optimize(weights.slice(s), gradient.slice(s), mean.slice(s),
         variance.slice(s));
   }
 }

 void Optimize(arma::Cube<eT>& weights,
               arma::Cube<eT>& gradient,
               arma::Cube<eT>& meanSquaredGradient,
               arma::Cube<eT>& meanSquaredGradientDx)
 {
   for (size_t s = 0; s < weights.n_slices; s++)
   {
     Optimize(weights.slice(s), gradient.slice(s), meanSquaredGradient.slice(s),
         meanSquaredGradientDx.slice(s));
   }
 }

  void Backward(const arma::Cube<eT>& /* unused */,
                const arma::Cube<eT>& gy,
                arma::Cube<eT>& g)
  {
    g = arma::zeros<arma::Cube<eT> >(inputParameter.n_rows,
        inputParameter.n_cols, inputParameter.n_slices);

    for (size_t s = 0; s < gy.n_slices; s++)
    {
      Unpooling(inputParameter.slice(s), gy.slice(s), g.slice(s));
    }
  }

  void FeedBackward(const arma::Cube<eT>& error)
  {
    delta = arma::zeros<arma::Cube<eT> >(inputLayer.InputActivation().n_rows,
                                         inputLayer.InputActivation().n_cols,
                                         inputLayer.InputActivation().n_slices);

    for (size_t outputmap = 0; outputmap < inputLayer.OutputMaps(); outputmap++)
    {
      for (size_t inputmap = 0; inputmap < outputLayer.OutputMaps(); inputmap++)
      {
        arma::Cube<eT> errorSlices = error.slices(inputmap *
            inputLayer.LayerSlices(), (inputmap * inputLayer.LayerSlices()) +
            inputLayer.LayerSlices() - 1);

        arma::Mat<eT> rotatedFilter;
        Rotate180(weights.slice(
            outputmap * outputLayer.OutputMaps() + inputmap), rotatedFilter);

        arma::Cube<eT> output;
        BackwardConvolutionRule::Convolution(errorSlices, rotatedFilter, output);

        delta.slices((outputmap * inputLayer.LayerSlices()),
            (outputmap * inputLayer.LayerSlices()) +
            inputLayer.LayerSlices() - 1) += output;
      }
    }
  }

 void Gradient(const arma::Cube<eT>& d, InputDataType& g)
 {
   g = arma::Mat<eT>(weights.n_rows, weights.n_cols);
   for (size_t s = 0; s < d.n_slices; s++)
   {
     g(s) = arma::accu(d.slice(s)) * bias;
   }
 }

 void Forward(const arma::Cube<eT>& input, arma::Cube<eT>& output)
 {
   output = input;
   for (size_t s = 0; s < input.n_slices; s++)
   {
     output.slice(s) += weights(s) * bias;
   }
 }

 void FeedBackward(const arma::Cube<eT>& error)
 {
   for (size_t s = 0; s < error.n_slices; s++)
   {
     Unpooling(inputLayer.InputActivation().slice(s), error.slice(s),
         delta.slice(s));
   }
 }

  static void Convolution(const arma::Cube<eT>& input,
                          const arma::Mat<eT>& filter,
                          arma::Cube<eT>& output)
  {
    arma::Mat<eT> convOutput;
    SVDConvolution<BorderMode>::Convolution(input.slice(0), filter, convOutput);

    output = arma::Cube<eT>(convOutput.n_rows, convOutput.n_cols,
        input.n_slices);
    output.slice(0) = convOutput;

    for (size_t i = 1; i < input.n_slices; i++)
    {
      SVDConvolution<BorderMode>::Convolution(input.slice(i), filter,
          convOutput);
      output.slice(i) = convOutput;
    }
  }

void Forward(const arma::Cube<eT>& input, arma::Cube<eT>& output)
{
    const size_t wConv = ConvOutSize(input.n_rows, wfilter, xStride, wPad);
    const size_t hConv = ConvOutSize(input.n_cols, hfilter, yStride, hPad);

    output = arma::zeros<arma::Cube<eT> >(wConv, hConv, outMaps);
    for (size_t outMap = 0, outMapIdx = 0; outMap < outMaps; outMap++)
    {
        for (size_t inMap = 0; inMap < inMaps; inMap++, outMapIdx++)
        {
            arma::Mat<eT> convOutput;
            ForwardConvolutionRule::Convolution(input.slice(inMap),
                                                weights.slice(outMap), convOutput);

            output.slice(outMap) += convOutput;
        }
    }
}