java实现简单的两层层神经网络算法
java实现简单的两层层神经网络算法
最近学习了神经网络算法，学的过程全部是用python实现的，我平时用java较多，所以我就尝试使用java来实现这个算法，完整代码在我的github地址,java没有numpy，所以我自己实现了一个类专门进行矩阵计算
package com.network.array;
/**
* 此类主要解决矩阵运算方面的数学问题（仅支持2维的运算）
* @author root
*/
public class Array {
// 需要进行运算的数据对象
private double[] data ;
// 矩阵的维度 行
private int h ;
// 矩阵的维度 列
private int w ;
// 用于随即产生矩阵
public static Random random = Random.random ;
// 用于产生一个全部为0的矩阵
public static Zero zero = Zero.zero ;
//给定维度和数据大小创建矩阵
public Array(int w , int maxLength) {
this.w = w ;
this.h = 0 ;
this.data = new double[maxLength] ;
}
// 给定维度创建矩阵
public Array(int w) {
this.w = w ;
this.h = 0 ;
this.data = new double[100] ;
}
// 扩大数组容量
private double[] copyArr(double[] source , int len) {
double[] target = new double[len] ;
System.arraycopy(source, 0, target, 0, source.length);
return target ;
}
// 获取矩阵结构
public int[] shape() {
int[] temp = new int[] {w , h} ;
return temp ;
}
// 重置矩阵结构
public void reshape(int w , int h) {
this.w = w ;
this.h = h ;
}
// 此方法时给矩阵乘法提供的 默认时操作矩阵的最后一位
public void push(int w_index , int h_index , double a) {
// 判断数组大小是否足够
if((h_index)*w + w_index + 1 >= data.length) {
data = copyArr(data, (w*h + 2)*2) ;
}
data[h_index*w + w_index] = a ;
h = h_index+1 ;
}
// 往矩阵中添加数据
public void push(double[] a) throws Exception {
if(a.length != this.w) {
throw new Exception("维度不匹配");
}
// 判断数组大小是否足够
if(w*h + a.length >= data.length) {
data = copyArr(data, (w*h + a.length)*2) ;
}
for(int i=0 ; i<a.length ; i++) {
data[w*h+i] = a[i] ;
}
h++ ;
}
// 往矩阵中添加数据
public void push(Array arr) throws Exception {
int target_w = arr.shape()[0] ;
int target_h = arr.shape()[1] ;
if(target_w != this.w) {
throw new Exception("维度不匹配");
}
double[] target = arr.getData() ;
int size = this.w*this.h ;
// 判断数组大小是否足够
if(w*h + target_w*target_h >= data.length) {
data = copyArr(data, (w*h + target_w*target_h)*2) ;
}
// 将目标数组填入
for(int i = 0 , len = target_w*target_h ; i < len ; i++) {
this.data[size+i] = target[i] ;
}
h += target_h ;
}
// 矩阵点乘
public Array dot(Array arr) throws Exception {
// 判断两个矩阵是否能够相乘
int target_w = arr.shape()[0] ;
int target_h = arr.shape()[1] ;
if(this.w != target_h) {
throw new Exception("矩阵无法相乘");
}
// 当前对象的矩阵数据
double[] source = this.data ;
// 目标对象的矩阵数据
double[] target = arr.getData() ;
// 创建相乘后的矩阵
Array result = new Array(target_w) ;
for(int i = 0 , len = this.h * target_w ; i < len ; i++) {
int temp_w = i%target_w ;
int temp_h = i/target_w ;
// 计算1矩阵i行和2矩阵j列的乘积
double d = 0 ;
for(int j = 0 ; j < this.w ; j++) {
d += source[temp_h*this.w+j]*target[temp_w+j*target_w] ;
}
result.push(temp_w , temp_h , d);
}
return result ;
}
// 矩阵某个维度求和
public Array sum(int axios) {
Array result = null ;
int lenX ;
int lenY ;
if (axios == 0) {
result = new Array(this.w) ;
lenX = this.w ;
lenY = this.h ;
}else {
result = new Array(1) ;
lenX = this.h ;
lenY = this.w ;
}
for(int i = 0 ; i < lenX ; i++) {
double sum = 0 ;
for(int j = 0 ; j < lenY ; j++) {
sum += this.data[axios == 0 ? j*this.w+i : i*this.w+j] ;
}
result.push(axios == 0 ? i : 0 , axios == 0 ? 0 : i , sum);
}
return result ;
}
。。。。。。
代码总共有400多行，所以只粘贴了一部分，完整代码请到我的github下载
上面是神经网络所需要的数学工具类，然后我们来写神经网络算法
前向传播forward
// 训练数据
Array batch_x = xTrain.I(batchMask) ;
// 数据标记
Array batch_t = tTrain.I(batchMask) ;
// 1.前向传播
Array a1 = batch_x.dot(this.w1).add(this.b1) ;
//激活函数sigmoid
Array z1 = a1.sigmoid() ;
Array a2 = z1.dot(this.w2).add(this.b2) ;
//激活函数softmax
Array y = a2.softmax() ;
反向传播backward
// 2.反向传播
// 2.1求softmax函数的反向传播(y - t)
Array dy = y.sub(batch_t).div(batch_x.shape()[1]) ;
// 矩阵点乘的反向传播 输入信号的转置点乘后端传过来的矩阵
Array dw2 = z1.T().dot(dy) ;
Array db2 = dy.sum(0) ;
// 求dx
Array dx = dy.dot(this.w2.T()) ;
// 2.2求sigmoid的反向传播 （1 - y）*y
Array dz = z1.sub(1).mul(-1).mul(z1).mul(dx) ;
Array dw1 = batch_x.T().dot(dz) ;
Array db1 = dz.sum(0) ;
梯度下降
// 更新权值
this.w1 = this.w1.sub(dw1.mul(this.learningRate)) ;
this.b1 = this.b1.sub(db1.mul(this.learningRate)) ;
this.w2 = this.w2.sub(dw2.mul(this.learningRate)) ;
this.b2 = this.b2.sub(db2.mul(this.learningRate)) ;
以上就是核心代码了