Java實作BP神經網路MNIST手寫數字識別
如果需要原始碼，請在下方評論區留下郵箱，我看到就會發過去
一、神經網路的構建
(1)：構建神經網路層次結構
由訓練集資料可知，手寫輸入的資料維數為784維，而對應的輸出結果為分別為0-9的10個數字，所以根據訓練集的資料可知，在構建的神經網路的輸入層的神經元的節點個數為784個，而對應的輸出層的神經元個數為10個，隱層可選擇單層或多層，
(2)：確定隱層中的神經元的個數
因為對于隱層的神經元個數的確定目前還沒有什么比較完美的解決方案，所以對此經過自己查閱書籍和上網查閱資料，有以下的幾種經驗方式來確定隱層的神經元的個數，方式分別如下所示：
-
一般取(輸入+輸出)/2
-
隱層一般小于輸入層
3）（輸入層+1）/2
-
log(輸入層)
-
log(輸入層)+10
實驗得到以第五種的方式得到的測驗結果相對較高，
(3)：設定神經元的激活函式
在《機器學習》的書中介紹了兩種比較常用的函式，分別是階躍函式和Sigmoid函式，最后自己采用了后者函式，
(4)：初始化輸入層和隱層之間神經元間的權值資訊
采用的是使用簡單的亂數分配的方法,并且兩層之間的神經元權值是通過二維陣列進行保留，陣列的索引就代表著兩層對應的神經元的索引資訊
(5)：初始化隱層和輸出層之間神經元間的權值資訊
采用的是使用簡單的亂數分配的方法,并且兩層之間的神經元權值是通過二維陣列進行保留，陣列的索引就代表著兩層對應的神經元的索引資訊
(6)：讀取CSV測驗集表格資訊，并加載到程式用資料保存，其中將每個維數的資料都換成了0和1的二進制數進行處理，
(7)：讀取CSV測驗集結果表格資訊，并加載到程式用資料保存
(8)：計算輸入層與隱層中隱層神經元的閾值
這里主要是采用了下面的方法：
Sum=sum+weight[i][j] * layer0[i];
引數的含義：將每個輸入層中的神經元與神經元的權值資訊weight[i][j]乘以對應的輸入層神經元的閾值累加，然后再呼叫激活函式得到對應的隱層神經元的閾值，
(9)：計算隱層與輸出層中輸出層的神經元的閾值
方法和上面的類似，只是相對應的把權值資訊進行了修改即可，
(10)：計算誤差逆傳播（輸出層的逆誤差）
采用書上P103頁的方法（西瓜書）
(11)：計算誤差傳播（隱層的逆誤差）
采用書上P103頁的方法（西瓜書）
(12)：更新各層神經元之間的權值資訊
double newVal = momentum * prevWeight[j][i] + eta * delta[i] * layer[j];
引數：其中設定momentum 為0.9，設定eta 為0.25，prevWeight[j][i]表示神經元之間的權值，layer[j]和delta[i]表示兩層不同神經元的閾值，
(13)：回圈迭代訓練5次
(14)：輸入測驗集資料
(15)：輸出測驗集預測結果和實際結果進行比較，得到精確度
此處放一個多隱層BP神經網路的類（自己寫的，有錯誤請指出）：
/**
* BP神經網路類
* 使用了附加動量法進行優化
* 主要使用方法：
* 初始化： 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[]) //引數表示輸入,回傳值表示輸出層最大權值
* 另有設定學習率和動量引數方法
*/
import java.util.Random;
public class BP {
private final double[][] layers;//輸入層、隱含層、輸出層
private final double[][] deltas;//每層誤差
private final double[][][] weights;//權值
private final double[][][] prevUptWeights;//更新之前的權值資訊
private final double[] target; //預測的輸出內容
private double eta; //學習率
private double momentum; //動量引數
private final Random random; //主要是對權值采取的是隨機產生的方法
//初始化
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];
}
//使每次產生的亂數都是第一次的分配，這是有引數和沒引數的區別
random = new Random(100000);
//初始化權值
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);
//初始化更新前的權值
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; //動態量
}
//隨機產生神經元之間的權值資訊
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(); //隨機分配著產生0-1之間的值
matrix[i][j][k] = random.nextDouble() > 0.5 ? real : -real;
}
}
}
}
//初始化輸入層，隱含層，和輸出層
public BP(int[] size) {
this(size, 0.25, 0.9);
}
//訓練資料
public void train(double[] trainData, double[] target) {
loadValue(trainData,layers[0]); //加載輸入的資料
loadValue(target,this.target); //加載輸出的結果資料
forward(); //向前計算神經元權值(先算輸入到隱含層的，然后再算隱含到輸出層的權值)
calculateDelta(); //計算誤差逆傳播值
adjustWeight(); //調整更新神經元的權值
}
//加載資料
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); //呼叫系統復制陣列的方法(存放輸入的訓練資料)
}
//向前計算(先算輸入到隱含層的，然后再算隱含到輸出層的權值)
private void forward() {
//計算隱含層到輸出層的權值
for(int i = 0; i < (layers.length - 1); i++) {
forward(layers[i], layers[i+1], weights[i]);
}
}
//計算每一層的誤差(因為在BP中，要達到使誤差最小)(就是逆傳播演算法，書上有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]); //計算隱含層的誤差
}
}
//更新每層中的神經元的權值資訊
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]);
}
}
//向前計算各個神經元的權值(layer0：某層的資料,layer1：下一層的內容，weight：某層到下一層的神經元的權值)
private void forward(double[] layer0, double[] layer1, double[][] weight) {
layer0[0] = 1.0;//給偏置神經元賦值為1（實際上添加了layer1層每個神經元的闕值）簡直漂亮!!!
for (int j = 1, len = layer1.length; j != len; ++j) {
double sum = 0;//保存權值
for (int i = 0, len2 = layer0.length; i != len2; ++i) {
sum += weight[i][j] * layer0[i];
}
layer1[j] = sigmoid(sum); //呼叫神經元的激活函式來得到結果(結果肯定是在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：權值)
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]; //神經元權值
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;
}
}
//更新每層中的神經元的權值資訊(這也就是不斷的訓練程序)
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) {
//通過公式計算誤差限=(動態量*之前的該神經元的閾值+學習率*誤差*對應神經元的閾值)，來進行更新權值
double newVal = momentum * prevWeight[j][i] + eta * delta[i] * layer[j];
weight[j][i] += newVal; //得到新的神經元之間的權值
prevWeight[j][i] = newVal; //保存這一次得到的權值，方便下一次進行更新
}
}
}
//我這里用的是sigmoid激活函式，當然也可以用階躍函式，看自己選擇吧
private double sigmoid(double val) {
return 1d / (1d + Math.exp(-val));
}
//測驗神經網路
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();
}
//回傳最后的輸出層的結果
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];
//獲得最大權值下標
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;
}
//設定動量引數
public void setMomentum(double momentum){
this.momentum = momentum;
}
}
二、系統架構
由于BP神經網路訓練程序時間較長，所以采用客戶端服務器（C/S）的形式，在服務器進行訓練，在客戶端直接進行識別，使用套接字進行通訊，
服務器：
客戶端：
采用MVC架構：
-
Model（模型）表示應用程式核心，
-
View（視圖）顯示資料，
-
Controller（控制器）處理輸入，
MNIST數字集經過整理存盤在CSV檔案中，
以下是系統架構：
三、原始碼
如果需要原始碼，請在下方評論區留下郵箱，我看到就會發過去
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542685.html
標籤：其他
上一篇：DDS結構的FPGA實作