Java實現(xiàn)BP神經(jīng)網(wǎng)絡MNIST手寫數(shù)字識別的示例詳解

更新時間：2023年01月31日 14:19:35 作者：七·仔

這篇文章主要為大家詳細介紹了Java實現(xiàn)BP神經(jīng)網(wǎng)絡MNIST手寫數(shù)字識別的相關(guān)方法，文中的示例代碼講解詳細，感興趣的小伙伴可以跟隨小編一起了解一下

一、神經(jīng)網(wǎng)絡的構(gòu)建

(1)：構(gòu)建神經(jīng)網(wǎng)絡層次結(jié)構(gòu)

由訓練集數(shù)據(jù)可知，手寫輸入的數(shù)據(jù)維數(shù)為784維，而對應的輸出結(jié)果為分別為0-9的10個數(shù)字，所以根據(jù)訓練集的數(shù)據(jù)可知，在構(gòu)建的神經(jīng)網(wǎng)絡的輸入層的神經(jīng)元的節(jié)點個數(shù)為784個，而對應的輸出層的神經(jīng)元個數(shù)為10個。隱層可選擇單層或多層。

(2)：確定隱層中的神經(jīng)元的個數(shù)

因為對于隱層的神經(jīng)元個數(shù)的確定目前還沒有什么比較完美的解決方案，所以對此經(jīng)過自己查閱書籍和上網(wǎng)查閱資料，有以下的幾種經(jīng)驗方式來確定隱層的神經(jīng)元的個數(shù)，方式分別如下所示：

一般取(輸入+輸出)/2
隱層一般小于輸入層

3）（輸入層+1）/2

log(輸入層)
log(輸入層)+10

實驗得到以第五種的方式得到的測試結(jié)果相對較高。

(3)：設置神經(jīng)元的激活函數(shù)

在《機器學習》的書中介紹了兩種比較常用的函數(shù)，分別是階躍函數(shù)和Sigmoid函數(shù)。最后自己采用了后者函數(shù)。

(4)：初始化輸入層和隱層之間神經(jīng)元間的權(quán)值信息

采用的是使用簡單的隨機數(shù)分配的方法,并且兩層之間的神經(jīng)元權(quán)值是通過二維數(shù)組進行保留，數(shù)組的索引就代表著兩層對應的神經(jīng)元的索引信息

(5)：初始化隱層和輸出層之間神經(jīng)元間的權(quán)值信息

采用的是使用簡單的隨機數(shù)分配的方法,并且兩層之間的神經(jīng)元權(quán)值是通過二維數(shù)組進行保留，數(shù)組的索引就代表著兩層對應的神經(jīng)元的索引信息

(6)：讀取CSV測試集表格信息，并加載到程序用數(shù)據(jù)保存，其中將每個維數(shù)的數(shù)據(jù)都換成了0和1的二進制數(shù)進行處理。

(7)：讀取CSV測試集結(jié)果表格信息，并加載到程序用數(shù)據(jù)保存

(8)：計算輸入層與隱層中隱層神經(jīng)元的閾值

這里主要是采用了下面的方法：

Sum=sum+weight[i][j] * layer0[i];

參數(shù)的含義：將每個輸入層中的神經(jīng)元與神經(jīng)元的權(quán)值信息weight[i][j]乘以對應的輸入層神經(jīng)元的閾值累加，然后再調(diào)用激活函數(shù)得到對應的隱層神經(jīng)元的閾值。

(9)：計算隱層與輸出層中輸出層的神經(jīng)元的閾值

方法和上面的類似，只是相對應的把權(quán)值信息進行了修改即可。

(10)：計算誤差逆?zhèn)鞑ィㄝ敵鰧拥哪嬲`差）

采用書上P103頁的方法（西瓜書）

(11)：計算誤差傳播（隱層的逆誤差）

采用書上P103頁的方法（西瓜書）

(12)：更新各層神經(jīng)元之間的權(quán)值信息

double newVal = momentum * prevWeight[j][i] + eta * delta[i] * layer[j];

參數(shù)：其中設置momentum 為0.9，設置eta 為0.25，prevWeight[j][i]表示神經(jīng)元之間的權(quán)值，layer[j]和delta[i]表示兩層不同神經(jīng)元的閾值。

(13)：循環(huán)迭代訓練5次

(14)：輸入測試集數(shù)據(jù)

(15)：輸出測試集預測結(jié)果和實際結(jié)果進行比較，得到精確度

此處放一個多隱層BP神經(jīng)網(wǎng)絡的類（自己寫的，有錯誤請指出）：

/**
 * BP神經(jīng)網(wǎng)絡類
 * 使用了附加動量法進行優(yōu)化
 * 主要使用方法：
 *     初始化：   BP bp = new BP(new int[]{int,int*n,int})  //第一個int表示輸入層，中間n個int表示隱藏層，最后一個int表示輸出層
 *     訓練： bp.train(double[],double[])               //第一個double[]表示輸入，第二個double[]表示期望輸出
 *     測試       int result = bp.test(double[])            //參數(shù)表示輸入,返回值表示輸出層最大權(quán)值
 *     另有設置學習率和動量參數(shù)方法
 */
import java.util.Random;
 
public class BP {
    
    private final double[][] layers;//輸入層、隱含層、輸出層
    private final double[][] deltas;//每層誤差
    private final double[][][] weights;//權(quán)值
    private final double[][][] prevUptWeights;//更新之前的權(quán)值信息
    private final double[] target;   //預測的輸出內(nèi)容
    
    private double eta;        //學習率
    private double momentum;    //動量參數(shù)
    
    private final Random random;  //主要是對權(quán)值采取的是隨機產(chǎn)生的方法
    
    //初始化
    public BP(int[] size, double eta, double momentum) {
       int len = size.length;
       //初始化每層
       layers = new double[len][];
       for(int i = 0; i<len; i++) {
           layers[i] = new double[size[i] + 1];
       }
       //初始化預測輸出
        target = new double[size[len - 1] + 1];
        
       //初始化隱藏層和輸出層的誤差
       deltas = new double[len - 1][];
       for(int i = 0; i < (len - 1); i++) {
           deltas[i] = new double[size[i + 1] + 1];
       }
       
       //使每次產(chǎn)生的隨機數(shù)都是第一次的分配，這是有參數(shù)和沒參數(shù)的區(qū)別
        random = new Random(100000);
       //初始化權(quán)值
       weights = new double[len - 1][][];
       for(int i = 0; i < (len - 1); i++) {
           weights[i] = new double[size[i] + 1][size[i + 1] + 1];
       }
       randomizeWeights(weights);
       
       //初始化更新前的權(quán)值
       prevUptWeights = new double[len - 1][][];
       for(int i = 0; i < (len - 1); i++) {
           prevUptWeights[i] = new double[size[i] + 1][size[i + 1] + 1];
       }
       
        this.eta = eta;             //學習率
        this.momentum = momentum;   //動態(tài)量
    }
    
    //隨機產(chǎn)生神經(jīng)元之間的權(quán)值信息  
    private void randomizeWeights(double[][][] matrix) {
        for (int i = 0, len = matrix.length; i != len; i++) {
            for (int j = 0, len2 = matrix[i].length; j != len2; j++) {
               for(int k = 0, len3 = matrix[i][j].length; k != len3; k++) {
                   double real = random.nextDouble();    //隨機分配著產(chǎn)生0-1之間的值  
                   matrix[i][j][k] = random.nextDouble() > 0.5 ? real : -real;
               }
            }
        }
    }
    
    //初始化輸入層，隱含層，和輸出層  
    public BP(int[] size) {
        this(size, 0.25, 0.9);
    }
    
    //訓練數(shù)據(jù)
    public void train(double[] trainData, double[] target) {
       loadValue(trainData,layers[0]);       //加載輸入的數(shù)據(jù)
       loadValue(target,this.target);         //加載輸出的結(jié)果數(shù)據(jù)
        forward();                  //向前計算神經(jīng)元權(quán)值(先算輸入到隱含層的，然后再算隱含到輸出層的權(quán)值)
        calculateDelta();           //計算誤差逆?zhèn)鞑ブ?
        adjustWeight();             //調(diào)整更新神經(jīng)元的權(quán)值
    }
 
    //加載數(shù)據(jù)
    private void loadValue(double[] value,double [] layer) {
        if (value.length != layer.length - 1)
            throw new IllegalArgumentException("Size Do Not Match.");
        System.arraycopy(value, 0, layer, 1, value.length);  //調(diào)用系統(tǒng)復制數(shù)組的方法(存放輸入的訓練數(shù)據(jù))
    }
    
    //向前計算(先算輸入到隱含層的，然后再算隱含到輸出層的權(quán)值)
    private void forward() {
       //計算隱含層到輸出層的權(quán)值
       for(int i = 0; i < (layers.length - 1); i++) {
           forward(layers[i], layers[i+1], weights[i]);
       } 
    }
    
    //計算每一層的誤差(因為在BP中，要達到使誤差最小)(就是逆?zhèn)鞑ニ惴?，書上有P101)
    private void calculateDelta() {
        outputErr(deltas[deltas.length-1],layers[layers.length - 1],target);   //計算輸出層的誤差(因為要反過來算，所以先算輸出層的)
        
        for(int i = (layers.length - 1); i > 1; i--) {
            hiddenErr(deltas[i - 2/*輸入層沒有誤差*/],layers[i - 1],deltas[i - 1],weights[i - 1]);   //計算隱含層的誤差
        }
    }
    
     //更新每層中的神經(jīng)元的權(quán)值信息
    private void adjustWeight() {
       for(int i = (layers.length - 1); i > 0; i--) {
            adjustWeight(deltas[i - 1], layers[i - 1], weights[i - 1], prevUptWeights[i - 1]);
       }
    }
    
    //向前計算各個神經(jīng)元的權(quán)值(layer0：某層的數(shù)據(jù),layer1：下一層的內(nèi)容，weight：某層到下一層的神經(jīng)元的權(quán)值)
    private void forward(double[] layer0, double[] layer1, double[][] weight) {
        layer0[0] = 1.0;//給偏置神經(jīng)元賦值為1（實際上添加了layer1層每個神經(jīng)元的闕值）簡直漂亮!!!
        for (int j = 1, len = layer1.length; j != len; ++j) {
            double sum = 0;//保存權(quán)值
            for (int i = 0, len2 = layer0.length; i != len2; ++i) {
               sum += weight[i][j] * layer0[i];
            }
            layer1[j] = sigmoid(sum);  //調(diào)用神經(jīng)元的激活函數(shù)來得到結(jié)果(結(jié)果肯定是在0-1之間的)
        }
    }
    
    //計算輸出層的誤差(delte:誤差，output:輸出，target：預測輸出)
    private void outputErr(double[] delte, double[] output,double[] target) {
        for (int idx = 1, len = delte.length; idx != len; ++idx) {
            double o = output[idx];
            delte[idx] = o * (1d - o) * (target[idx] - o);
        }
    }
    
    //計算隱含層的誤差(delta:本層誤差,layer：本層,delta1：下一層誤差,weights：權(quán)值)
    private void hiddenErr(double[] delta, double[] layer, double[] delta1, double[][] weights) {
        for (int j = 1, len = delta.length; j != len; ++j) {
            double o = layer[j];  //神經(jīng)元權(quán)值
            double sum = 0;
            for (int k = 1, len2 = delta1.length; k != len2; ++k)  //由輸出層來反向計算
                sum += weights[j][k] * delta1[k];
            delta[j] = o * (1d - o) * sum;
        }
    }
    
    //更新每層中的神經(jīng)元的權(quán)值信息(這也就是不斷的訓練過程)
    private void adjustWeight(double[] delta, double[] layer, double[][] weight, double[][] prevWeight) {
        layer[0] = 1;
        for (int i = 1, len = delta.length; i != len; ++i) {
            for (int j = 0, len2 = layer.length; j != len2; ++j) {
               //通過公式計算誤差限=(動態(tài)量*之前的該神經(jīng)元的閾值+學習率*誤差*對應神經(jīng)元的閾值)，來進行更新權(quán)值
                double newVal = momentum * prevWeight[j][i] + eta * delta[i] * layer[j];
                weight[j][i] += newVal;  //得到新的神經(jīng)元之間的權(quán)值
                prevWeight[j][i] = newVal;  //保存這一次得到的權(quán)值，方便下一次進行更新
            }
        }
    }
    
    //我這里用的是sigmoid激活函數(shù)，當然也可以用階躍函數(shù)，看自己選擇吧 
    private double sigmoid(double val) {
        return 1d / (1d + Math.exp(-val));
    }
    
    //測試神經(jīng)網(wǎng)絡
    public int test(double[] inData) {
        if (inData.length != layers[0].length - 1)
            throw new IllegalArgumentException("Size Do Not Match.");
        System.arraycopy(inData, 0, layers[0], 1, inData.length);
        forward();
        return getNetworkOutput();
    }
    
    //返回最后的輸出層的結(jié)果
    private int getNetworkOutput() {
        int len = layers[layers.length - 1].length;
        double[] temp = new double[len - 1];
        for (int i = 1; i != len; i++)
            temp[i - 1] = layers[layers.length - 1][i];
        //獲得最大權(quán)值下標
        double max = temp[0];
        int idx = -1;
        for (int i = 0; i <temp.length; i++) {
            if (temp[i] >= max) {
                max = temp[i];
                idx = i;
            }
        }
        return idx;
    }
    
    //設置學習率
    public void setEta(double eta) {
       this.eta = eta;
    }
    
    //設置動量參數(shù)
    public void setMomentum(double momentum){
       this.momentum = momentum;
    }
}

二、系統(tǒng)架構(gòu)

由于BP神經(jīng)網(wǎng)絡訓練過程時間較長，所以采用客戶端服務器（C/S）的形式，在服務器進行訓練，在客戶端直接進行識別，使用套接字進行通訊。

服務器

客戶端

采用MVC架構(gòu)

Model（模型）表示應用程序核心。
View（視圖）顯示數(shù)據(jù)。
Controller（控制器）處理輸入。

MNIST數(shù)字集經(jīng)過整理存儲在CSV文件中。

以下是系統(tǒng)架構(gòu)：

到此這篇關(guān)于Java實現(xiàn)BP神經(jīng)網(wǎng)絡MNIST手寫數(shù)字識別的示例詳解的文章就介紹到這了,更多相關(guān)Java手寫數(shù)字識別內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: