2025-02-10

From Quantums blog


好久沒寫東西瞭,隨便記一下~~如果不記錄忘記瞭真是很浪費啊~


下面貼的這個是JAVA寫的反向傳播神經網絡,面向對象,把神經元和連結都抽象成對象。


其實這個已經不是什麼新奇的玩意瞭,對於分類 回歸而言 神經網絡是一個選擇但並不一定是最好的選擇。


類似很多進化計算都存在同樣的問題,如GA遺傳算法。


NN迭代學習過後,每個神經元權重的含義很難被理解,所以才有人提出神經網絡的規則抽取,如何對網絡的神經元進行裁剪


接下來就是NN 的學習過程中,最具有價值的


1. 計算 delta規則 ,一般采用梯度下降法等等(有本書說得不錯的《最優化理論與方法》講瞭很多牛頓法 最速下降法等等)


2. 激活函數,其實這個最終目的就是讓數據2值化,神經網絡設計一書上標準的方式,其實你也可以通過這個思想自己搞一個


3. 當然是NN的整個數據結構模型,模擬瞭大腦神經的信息傳遞過程。


以下代碼 main函數是使用DEMO


package cn.isto.ai.algorithm.nn;
import java.util.HashMap;
import java.util.Random;
import java.util.Set;
import java.util.Map.Entry;


/**
 * JAVA 反向傳輸神經網絡
 * @author kj021320  , codeby 2008.12.10
 *
 */
public class JavaBackPropagationNeuralNetwork {
    /**
     * 神經元
     */
    public class Neuron {
        HashMap<Integer, Link> target = new HashMap<Integer, Link>();// 連接其他神經元的
        HashMap<Integer, Link> source = new HashMap<Integer, Link>();// 被其他神經元連接的
        double data = 0.0;
        public Link sourceGet(int index) {
            return source.get(index);
        }
        public Link targetGet(int index) {
            return target.get(index);
        }
        public boolean targetContains(Link l) {
            return target.containsValue(l);
        }
        public boolean sourceContains(Link l) {
            return source.containsValue(l);
        }
        public Link sourceLink(int index, Link l) {
            if (l.linker != this) {
                l.setLinker(this);
            }
            return source.put(index, l);
        }
        public Link targetLink(int index, Link l) {
            if (l.owner != this) {
                l.setOwner(this);
            }
            return target.put(index, l);
        }
    }


    /**
     * 神經鏈
     */
    public class Link {
        Neuron owner;
        public void setOwner(Neuron o) {
            owner = o;
            if (!o.targetContains(this)) {
                o.targetLink(o.target.size(), this);
            }
        }
        public Link() {
            weight = rand(-1, 1);
        }
        public void setLinker(Neuron o) {
            linker = o;
            if (!o.sourceContains(this)) {
                o.sourceLink(o.source.size(), this);
            }
        }
        @Override
        public String toString(){
            return super.toString()+” weight:”+weight;
        }
        Neuron linker;
        double weight;
    }


    Random random = new Random();
    {
        random.setSeed(System.nanoTime());
    }
    Neuron[] inputnode;    //輸入層神經元
    Neuron[] hiddennode;    //隱含層神經元
    Neuron[] outputnode;    //輸出層神經元
    double learnrate;// 學習速度
    double threshold;// 閥值,誤差允許度


    private final int inputCount;
    private final int hiddenCount;
    private final int outputCount;
    /**
     *
     * @param input        輸入層的神經元個數
     * @param hidden    隱含層的神經元個數
     * @param output    輸出層的神經元的個數
     */
    public JavaBackPropagationNeuralNetwork(int input, int hidden, int output) {
        inputCount = input;
        hiddenCount = hidden;
        outputCount = output;
        build();
    }
    public void reBuildNeuralNetwork(){
        build();
    }
    private void build(){
        inputnode = new Neuron[inputCount+1];
        hiddennode = new Neuron[hiddenCount];
        outputnode = new Neuron[outputCount];
        initNeurons(inputnode);
        initNeurons(hiddennode);
        initNeurons(outputnode);
        makeLink(inputnode, hiddennode);
        makeLink(hiddennode, outputnode);
    }
    /**
     * 思考方法
     * @param inputs    前饋層神經個數相符的浮點數    -1~1之間
     * @return     &nbsp

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *