public class Net {

	List<DoubleMatrix> weights = new ArrayList<DoubleMatrix>();

	List<DoubleMatrix> bs = new ArrayList<>();

	List<ScalarDifferentiableFunction> activations = new ArrayList<>();

	CostFunctionFactory costFunc;

	CostFunctionFactory accuracyFunc;

	int[] nodesNum;

	int layersNum;

	public Net(int[] nodesNum, ScalarDifferentiableFunction[] activations,CostFunctionFactory costFunc) {

		super();

		this.initNet(nodesNum, activations);

		this.costFunc=costFunc;

		this.layersNum=nodesNum.length-1;

	}

	public Net(int[] nodesNum, ScalarDifferentiableFunction[] activations,CostFunctionFactory costFunc,CostFunctionFactory accuracyFunc) {

		this(nodesNum,activations,costFunc);

		this.accuracyFunc=accuracyFunc;

	}

	public void resetNet() {

		this.initNet(nodesNum, (ScalarDifferentiableFunction[]) activations.toArray());

	}

	private void initNet(int[] nodesNum, ScalarDifferentiableFunction[] activations) {

		assert (nodesNum != null && activations != null

				&& nodesNum.length == activations.length + 1 && nodesNum.length > 1);

		this.nodesNum = nodesNum;

		this.weights.clear();

		this.bs.clear();

		this.activations.clear();

		for (int i = 0; i < nodesNum.length - 1; i++) {

			// 列数==输入；行数==输出。

			int columns = nodesNum[i];

			int rows = nodesNum[i + 1];

			double r1 = Math.sqrt(6) / Math.sqrt(rows + columns + 1);

			//r1=0.001;

			// W

			DoubleMatrix weight = DoubleMatrix.rand(rows, columns).muli(2*r1).subi(r1);

			//weight=DoubleMatrix.ones(rows, columns);

			weights.add(weight);

			// b

			DoubleMatrix b = DoubleMatrix.zeros(rows, 1);

			bs.add(b);

			// activations

			this.activations.add(activations[i]);

		}

	}

}

public class Propagation {

	Net net;

	public Propagation(Net net) {

		super();

		this.net = net;

	}

	// 多个样本。

	public ForwardResult forward(DoubleMatrix input) {

		ForwardResult result = new ForwardResult();

		result.input = input;

		DoubleMatrix currentResult = input;

		int index = -1;

		for (DoubleMatrix weight : net.weights) {

			index++;

			DoubleMatrix b = net.bs.get(index);

			final ScalarDifferentiableFunction activation = net.activations

					.get(index);

			currentResult = weight.mmul(currentResult).addColumnVector(b);

			result.netResult.add(currentResult);

			// 乘以导数

			DoubleMatrix derivative = MatrixUtil.applyNewElements(

					new ScalarFunction() {

						@Override

						public double valueAt(double x) {

							return activation.derivativeAt(x);

						}

					}, currentResult);

			currentResult = MatrixUtil.applyNewElements(activation,

					currentResult);

			result.finalResult.add(currentResult);

			result.derivativeResult.add(derivative);

		}

		result.netResult=null;// 不再需要。

		return result;

	}

    // 多个样本梯度平均值。

	public BackwardResult backward(DoubleMatrix target,

			ForwardResult forwardResult) {

		BackwardResult result = new BackwardResult();

		DoubleMatrix cost = DoubleMatrix.zeros(1,target.columns);

		DoubleMatrix output = forwardResult.finalResult

				.get(forwardResult.finalResult.size() - 1);

		DoubleMatrix outputDelta = DoubleMatrix.zeros(output.rows,

				output.columns);

		DoubleMatrix outputDerivative = forwardResult.derivativeResult

				.get(forwardResult.derivativeResult.size() - 1);

		DoubleMatrix accuracy = null;

		if (net.accuracyFunc != null) {

			accuracy = DoubleMatrix.zeros(1,target.columns);

		}

		for (int i = 0; i < target.columns; i++) {

			CostFunction costFunc = net.costFunc.create(target.getColumn(i)

					.toArray());

			cost.put(i, costFunc.valueAt(output.getColumn(i).toArray()));

			// System.out.println(i);

			DoubleMatrix column1 = new DoubleMatrix(

					costFunc.derivativeAt(output.getColumn(i).toArray()));

			DoubleMatrix column2 = outputDerivative.getColumn(i);

			outputDelta.putColumn(i, column1.muli(column2));

			if (net.accuracyFunc != null) {

				CostFunction accuracyFunc = net.accuracyFunc.create(target

						.getColumn(i).toArray());

				accuracy.put(i,

						accuracyFunc.valueAt(output.getColumn(i).toArray()));

			}

		}

		result.deltas.add(outputDelta);

		result.cost = cost;

		result.accuracy = accuracy;

		for (int i = net.layersNum - 1; i >= 0; i--) {

			DoubleMatrix pdelta = result.deltas.get(result.deltas.size() - 1);

			// 梯度计算，取所有样本平均

			DoubleMatrix layerInput = i == 0 ? forwardResult.input

					: forwardResult.finalResult.get(i - 1);

			DoubleMatrix gradient = pdelta.mmul(layerInput.transpose()).div(

					target.columns);

			result.gradients.add(gradient);

			// 偏置梯度

			result.biasGradients.add(pdelta.rowMeans());

			// 计算前一层delta，若i=0，delta为输入层误差，即input调整梯度，不作平均处理。

			DoubleMatrix delta = net.weights.get(i).transpose().mmul(pdelta);

			if (i > 0)

				delta = delta.muli(forwardResult.derivativeResult.get(i - 1));

			result.deltas.add(delta);

		}

		Collections.reverse(result.gradients);

		Collections.reverse(result.biasGradients);

		//其它的delta都不需要。

		DoubleMatrix inputDeltas=result.deltas.get(result.deltas.size()-1);

		result.deltas.clear();

		result.deltas.add(inputDeltas);

		return result;

	}

	public Net getNet() {

		return net;

	}

}