From 0d419504e132656ee28351d093a949223dc0cec9 Mon Sep 17 00:00:00 2001 From: inter Date: Thu, 4 Sep 2025 14:09:24 +0800 Subject: [PATCH] Add File --- .../easyai/rnnNerveCenter/NerveManager.java | 392 ++++++++++++++++++ 1 file changed, 392 insertions(+) create mode 100644 src/main/java/org/dromara/easyai/rnnNerveCenter/NerveManager.java diff --git a/src/main/java/org/dromara/easyai/rnnNerveCenter/NerveManager.java b/src/main/java/org/dromara/easyai/rnnNerveCenter/NerveManager.java new file mode 100644 index 0000000..f21dedb --- /dev/null +++ b/src/main/java/org/dromara/easyai/rnnNerveCenter/NerveManager.java @@ -0,0 +1,392 @@ +package org.dromara.easyai.rnnNerveCenter; + +import org.dromara.easyai.matrixTools.Matrix; +import org.dromara.easyai.i.ActiveFunction; +import org.dromara.easyai.rnnNerveEntity.*; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * 神经网络管理工具 + * 创建神经网络 + * + * @author lidapeng + * @date 11:05 上午 2019/12/21 + */ +public class NerveManager { + private final int hiddenNerveNub;//隐层神经元个数 + private final int sensoryNerveNub;//输入神经元个数 + private final int outNerveNub;//输出神经元个数 + private final int hiddenDepth;//隐层深度 + private final List sensoryNerves = new ArrayList<>();//感知神经元 + private final List> depthNerves = new ArrayList<>();//隐层神经元 + private final List outNerves = new ArrayList<>();//输出神经元 + private final List rnnOutNerveBodies = new ArrayList<>();//rnn输出层神经元 + private boolean initPower; + private float studyPoint = 0.1f;//学习率 + private final ActiveFunction activeFunction; + private boolean isRnn = false;//是否为rnn网络 + private List studyList = new ArrayList<>(); + private final int rzType;//正则化类型，默认不进行正则化 + private final float lParam;//正则参数 + private boolean isSoftMax = true; + + public void setSoftMax(boolean softMax) { + isSoftMax = softMax; + } + + public List getStudyList() {//查看每一次的学习率 + return studyList; + } + + public void setStudyList(List studyList) {//设置每一层的学习率 + this.studyList = studyList; + } + + + private Map conversion(Map map) { + Map cMap = new HashMap<>(); + for (Map.Entry entry : map.entrySet()) { + cMap.put(String.valueOf(entry.getKey()), entry.getValue()); + } + return cMap; + } + + private Map unConversion(Map map) { + Map cMap = new HashMap<>(); + for (Map.Entry entry : map.entrySet()) { + cMap.put(Integer.parseInt(entry.getKey()), entry.getValue()); + } + return cMap; + } + + + public ModelParameter getModelParameter() throws Exception { + if (isRnn) { + return getRnnModelParameter(); + } else { + return getStaticModelParameter(); + } + } + + private ModelParameter getRnnModelParameter() {//获取rnn当前模型参数 + ModelParameter modelParameter = new ModelParameter(); + List> studyDepthNerves = new ArrayList<>();//隐层神经元模型 + List rnnOutNerveStudies = new ArrayList<>(); + modelParameter.setDepthNerves(studyDepthNerves); + modelParameter.setRnnOutNerveStudies(rnnOutNerveStudies); + //隐层神经元 + getHiddenNerveModel(studyDepthNerves); + for (RnnOutNerveBody rnnOutNerveBody : rnnOutNerveBodies) { + List nerveStudies = new ArrayList<>(); + RnnOutNerveStudy rnnOutNerveStudy = new RnnOutNerveStudy(); + rnnOutNerveStudies.add(rnnOutNerveStudy); + rnnOutNerveStudy.setDepth(rnnOutNerveBody.getDepth()); + rnnOutNerveStudy.setNerveStudies(nerveStudies); + List outNerveList = rnnOutNerveBody.getOutNerves(); + getRnnOutNerveModel(nerveStudies, outNerveList); + } + return modelParameter; + } + + private void getRnnOutNerveModel(List nerveStudies, List outNerveList) { + for (Nerve nerve : outNerveList) { + NerveStudy nerveStudy = new NerveStudy(); + nerveStudy.setThreshold(nerve.getThreshold()); + nerveStudy.setDendrites(conversion(nerve.getDendrites())); + nerveStudies.add(nerveStudy); + } + } + + private void getHiddenNerveModel(List> studyDepthNerves) { + for (List depthNerve : depthNerves) { + //创建一层深度的隐层神经元模型 + List deepNerve = new ArrayList<>(); + for (Nerve nerve : depthNerve) { + //遍历某一层深度的所有隐层神经元 + NerveStudy nerveStudy = new NerveStudy(); + nerveStudy.setThreshold(nerve.getThreshold()); + nerveStudy.setDendrites(conversion(nerve.getDendrites())); + deepNerve.add(nerveStudy); + } + studyDepthNerves.add(deepNerve); + } + } + + private ModelParameter getStaticModelParameter() {//获取当前模型参数 + ModelParameter modelParameter = new ModelParameter(); + List> studyDepthNerves = new ArrayList<>();//隐层神经元模型 + List outStudyNerves = new ArrayList<>();//输出神经元 + //隐层神经元 + getHiddenNerveModel(studyDepthNerves); + getRnnOutNerveModel(outStudyNerves, outNerves); + modelParameter.setDepthNerves(studyDepthNerves); + modelParameter.setOutNerves(outStudyNerves); + return modelParameter; + } + + public void insertModelParameter(ModelParameter modelParameter) throws Exception { + if (isRnn) { + insertRnnModelParameter(modelParameter); + } else { + insertBpModelParameter(modelParameter);//全连接层注入参数 + } + + } + + private void insertRnnModelParameter(ModelParameter modelParameter) { + List> depthStudyNerves = modelParameter.getDepthNerves();//隐层神经元 + List rnnOutNerveStudies = modelParameter.getRnnOutNerveStudies(); + //隐层神经元参数注入 + for (int i = 0; i < depthNerves.size(); i++) { + List depth = depthStudyNerves.get(i);//对应的学习结果 + List depthNerve = depthNerves.get(i);//深度隐层神经元 + for (int j = 0; j < depthNerve.size(); j++) {//遍历当前深度神经元 + Nerve nerve = depthNerve.get(j); + NerveStudy nerveStudy = depth.get(j); + //学习结果 + Map studyDendrites = unConversion(nerveStudy.getDendrites()); + //神经元参数注入 + Map dendrites = nerve.getDendrites(); + nerve.setThreshold(nerveStudy.getThreshold());//注入隐层阈值 + for (Map.Entry entry : dendrites.entrySet()) { + int key = entry.getKey(); + dendrites.put(key, studyDendrites.get(key));//注入隐层权重 + } + } + } + for (RnnOutNerveStudy rnnOutNerveStudy : rnnOutNerveStudies) { + RnnOutNerveBody rnnOutNerveBody = getRnnOutNerveBody(rnnOutNerveStudy.getDepth()); + List outStudyNerves = rnnOutNerveStudy.getNerveStudies(); + List outNerveBody = rnnOutNerveBody.getOutNerves(); + //输出神经元参数注入 + for (int i = 0; i < outNerveBody.size(); i++) { + Nerve outNerve = outNerveBody.get(i); + NerveStudy nerveStudy = outStudyNerves.get(i); + outNerve.setThreshold(nerveStudy.getThreshold()); + Map dendrites = outNerve.getDendrites(); + Map studyDendrites = unConversion(nerveStudy.getDendrites()); + for (Map.Entry outEntry : dendrites.entrySet()) { + int key = outEntry.getKey(); + dendrites.put(key, studyDendrites.get(key)); + } + } + } + } + + private RnnOutNerveBody getRnnOutNerveBody(int depth) { + RnnOutNerveBody myRnnOutNerveBody = null; + for (RnnOutNerveBody rnnOutNerveBody : rnnOutNerveBodies) { + if (rnnOutNerveBody.getDepth() == depth) { + myRnnOutNerveBody = rnnOutNerveBody; + break; + } + } + return myRnnOutNerveBody; + } + + //注入全连接模型参数 + private void insertBpModelParameter(ModelParameter modelParameter) { + List> depthStudyNerves = modelParameter.getDepthNerves();//隐层神经元 + List outStudyNerves = modelParameter.getOutNerves();//输出神经元 + //隐层神经元参数注入 + for (int i = 0; i < depthNerves.size(); i++) { + List depth = depthStudyNerves.get(i);//对应的学习结果 + List depthNerve = depthNerves.get(i);//深度隐层神经元 + for (int j = 0; j < depthNerve.size(); j++) {//遍历当前深度神经元 + Nerve nerve = depthNerve.get(j); + NerveStudy nerveStudy = depth.get(j); + //学习结果 + Map studyDendrites = unConversion(nerveStudy.getDendrites()); + //神经元参数注入 + Map dendrites = nerve.getDendrites(); + nerve.setThreshold(nerveStudy.getThreshold());//注入隐层阈值 + for (Map.Entry entry : dendrites.entrySet()) { + int key = entry.getKey(); + dendrites.put(key, studyDendrites.get(key));//注入隐层权重 + } + } + } + //输出神经元参数注入 + for (int i = 0; i < outNerves.size(); i++) { + Nerve outNerve = outNerves.get(i); + NerveStudy nerveStudy = outStudyNerves.get(i); + outNerve.setThreshold(nerveStudy.getThreshold()); + Map dendrites = outNerve.getDendrites(); + Map studyDendrites = unConversion(nerveStudy.getDendrites()); + for (Map.Entry outEntry : dendrites.entrySet()) { + int key = outEntry.getKey(); + dendrites.put(key, studyDendrites.get(key)); + } + } + } + + /** + * 初始化神经元参数 + * + * @param sensoryNerveNub 输入神经元个数 + * @param hiddenNerveNub 隐层神经元个数 + * @param outNerveNub 输出神经元个数 + * @param hiddenDepth 隐层深度 + * @param activeFunction 激活函数 + * @param rzType 正则函数 + * @param lParam 正则系数 + * @throws Exception 如果参数错误则抛异常 + */ + public NerveManager(int sensoryNerveNub, int hiddenNerveNub, int outNerveNub + , int hiddenDepth, ActiveFunction activeFunction, float studyPoint, int rzType, float lParam) throws Exception { + if (sensoryNerveNub > 0 && hiddenNerveNub > 0 && outNerveNub > 0 && hiddenDepth > 0 && activeFunction != null) { + this.hiddenNerveNub = hiddenNerveNub; + this.sensoryNerveNub = sensoryNerveNub; + this.outNerveNub = outNerveNub; + this.hiddenDepth = hiddenDepth; + this.activeFunction = activeFunction; + this.rzType = rzType; + this.lParam = lParam; + if (studyPoint > 0 && studyPoint < 1) { + this.studyPoint = studyPoint; + } + } else { + throw new Exception("param is null"); + } + } + + public List getSensoryNerves() {//获取感知神经元集合 + return sensoryNerves; + } + + /** + * 初始化 + * + * @param initPower 是否是第一次注入 + * @param isShowLog 是否打印学习参数 + * @param isSoftMax 最后一层是否用softMax激活 + */ + public void init(boolean initPower, boolean isShowLog, boolean isSoftMax) throws Exception {//进行神经网络的初始化构建 + this.initPower = initPower; + initDepthNerve();//初始化深度隐层神经元 + List nerveList = depthNerves.get(0);//第一层隐层神经元 + //最后一层隐层神经元啊 + List lastNerveList = depthNerves.get(depthNerves.size() - 1); + //初始化输出神经元 + List outNerveList = new ArrayList<>(); + for (int i = 1; i < outNerveNub + 1; i++) { + OutNerve outNerve = new OutNerve(i, hiddenNerveNub, 0, studyPoint, initPower, + activeFunction, isShowLog, rzType, lParam, isSoftMax); + //输出层神经元连接最后一层隐层神经元 + outNerve.connectFather(lastNerveList); + outNerves.add(outNerve); + outNerveList.add(outNerve); + } + //生成softMax层 + createSoftMax(isShowLog, isSoftMax, outNerveList, outNerves); + //最后一层隐层神经元 与输出神经元进行连接 + for (Nerve nerve : lastNerveList) { + nerve.connect(outNerves); + } + + //初始化感知神经元 + for (int i = 1; i < sensoryNerveNub + 1; i++) { + SensoryNerve sensoryNerve = new SensoryNerve(i, 0); + //感知神经元与第一层隐层神经元进行连接 + sensoryNerve.connect(nerveList); + sensoryNerves.add(sensoryNerve); + } + } + + private void createSoftMax(boolean isShowLog, boolean isSoftMax, List outNerveList, List outNerves) throws Exception { + if (isSoftMax) { + List softMaxList = new ArrayList<>(); + SoftMax softMax = new SoftMax(outNerveNub, outNerveList, isShowLog); + softMaxList.add(softMax); + for (Nerve nerve : outNerves) { + nerve.connect(softMaxList); + } + } + } + + private void createRnnOutNerve(boolean initPower, boolean isShowLog, List nerveList, int depth) throws Exception { + RnnOutNerveBody rnnOutNerveBody = new RnnOutNerveBody(); + List rnnOutNerves = new ArrayList<>(); + List outNerveList = new ArrayList<>(); + rnnOutNerveBody.setDepth(depth); + rnnOutNerveBody.setOutNerves(rnnOutNerves); + for (int i = 1; i < outNerveNub + 1; i++) { + OutNerve outNerve = new OutNerve(i, hiddenNerveNub, 0, studyPoint, initPower, + activeFunction, isShowLog, rzType, lParam, isSoftMax); + outNerve.connectFather(nerveList);//每一层的输出神经元 链接每一层的隐层神经元 + rnnOutNerves.add(outNerve); + outNerveList.add(outNerve); + } + createSoftMax(isShowLog, isSoftMax, outNerveList, rnnOutNerves); + for (Nerve nerve : nerveList) { + nerve.connectOut(rnnOutNerves); + } + rnnOutNerveBodies.add(rnnOutNerveBody); + } + + public void initRnn(boolean initPower, boolean isShowLog) throws Exception { + isRnn = true; + this.initPower = initPower; + initDepthNerve();//初始化深度隐层神经元 + for (int i = 0; i < depthNerves.size(); i++) { + createRnnOutNerve(initPower, isShowLog, depthNerves.get(i), i + 1); + } + List nerveList = depthNerves.get(0);//第一层隐层神经元 + //初始化感知神经元 + for (int i = 1; i < sensoryNerveNub + 1; i++) { + SensoryNerve sensoryNerve = new SensoryNerve(i, 0); + //感知神经元与第一层隐层神经元进行连接 + sensoryNerve.connect(nerveList); + sensoryNerves.add(sensoryNerve); + } + } + + private void initDepthNerve() throws Exception {//初始化隐层神经元1 + for (int i = 0; i < hiddenDepth; i++) {//遍历深度 + List hiddenNerveList = new ArrayList<>(); + float studyPoint = this.studyPoint; + if (studyList.contains(i)) {//加载每一层的学习率 + studyPoint = studyList.get(i); + } + if (studyPoint <= 0 || studyPoint > 1) { + throw new Exception("studyPoint Values range from 0 to 1"); + } + for (int j = 1; j < hiddenNerveNub + 1; j++) {//遍历同级 + int upNub; + int downNub; + if (i == 0) { + upNub = sensoryNerveNub; + } else { + upNub = hiddenNerveNub; + } + if (i == hiddenDepth - 1) {//最后一层隐层神经元z + downNub = outNerveNub; + } else { + downNub = hiddenNerveNub; + } + HiddenNerve hiddenNerve = new HiddenNerve(j, i + 1, upNub, downNub, studyPoint, initPower, activeFunction + , rzType, lParam, outNerveNub); + hiddenNerveList.add(hiddenNerve); + } + depthNerves.add(hiddenNerveList); + } + initHiddenNerve(); + } + + private void initHiddenNerve() {//初始化隐层神经元2 + for (int i = 0; i < hiddenDepth - 1; i++) {//遍历深度 + List hiddenNerveList = depthNerves.get(i);//当前遍历隐层神经元 + List nextHiddenNerveList = depthNerves.get(i + 1);//当前遍历的下一层神经元 + for (Nerve hiddenNerve : hiddenNerveList) { + hiddenNerve.connect(nextHiddenNerveList); + } + for (Nerve nextHiddenNerve : nextHiddenNerveList) { + nextHiddenNerve.connectFather(hiddenNerveList); + } + } + } +}