如何用70行Java代码实现深度神经网络算法

import java.util.Random;

网站的建设成都创新互联公司专注网站定制,经验丰富,不做模板,主营网站定制开发.小程序定制开发,H5页面制作!给你焕然一新的设计体验!已为宴会酒店设计等企业提供专业服务。

public class BpDeep{

public double[][] layer;//神经网络各层节点

public double[][] layerErr;//神经网络各节点误差

public double[][][] layer_weight;//各层节点权重

public double[][][] layer_weight_delta;//各层节点权重动量

public double mobp;//动量系数

public double rate;//学习系数

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;llayernum.length;l++){

layer[l]=new double[layernum[l]];

layerErr[l]=new double[layernum[l]];

if(l+1layernum.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;jlayernum[l]+1;j++)

for(int i=0;ilayernum[l+1];i++)

layer_weight[l][j][i]=random.nextDouble();//随机初始化权重

}

}

}

//逐层向前计算输出

public double[] computeOut(double[] in){

for(int l=1;llayer.length;l++){

for(int j=0;jlayer[l].length;j++){

double z=layer_weight[l-1][layer[l-1].length][j];

for(int i=0;ilayer[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];

}

//逐层反向计算误差并修改权重

public void updateWeight(double[] tar){

int l=layer.length-1;

for(int j=0;jlayerErr[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;jlayerErr[l].length;j++){

double z = 0.0;

for(int i=0;ilayerErr[l+1].length;i++){

z=z+l0?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];//隐含层动量调整

layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整

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];//截距动量调整

layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整

}

}

layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差

}

}

}

public void train(double[] in, double[] tar){

double[] out = computeOut(in);

updateWeight(tar);

}

}

参考资料

用java言语编写一个遍历硬盘里面后缀名为.java的文件名。

import java.io.File;

import java.io.FileFilter;

import java.util.ArrayList;

import java.util.List;

public class Test {

public static void main(String[] args) {

//用来保存java文件的名字的list

ListString javaFilelist = new ArrayListString();

String filePath = "C://111"; //要测试的文件，如果是分区，必须是C://这样子的

getAllFiles(new File(filePath), javaFilelist);

if(javaFilelist.size() == 0){

System.out.println("No java file found under " + filePath);

}

System.out.println("Java file list in " + filePath);

for(String javaFileName: javaFilelist){

System.out.println(javaFileName);

}

}

public static void getAllFiles(File path, ListString list){

if(path.isFile()){//如果是文件

if(path.getName().matches("^.+\\.java$")){//用正则表达式并且是java文件加入list

list.add(path.getAbsolutePath());

}

}else{//这里加入一个过滤，过滤掉非java文件，只保留java文件和文件夹

File[] fileAry = path.listFiles(new JavaFileFilter());

if(fileAry == null || fileAry.length == 0){

return;

}

for(File file: fileAry){

getAllFiles(file, list);

}

}

}

}

class JavaFileFilter implements FileFilter{

public boolean accept(File pathname) {

if(pathname.isDirectory()){//如果是目录也接受

return true;

}else{//如果是java文件，才接受

return pathname.getName().matches("^.+\\.java$");

}

}

}

-------------

测试文件夹下所有文件及其文件夹，输出应该只有4个文件，11.java, 444.java, test.java, 222.java

C:\111tree /F

Folder PATH listi

Volume serial num

C:.

│ 11.java

│ abdef.txt

│

├—2

│ 444.java

│ test.java

│

└—3

│ 222.java

│

└—2.java

--------程序输出

Java file list in C://111

C:\111\11.java

C:\111\2\444.java

C:\111\2\test.java

C:\111\3\222.java

关于用java遍历集合的算法

public static void main(String[] args) {

ListA list=new ArrayListA();

list.add(new A(1,1,0));

list.add(new A(2,2,1));

list.add(new A(3,3,1));

list.add(new A(4,4,2));

list.add(new A(5,5,2));

list.add(new A(6,6,3));

list.add(new A(7,7,3));

list.add(new A(8,8,4));

list.add(new A(9,9,5));

diayong(list,2);

}

private static void diayong(ListAlist,int i) {

// TODO Auto-generated method stub

for (A a : list) {

if(a.did==i){

System.out.println(a.id);

diayong(list,a.id);

}

}

}

输出结果 4 8 5 9 先找到等于2的第一次 4 然后找等于4的 8 然后没有了 再循环找到等于 2的 5 然后找到9 以此类推 不知道 是不是你要的

java 深度优先搜索（回溯法）求集合的幂集

import java.util.ArrayList;

import java.util.List;

