求指導(dǎo)，我用你的代碼運(yùn)行一個(gè)不一樣的東西，結(jié)果很失望



import java.util.Random;
public class BpDeep{
    public double[][] layer;//神經(jīng)網(wǎng)絡(luò)各層節(jié)點(diǎn)
    public double[][] layerErr;//神經(jīng)網(wǎng)絡(luò)各節(jié)點(diǎn)誤差
    public double[][][] layer_weight;//各層節(jié)點(diǎn)權(quán)重
    public double[][][] layer_weight_delta;//各層節(jié)點(diǎn)權(quán)重動量
    public double mobp;//動量系數(shù)
    public double rate;//學(xué)習(xí)系數(shù)

    public BpDeep(int[] layernum, double rate, double mobp){
        this.mobp = mobp;
        this.rate = rate;
        layer = new double[layernum.length][];
        layerErr = new double[layernum.length][];
        layer_weight = new double[layernum.length][][];
        layer_weight_delta = new double[layernum.length][][];
        Random random = new Random();
        for(int l=0;l<layernum.length;l++){
            layer[l]=new double[layernum[l]];
            layerErr[l]=new double[layernum[l]];
            if(l+1<layernum.length){
                layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
                layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
                for(int j=0;j<layernum[l]+1;j++)
                    for(int i=0;i<layernum[l+1];i++)
                        layer_weight[l][j][i]=random.nextDouble();//隨機(jī)初始化權(quán)重
            }   
        }
    }
    //逐層向前計(jì)算輸出
    public double[] computeOut(double[] in){
        for(int l=1;l<layer.length;l++){
            for(int j=0;j<layer[l].length;j++){
                double z=layer_weight[l-1][layer[l-1].length][j];
                for(int i=0;i<layer[l-1].length;i++){
                    layer[l-1][i]=l==1?in[i]:layer[l-1][i];
                    z+=layer_weight[l-1][i][j]*layer[l-1][i];
                }
                layer[l][j]=1/(1+Math.exp(-z));
            }
        }
        return layer[layer.length-1];
    }
    //逐層反向計(jì)算誤差并修改權(quán)重
    public void updateWeight(double[] tar){
        int l=layer.length-1;
        for(int j=0;j<layerErr[l].length;j++)
            layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);

        while(l-->0){
            for(int j=0;j<layerErr[l].length;j++){
                double z = 0.0;
                for(int i=0;i<layerErr[l+1].length;i++){
                    z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
                    layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隱含層動量調(diào)整
                    layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隱含層權(quán)重調(diào)整
                    if(j==layerErr[l].length-1){
                        layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距動量調(diào)整
                        layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距權(quán)重調(diào)整
                    }
                }
                layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//記錄誤差
            }
        }
    }

    public void train(double[] in, double[] tar){
        double[] out = computeOut(in);
        updateWeight(tar);
    }
}




import java.util.Arrays;
public class MyBPtest1{
    public static void main(String[] args){
        //初始化神經(jīng)網(wǎng)絡(luò)的基本配置
        //第一個(gè)參數(shù)是一個(gè)整型數(shù)組，表示神經(jīng)網(wǎng)絡(luò)的層數(shù)和每層節(jié)點(diǎn)數(shù)，比如{3,10,10,10,10,2}表示輸入層是3個(gè)節(jié)點(diǎn)，輸出層是2個(gè)節(jié)點(diǎn)，中間有4層隱含層，每層10個(gè)節(jié)點(diǎn)
        /////////第二個(gè)參數(shù)是學(xué)習(xí)步長（過小會使收斂速度太慢；過大則會使預(yù)測不準(zhǔn)，跳過一些細(xì)節(jié)），
            /////////第三個(gè)參數(shù)是動量系數(shù)（使波動小的預(yù)測重新振蕩起來）
        BpDeep bp = new BpDeep(new int[]{5,5,1}, 0.15, 0.9);

        ////////對于輸入樣本如果只有一個(gè)數(shù)。沒關(guān)系，大不了{(lán),}第二項(xiàng)里的data和target全為0,,,,!!!!這理解是錯(cuò)誤
        ////////因?yàn)槲覀冊O(shè)定了輸入層為2，才會有兩個(gè)輸入（{，}，{，}}這樣的東西；同理輸入層也為如此
        ////////所以說如果是5個(gè)輸入，一個(gè)輸出對于data就{{，，，，}，{，，，，}。。。。。。}；；；；；對于target{，，，，}
        double[][] data = new double[][]{{192,195,194,193,193},
                        {195,194,193,193,195},{194,193,193,195,201},
                        {193,193,195,201,205},{193,195,201,205,205},
                        {195,201,205,205,203},{201,205,205,203,203},
                        {205,205,203,203,202},{205,203,203,202,206},
                        {203,203,202,206,204},{203,202,206,204,204},
                        {202,206,204,204,203},{206,204,204,203,199},
                        {204,204,203,199,195},{204,203,199,195,182},
                        {203,199,195,182,179},{199,195,182,179,178},
                        {195,182,179,178,176},{182,179,178,176,175},
                        {179,178,176,175,173},{178,176,175,173,175},
                        {176,175,173,175,182},{175,173,175,182,183},
                        {173,175,182,183,185},{175,182,183,185,179}};
        //設(shè)置目標(biāo)數(shù)據(jù)，對應(yīng)4個(gè)坐標(biāo)數(shù)據(jù)的分類
        double[][] target = new double[][]{{195},{201},{205},{205},{203},
                        {203},{202},{206},{204},{204},{203},{199},{195},{182},{179},
                        {178},{176},{175},{173},{175},{182},{183},{185},{179},{182}};

        //迭代訓(xùn)練5000次
        ///////這里我們沒有設(shè)置訓(xùn)練到了某一精確度自動停止，而是實(shí)打?qū)嵉挠?xùn)練這些次數(shù)
        for(int n=0;n<5000;n++)
            for(int i=0;i<data.length;i++)
                bp.train(data[i], target[i]);

        //根據(jù)訓(xùn)練結(jié)果來檢驗(yàn)樣本數(shù)據(jù)
        for(int j=0;j<data.length;j++){
            double[] result = bp.computeOut(data[j]);
            System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
        }

        //根據(jù)訓(xùn)練結(jié)果來預(yù)測一條新數(shù)據(jù)的分類
        double[] x = new double[]{192,195,194,193,193};
        double[] result = bp.computeOut(x);
        System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
    }
}