public class BackTrack {

public static void main(String[] args) {

//初始化一个集合，放在list里面

ListString list=new ArrayListString();

list.add("1");

list.add("2");

list.add("3");

list.add("f");

ListString li=new ArrayListString();

PowerSet(0,list,li);

}

//回溯法求幂集

public static void PowerSet(int i,ListString list,ListString li){

if(ilist.size()-1){System.out.println(li);}

else{

li.add(list.get(i));//左加

PowerSet(i+1,list,li); //递归方法

li.remove(list.get(i)); //右去

PowerSet(i+1, list, li);

}

}

}

注：该方法采用中序遍历二叉树（实际这棵树是不存在的）。对于第一个元素，左节点加进去，右节点去掉。对于第i一个节点，左加，右去。直到i大于元素的总个数。

输出结果：

[1, 2, 3, 4]

[1, 2, 3]

[1, 2, 4]

[1, 2]

[1, 3, 4]

[1, 3]

[1, 4]

[1]

[2, 3, 4]

[2, 3]

[2, 4]

[2]

[3, 4]

[3]

[4]

[]

图的遍历算法java解决方案

二叉树具有以下重要性质：

性质1 二叉树第i层上的结点数目最多为2i-1(i≥1)。

证明：用数学归纳法证明：

归纳基础：i=1时，有2i-1=20=1。因为第1层上只有一个根结点，所以命题成立。

归纳假设：假设对所有的j(1≤ji)命题成立，即第j层上至多有2j-1个结点，证明j=i时命题亦成立。

归纳步骤：根据归纳假设，第i-1层上至多有2i-2个结点。由于二叉树的每个结点至多有两个孩子，故第i层上的结点数至多是第i-1层上的最大结点数的2倍。即j=i时，该层上至多有2×2i-2=2i-1个结点，故命题成立。

性质2 深度为k的二叉树至多有2k-1个结点(k≥1)。

证明：在具有相同深度的二叉树中，仅当每一层都含有最大结点数时，其树中结点数最多。因此利用性质1可得，深度为k的二叉树的结点数至多为：

20+21+…+2k-1=2k-1

故命题正确。

性质3 在任意-棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则no=n2+1。

证明：因为二叉树中所有结点的度数均不大于2，所以结点总数(记为n)应等于0度结点数、1度结点(记为n1)和2度结点数之和：

n=no+n1+n2 (式子1)

另一方面，1度结点有一个孩子，2度结点有两个孩子，故二叉树中孩子结点总数是：

nl+2n2

树中只有根结点不是任何结点的孩子，故二叉树中的结点总数又可表示为：

n=n1+2n2+1 (式子2)

由式子1和式子2得到：

no=n2+1

满二叉树和完全二叉树是二叉树的两种特殊情形。

1、满二叉树(FullBinaryTree)

一棵深度为k且有2k-1个结点的二又树称为满二叉树。

满二叉树的特点：

（1） 每一层上的结点数都达到最大值。即对给定的高度，它是具有最多结点数的二叉树。

（2） 满二叉树中不存在度数为1的结点，每个分支结点均有两棵高度相同的子树，且树叶都在最下一层上。

【例】图(a)是一个深度为4的满二叉树。

2、完全二叉树(Complete BinaryTree)

若一棵二叉树至多只有最下面的两层上结点的度数可以小于2，并且最下一层上的结点都集中在该层最左边的若干位置上，则此二叉树称为完全二叉树。

特点：

（1） 满二叉树是完全二叉树，完全二叉树不一定是满二叉树。

（2） 在满二叉树的最下一层上，从最右边开始连续删去若干结点后得到的二叉树仍然是一棵完全二叉树。

（3） 在完全二叉树中，若某个结点没有左孩子，则它一定没有右孩子，即该结点必是叶结点。

【例】如图(c)中，结点F没有左孩子而有右孩子L，故它不是一棵完全二叉树。

【例】图(b)是一棵完全二叉树。

性质4 具有n个结点的完全二叉树的深度为

证明：设所求完全二叉树的深度为k。由完全二叉树定义可得：

深度为k得完全二叉树的前k-1层是深度为k-1的满二叉树，一共有2k-1-1个结点。

由于完全二叉树深度为k，故第k层上还有若干个结点，因此该完全二叉树的结点个数：

n2k-1-1。

另一方面，由性质2可得：

n≤2k-1，

即：2k-1-ln≤2k-1

由此可推出：2k-1≤n2k，取对数后有：

k-1≤lgnk

又因k-1和k是相邻的两个整数，故有

,

由此即得：

新闻名称：深度遍历java算法代码,深度遍历 java
URL地址：http://kswjz.com/article/dsejgjh.html