From b809a4a60f5a8864fc3858c9a940ea651aa19b3a Mon Sep 17 00:00:00 2001 From: lidapeng Date: Mon, 16 Mar 2020 18:08:15 +0800 Subject: [PATCH] =?UTF-8?q?apida=E5=A4=A7=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../org/wlld/MatrixTools/MatrixOperation.java | 21 ++ .../java/org/wlld/config/StudyPattern.java | 2 + .../wlld/imageRecognition/Convolution.java | 31 +- .../org/wlld/imageRecognition/Operation.java | 140 +++++++-- .../wlld/imageRecognition/TempleConfig.java | 160 +++++----- .../org/wlld/imageRecognition/VectorK.java | 39 +-- .../org/wlld/imageRecognition/border/LVQ.java | 8 + .../org/wlld/nerveCenter/Normalization.java | 26 +- .../org/wlld/nerveEntity/ModelParameter.java | 28 ++ .../java/org/wlld/nerveEntity/OutNerve.java | 6 +- src/test/java/org/wlld/HelloWorld.java | 294 +++++------------- src/test/java/org/wlld/ModelData.java | 11 +- 12 files changed, 412 insertions(+), 354 deletions(-) diff --git a/src/main/java/org/wlld/MatrixTools/MatrixOperation.java b/src/main/java/org/wlld/MatrixTools/MatrixOperation.java index 84ce556..11c476c 100644 --- a/src/main/java/org/wlld/MatrixTools/MatrixOperation.java +++ b/src/main/java/org/wlld/MatrixTools/MatrixOperation.java @@ -2,6 +2,9 @@ package org.wlld.MatrixTools; import org.wlld.tools.ArithUtil; +import java.util.ArrayList; +import java.util.List; + public class MatrixOperation { private MatrixOperation() { @@ -370,4 +373,22 @@ public class MatrixOperation { } } } + + //行向量转LIST + public static List rowVectorToList(Matrix matrix) throws Exception { + List list = new ArrayList<>(); + for (int j = 0; j < matrix.getY(); j++) { + list.add(matrix.getNumber(0, j)); + } + return list; + } + + //list转行向量 + public static Matrix listToRowVector(List list) throws Exception { + Matrix matrix = new Matrix(1, list.size()); + for (int i = 0; i < list.size(); i++) { + matrix.setNub(0, i, list.get(i)); + } + return matrix; + } } diff --git a/src/main/java/org/wlld/config/StudyPattern.java b/src/main/java/org/wlld/config/StudyPattern.java index e93fa30..fb83917 100644 --- a/src/main/java/org/wlld/config/StudyPattern.java +++ b/src/main/java/org/wlld/config/StudyPattern.java @@ -8,4 +8,6 @@ package org.wlld.config; public class StudyPattern { public static final int Speed_Pattern = 1;//速度学习模式 public static final int Accuracy_Pattern = 2;//精准学习模式 + public static final int Cover_Pattern = 3;//覆盖率模式 + } diff --git a/src/main/java/org/wlld/imageRecognition/Convolution.java b/src/main/java/org/wlld/imageRecognition/Convolution.java index 25579af..0feea04 100644 --- a/src/main/java/org/wlld/imageRecognition/Convolution.java +++ b/src/main/java/org/wlld/imageRecognition/Convolution.java @@ -96,19 +96,34 @@ public class Convolution { if (isOnce) { return null; } else { - return late(myMatrix); + return late(myMatrix, 2); } } - private Matrix late(Matrix matrix) throws Exception {//迟化处理 + public Matrix getBorder(Matrix matrix, Matrix kernel) throws Exception { + int x = matrix.getX() - 2;//求导后矩阵的行数 + int y = matrix.getY() - 2;//求导后矩阵的列数 + Matrix myMatrix = new Matrix(x, y);//最终合成矩阵 + for (int i = 0; i < x; i++) {//遍历行 + for (int j = 0; j < y; j++) {//遍历每行的列 + double dm = MatrixOperation.convolution(matrix, kernel, i, j); + if (dm > 0) {//存在边缘 + myMatrix.setNub(i, j, dm); + } + } + } + return myMatrix; + } + + protected Matrix late(Matrix matrix, int size) throws Exception {//迟化处理 int xn = matrix.getX(); int yn = matrix.getY(); - int x = xn / 2;//求导后矩阵的行数 - int y = yn / 2;//求导后矩阵的列数 + int x = xn / size;//求导后矩阵的行数 + int y = yn / size;//求导后矩阵的列数 Matrix myMatrix = new Matrix(x, y);//迟化后的矩阵 - for (int i = 0; i < xn - 2; i += 2) { - for (int j = 0; j < yn - 2; j += 2) { - Matrix matrix1 = matrix.getSonOfMatrix(i, j, 2, 2); + for (int i = 0; i < xn - size; i += size) { + for (int j = 0; j < yn - size; j += size) { + Matrix matrix1 = matrix.getSonOfMatrix(i, j, size, size); double maxNub = 0; for (int t = 0; t < matrix1.getX(); t++) { for (int k = 0; k < matrix1.getY(); k++) { @@ -119,7 +134,7 @@ public class Convolution { } } //迟化的最大值是 MAXNUB - myMatrix.setNub(i / 2, j / 2, maxNub); + myMatrix.setNub(i / size, j / size, maxNub); } } return myMatrix; diff --git a/src/main/java/org/wlld/imageRecognition/Operation.java b/src/main/java/org/wlld/imageRecognition/Operation.java index 8396e09..52595fa 100644 --- a/src/main/java/org/wlld/imageRecognition/Operation.java +++ b/src/main/java/org/wlld/imageRecognition/Operation.java @@ -4,6 +4,7 @@ package org.wlld.imageRecognition; import org.wlld.MatrixTools.Matrix; import org.wlld.MatrixTools.MatrixOperation; import org.wlld.config.Classifier; +import org.wlld.config.Kernel; import org.wlld.config.StudyPattern; import org.wlld.function.Sigmod; import org.wlld.i.OutBack; @@ -26,9 +27,11 @@ public class Operation {//进行计算 private MatrixBack matrixBack = new MatrixBack(); private ImageBack imageBack = new ImageBack(); private OutBack outBack; + private double avg; public Operation(TempleConfig templeConfig) { this.templeConfig = templeConfig; + avg = templeConfig.getAvg(); } public Operation(TempleConfig templeConfig, OutBack outBack) { @@ -57,6 +60,83 @@ public class Operation {//进行计算 return sub(matrix1); } + private double one(List> rightLists, double sigma) { + for (List list : rightLists) { + for (double nub : list) { + sigma = ArithUtil.add(nub, sigma); + } + } + return sigma; + } + + private void lastOne(List> rightLists, double avg) { + for (List list : rightLists) { + for (int i = 0; i < list.size(); i++) { + list.set(i, ArithUtil.sub(list.get(i), avg)); + } + } + } + + //从一张图片的局部进行学习 + public void coverStudy(Matrix matrixRight, Map right + , Matrix matrixWrong, Map wrong) throws Exception { + if (templeConfig.getStudyPattern() == StudyPattern.Cover_Pattern) { + //先用边缘算子卷一遍 + matrixRight = convolution.late(convolution.getBorder(matrixRight, Kernel.ALL_Two), 2); + matrixWrong = convolution.late(convolution.getBorder(matrixWrong, Kernel.ALL_Two), 2); + List> rightLists = getFeatures(matrixRight); + List> wrongLists = getFeatures(matrixWrong); + int nub = rightLists.size() * 2 * 9; + double sigma = one(rightLists, 0); + sigma = one(rightLists, sigma); + avg = ArithUtil.div(sigma, nub); + templeConfig.setAvg(avg); + lastOne(rightLists, avg); + lastOne(wrongLists, avg); + //特征塞入容器完毕 + int size = rightLists.size(); + for (int j = 0; j < 3; j++) { + for (int i = 0; i < size; i++) { + List rightList = rightLists.get(i); + List wrongList = wrongLists.get(i); + intoDnnNetwork(1, rightList, templeConfig.getSensoryNerves(), true, right, null); + intoDnnNetwork(1, wrongList, templeConfig.getSensoryNerves(), true, wrong, null); + //System.out.println("right:" + rightList); + //System.out.println("wrong:" + wrongList); + } + } + } else { + throw new Exception("PATTERN IS NOT COVER"); + } + } + + public double coverPoint(Matrix matrix, int rightId) throws Exception { + if (templeConfig.getStudyPattern() == StudyPattern.Cover_Pattern) { + matrix = convolution.late(convolution.getBorder(matrix, Kernel.ALL_Two), 2); + List> lists = getFeatures(matrix); + //特征塞入容器完毕 + int size = lists.size(); + int right = 0; + int all = 0; + lastOne(lists, avg); + for (int i = 0; i < size; i++) { + List list = lists.get(i); + MaxPoint maxPoint = new MaxPoint(); + long pid = IdCreator.get().nextId(); + intoDnnNetwork(pid, list, templeConfig.getSensoryNerves(), false, null, maxPoint); + int id = maxPoint.getId(); + if (id == rightId) { + right++; + } + all++; + } + //ArithUtil.div(coverBody.getRightNub(), size) + return ArithUtil.div(right, all); + } else { + throw new Exception("PATTERN IS NOT COVER"); + } + } + //模板学习 public void study(Matrix matrix, Map tagging) throws Exception { if (templeConfig.getStudyPattern() == StudyPattern.Speed_Pattern) { @@ -135,19 +215,6 @@ public class Operation {//进行计算 Map map = new HashMap<>(); map.put(tagging, 1.0); intoDnnNetwork(1, featureALL, templeConfig.getSensoryNerves(), true, map, null); -// int classifier = templeConfig.getClassifier(); -// switch (classifier) { -// case Classifier.DNN: -// dnn(tagging, myMatrixR); -// break; -// case Classifier.LVQ: -// lvq(tagging, myMatrixR); -// break; -// case Classifier.VAvg: -// vectorAvg(tagging, myMatrixR); -// break; -// } - } } @@ -214,7 +281,7 @@ public class Operation {//进行计算 Map map = new HashMap<>(); map.put(tagging, 1.0); List feature = getFeature(myMatrix); - System.out.println(feature); + //System.out.println(feature); intoDnnNetwork(1, feature, templeConfig.getSensoryNerves(), true, map, null); } @@ -227,6 +294,7 @@ public class Operation {//进行计算 private void lvq(int tagging, Matrix myMatrix) throws Exception {//LVQ学习 LVQ lvq = templeConfig.getLvq(); Matrix vector = MatrixOperation.matrixToVector(myMatrix, true); + System.out.println(vector.getString()); MatrixBody matrixBody = new MatrixBody(); matrixBody.setMatrix(vector); matrixBody.setId(tagging); @@ -237,12 +305,11 @@ public class Operation {//进行计算 List list = new ArrayList<>(); Normalization normalization = templeConfig.getNormalization(); double middle = normalization.getAvg(); - //double sub = ArithUtil.sub(normalization.getMax(), normalization.getMin()); for (int i = 0; i < matrix.getX(); i++) { for (int j = 0; j < matrix.getY(); j++) { double nub = matrix.getNumber(i, j); if (nub != 0) { - nub = ArithUtil.sub(nub, middle);//middle + nub = ArithUtil.sub(nub, middle); list.add(nub); } else { list.add(0.0); @@ -253,6 +320,32 @@ public class Operation {//进行计算 return list; } + private List> getFeatures(Matrix matrix) throws Exception { + List> lists = new ArrayList<>(); + int x = matrix.getX() - 3;//求导后矩阵的行数 + int y = matrix.getY() - 3;//求导后矩阵的列数 + for (int i = 0; i < x; i += 3) {//遍历行 + for (int j = 0; j < y; j += 3) {//遍历每行的列 + Matrix myMatrix = matrix.getSonOfMatrix(i, j, 3, 3); + lists.add(getListFeature(myMatrix)); + } + } + return lists; + } + + private List getListFeature(Matrix matrix) throws Exception { + List list = new ArrayList<>(); + int x = matrix.getX(); + int y = matrix.getY(); + for (int i = 0; i < x; i++) { + for (int j = 0; j < y; j++) { + double nub = matrix.getNumber(i, j) / 300; + list.add(nub); + } + } + return list; + } + //图像视觉 speed 模式 public void look(Matrix matrix, long eventId) throws Exception { if (templeConfig.getStudyPattern() == StudyPattern.Speed_Pattern) { @@ -295,8 +388,19 @@ public class Operation {//进行计算 Matrix myMatrix = matrixBack.getMatrix(); //卷积层输出即边框回归的输入的特征向量 frameBody.setEndMatrix(myMatrix); - //Matrix vector = MatrixOperation.matrixToVector(myMatrix, true); - int id = getClassificationIdByLVQ(myMatrix); + int classifier = templeConfig.getClassifier(); + int id = 0; + switch (classifier) { + case Classifier.LVQ: + id = getClassificationIdByLVQ(myMatrix); + break; + case Classifier.DNN: + id = getClassificationIdByDnn(myMatrix); + break; + case Classifier.VAvg: + id = getClassificationIdByVag(myMatrix); + break; + } frameBody.setId(id); } return toPosition(frameBodies, frame.getWidth(), frame.getHeight()); diff --git a/src/main/java/org/wlld/imageRecognition/TempleConfig.java b/src/main/java/org/wlld/imageRecognition/TempleConfig.java index 28110dc..5ca8529 100644 --- a/src/main/java/org/wlld/imageRecognition/TempleConfig.java +++ b/src/main/java/org/wlld/imageRecognition/TempleConfig.java @@ -1,6 +1,7 @@ package org.wlld.imageRecognition; import org.wlld.MatrixTools.Matrix; +import org.wlld.MatrixTools.MatrixOperation; import org.wlld.config.Classifier; import org.wlld.config.StudyPattern; import org.wlld.function.ReLu; @@ -31,7 +32,7 @@ public class TempleConfig { private int row = 5;//行的最小比例 private int column = 3;//列的最小比例 private int deep = 1;//默认深度 - private int classificationNub = 1;//分类的数量 + private int classificationNub = 2;//分类的数量 private int studyPattern;//学习模式 private boolean isHavePosition = false;//是否需要锁定物体位置 private LVQ lvq;//模型需要返回,精准模式下的原型聚类 @@ -39,11 +40,21 @@ public class TempleConfig { private double th = 0.6;//标准阈值 private boolean boxReady = false;//边框已经学习完毕 private double iouTh = 0.5;//IOU阈值 - private int lvqNub = 30;//lvq循环次数，默认30 + private int lvqNub = 10;//lvq循环次数，默认30 private VectorK vectorK; private boolean isThreeChannel;//是否启用三通道 private int classifier = Classifier.VAvg;//默认分类类别使用的是向量均值分类 private Normalization normalization = new Normalization();//统一归一化 + private double avg = 0;//覆盖均值 + private int sensoryNerveNub;//输入神经元个数 + + public double getAvg() { + return avg; + } + + public void setAvg(double avg) { + this.avg = avg; + } public Normalization getNormalization() { return normalization; @@ -102,10 +113,6 @@ public class TempleConfig { return kClusteringMap; } - public int getLvqNub() { - return lvqNub; - } - public void setLvqNub(int lvqNub) { this.lvqNub = lvqNub; } @@ -182,6 +189,9 @@ public class TempleConfig { case StudyPattern.Accuracy_Pattern://精准学习模式 initConvolutionVision(initPower, width, height); break; + case StudyPattern.Cover_Pattern://覆盖学习模式 + initNerveManager(initPower, 9, deep); + break; } } @@ -226,12 +236,13 @@ public class TempleConfig { lvq = new LVQ(classificationNub, lvqNub); break; case Classifier.VAvg: - vectorK = new VectorK(height * width); + sensoryNerveNub = height * width; + vectorK = new VectorK(sensoryNerveNub); break; } //加载各识别分类的期望矩阵 matrixMap.put(0, new Matrix(height, width)); - double nub = 1;//每个分类期望参数的跨度 + double nub = 0.5;//每个分类期望参数的跨度 for (int k = 1; k <= classificationNub; k++) { Matrix matrix = new Matrix(height, width);//初始化期望矩阵 double t = k * nub;//期望矩阵的分类参数数值 @@ -266,7 +277,7 @@ public class TempleConfig { MatrixBody matrixBody = matrixBodies[i]; Matrix matrix = matrixBody.getMatrix(); MatrixModel matrixModel = new MatrixModel(); - List rowVector = rowVectorToList(matrix); + List rowVector = MatrixOperation.rowVectorToList(matrix); matrixModel.setId(matrixBody.getId()); matrixModel.setRowVector(rowVector); matrixModelList.add(matrixModel); @@ -274,15 +285,6 @@ public class TempleConfig { return matrixModelList; } - //行向量转LIST - private List rowVectorToList(Matrix matrix) throws Exception { - List list = new ArrayList<>(); - for (int j = 0; j < matrix.getY(); j++) { - list.add(matrix.getNumber(0, j)); - } - return list; - } - private Map kToBody() throws Exception { Map borderMap = new HashMap<>(); for (Map.Entry entry : kClusteringMap.entrySet()) { @@ -301,14 +303,14 @@ public class TempleConfig { for (Map.Entry entryBox : positionMap.entrySet()) { Box box = entryBox.getValue(); BoxList boxList = new BoxList(); - List furList = rowVectorToList(box.getMatrix()); - List borderList = rowVectorToList(box.getMatrixPosition()); + List furList = MatrixOperation.rowVectorToList(box.getMatrix()); + List borderList = MatrixOperation.rowVectorToList(box.getMatrixPosition()); boxList.setList(furList); boxList.setPositionList(borderList); myPosition.put(entryBox.getKey(), boxList); } for (int i = 0; i < matrices.length; i++) { - lists.add(rowVectorToList(matrices[i])); + lists.add(MatrixOperation.rowVectorToList(matrices[i])); } } @@ -324,18 +326,37 @@ public class TempleConfig { modelParameter.setDymNerveStudies(modelParameter1.getDymNerveStudies()); modelParameter.setDymOutNerveStudy(modelParameter1.getDymOutNerveStudy()); //获取LVQ模型 - if (classifier == Classifier.LVQ && lvq.isReady()) { - LvqModel lvqModel = new LvqModel(); - lvqModel.setLength(lvq.getLength()); - lvqModel.setTypeNub(lvq.getTypeNub()); - lvqModel.setMatrixModelList(getLvqModel(lvq.getModel())); - modelParameter.setLvqModel(lvqModel); + switch (classifier) { + case Classifier.LVQ: + if (lvq.isReady()) { + LvqModel lvqModel = new LvqModel(); + lvqModel.setLength(lvq.getLength()); + lvqModel.setTypeNub(lvq.getTypeNub()); + lvqModel.setMatrixModelList(getLvqModel(lvq.getModel())); + modelParameter.setLvqModel(lvqModel); + } + break; + case Classifier.VAvg: + if (vectorK != null) { + Map> map = vectorK.getKMatrix(); + modelParameter.setMatrixK(map); + } + break; + case Classifier.DNN: + if (normalization != null) { + modelParameter.setDnnAvg(normalization.getAvg()); + } + ModelParameter modelParameter2 = nerveManager.getModelParameter(); + modelParameter.setDepthNerves(modelParameter2.getDepthNerves()); + modelParameter.setOutNerves(modelParameter2.getOutNerves()); + break; } - } else if (studyPattern == StudyPattern.Speed_Pattern) { + } else if (studyPattern == StudyPattern.Cover_Pattern) { ModelParameter modelParameter1 = nerveManager.getModelParameter(); modelParameter.setDepthNerves(modelParameter1.getDepthNerves()); modelParameter.setOutNerves(modelParameter1.getOutNerves()); + modelParameter1.setAvg(avg); } if (isHavePosition && kClusteringMap != null && kClusteringMap.size() > 0) {//存在边框学习模型参数 Map kBorderMap = kToBody(); @@ -371,44 +392,51 @@ public class TempleConfig { return column; } - //list转行向量 - private Matrix listToRowVector(List list) throws Exception { - Matrix matrix = new Matrix(1, list.size()); - for (int i = 0; i < list.size(); i++) { - matrix.setNub(0, i, list.get(i)); - } - return matrix; - } - //注入模型参数 public void insertModel(ModelParameter modelParameter) throws Exception { if (studyPattern == StudyPattern.Accuracy_Pattern) { convolutionNerveManager.insertModelParameter(modelParameter); //LVQ模型参数注入 - LvqModel lvqModel = modelParameter.getLvqModel(); - if (lvqModel != null) { - int length = lvqModel.getLength(); - int typeNub = lvqModel.getTypeNub(); - List matrixModels = lvqModel.getMatrixModelList(); - if (length > 0 && typeNub > 0 && matrixModels != null && - matrixModels.size() > 0) { - MatrixBody[] model = new MatrixBody[matrixModels.size()]; - for (int i = 0; i < model.length; i++) { - MatrixModel matrixModel = matrixModels.get(i); - MatrixBody matrixBody = new MatrixBody(); - matrixBody.setId(matrixModel.getId()); - matrixBody.setMatrix(listToRowVector(matrixModel.getRowVector())); - model[i] = matrixBody; + switch (classifier) { + case Classifier.LVQ: + LvqModel lvqModel = modelParameter.getLvqModel(); + if (lvqModel != null) { + int length = lvqModel.getLength(); + int typeNub = lvqModel.getTypeNub(); + List matrixModels = lvqModel.getMatrixModelList(); + if (length > 0 && typeNub > 0 && matrixModels != null && + matrixModels.size() > 0) { + MatrixBody[] model = new MatrixBody[matrixModels.size()]; + for (int i = 0; i < model.length; i++) { + MatrixModel matrixModel = matrixModels.get(i); + MatrixBody matrixBody = new MatrixBody(); + matrixBody.setId(matrixModel.getId()); + matrixBody.setMatrix(MatrixOperation.listToRowVector(matrixModel.getRowVector())); + model[i] = matrixBody; + } + lvq.setLength(length); + lvq.setTypeNub(typeNub); + lvq.setReady(true); + lvq.setModel(model); + } } - lvq.setLength(length); - lvq.setTypeNub(typeNub); - lvq.setReady(true); - lvq.setModel(model); - } - + break; + case Classifier.VAvg: + vectorK = new VectorK(sensoryNerveNub); + vectorK.insertKMatrix(modelParameter.getMatrixK()); + break; + case Classifier.DNN: + nerveManager.insertModelParameter(modelParameter); + normalization = new Normalization(); + normalization.setAvg(modelParameter.getDnnAvg()); + break; } + } else if (studyPattern == StudyPattern.Speed_Pattern) { nerveManager.insertModelParameter(modelParameter); + } else if (studyPattern == StudyPattern.Cover_Pattern) { + nerveManager.insertModelParameter(modelParameter); + avg = modelParameter.getAvg(); } if (isHavePosition) { if (modelParameter.getFrame() != null) { @@ -429,7 +457,7 @@ public class TempleConfig { Matrix[] matrices = new Matrix[lists.size()]; Map boxMap = kClustering.getPositionMap(); for (int i = 0; i < lists.size(); i++) { - Matrix matrix = listToRowVector(lists.get(i)); + Matrix matrix = MatrixOperation.listToRowVector(lists.get(i)); matrices[i] = matrix; } kClustering.setMatrices(matrices); @@ -438,8 +466,8 @@ public class TempleConfig { for (Map.Entry boxEntry : boxListMap.entrySet()) { Box box = new Box(); BoxList boxList = boxEntry.getValue(); - box.setMatrix(listToRowVector(boxList.getList())); - box.setMatrixPosition(listToRowVector(boxList.getPositionList())); + box.setMatrix(MatrixOperation.listToRowVector(boxList.getList())); + box.setMatrixPosition(MatrixOperation.listToRowVector(boxList.getPositionList())); boxMap.put(boxEntry.getKey(), box); } } @@ -448,20 +476,8 @@ public class TempleConfig { } } - public int getDeep() { - return deep; - } - public void setDeep(int deep) { this.deep = deep; } - public int getClassificationNub() { - return classificationNub; - } - - public void setClassificationNub(int classificationNub) { - this.classificationNub = classificationNub; - } - } diff --git a/src/main/java/org/wlld/imageRecognition/VectorK.java b/src/main/java/org/wlld/imageRecognition/VectorK.java index a9333cd..de6ee75 100644 --- a/src/main/java/org/wlld/imageRecognition/VectorK.java +++ b/src/main/java/org/wlld/imageRecognition/VectorK.java @@ -8,7 +8,7 @@ import java.util.*; public class VectorK { private Map> matrixMap = new HashMap<>(); - private Map matrixK = new HashMap<>(); + private Map matrixK = new HashMap<>();//这个作为模型拿出来 private int length; public VectorK(int length) { @@ -43,27 +43,6 @@ public class VectorK { return matrix; } - private Matrix mind(List matrixList) throws Exception {//拿中位数 - Matrix matrix = new Matrix(1, length); - List> lists = new ArrayList<>(); - for (Matrix matrix1 : matrixList) { - for (int i = 0; i < matrix1.getY(); i++) { - if (lists.size() <= i) { - lists.add(new ArrayList<>()); - } - List list = lists.get(i); - list.add(matrix1.getNumber(0, i)); - Collections.sort(list); - } - } - for (int i = 0; i < length; i++) { - List list = lists.get(i); - int index = list.size() / 2; - matrix.setNub(0, i, list.get(index)); - } - return matrix; - } - public void study() throws Exception { for (Map.Entry> entry : matrixMap.entrySet()) { List matrixList = entry.getValue(); @@ -71,4 +50,20 @@ public class VectorK { matrixK.put(entry.getKey(), matrix); } } + + public Map> getKMatrix() throws Exception { + Map> matrixList = new HashMap<>(); + for (Map.Entry entry : matrixK.entrySet()) { + List list = MatrixOperation.rowVectorToList(entry.getValue()); + matrixList.put(entry.getKey(), list); + } + return matrixList; + } + + public void insertKMatrix(Map> matrixList) throws Exception { + for (Map.Entry> entry : matrixList.entrySet()) { + Matrix matrix = MatrixOperation.listToRowVector(entry.getValue()); + matrixK.put(entry.getKey(), matrix); + } + } } diff --git a/src/main/java/org/wlld/imageRecognition/border/LVQ.java b/src/main/java/org/wlld/imageRecognition/border/LVQ.java index d08b079..9455891 100644 --- a/src/main/java/org/wlld/imageRecognition/border/LVQ.java +++ b/src/main/java/org/wlld/imageRecognition/border/LVQ.java @@ -86,6 +86,8 @@ public class LVQ { long type = matrixBody.getId();//类别 double distEnd = 0; int id = 0; + double dis0 = 0; + double dis1 = 1; for (int i = 0; i < typeNub; i++) { MatrixBody modelBody = model[i]; Matrix modelMatrix = modelBody.getMatrix(); @@ -95,10 +97,16 @@ public class LVQ { id = modelBody.getId(); distEnd = dist; } + if (i == 0) { + dis0 = dist; + } else { + dis1 = dist; + } } MatrixBody modelBody = model[id]; Matrix modelMatrix = modelBody.getMatrix(); boolean isRight = id == type; + System.out.println("type==" + type + ",dis0==" + dis0 + ",dis1==" + dis1); Matrix matrix1 = op(matrix, modelMatrix, isRight); modelBody.setMatrix(matrix1); } diff --git a/src/main/java/org/wlld/nerveCenter/Normalization.java b/src/main/java/org/wlld/nerveCenter/Normalization.java index a189afc..ccd5d07 100644 --- a/src/main/java/org/wlld/nerveCenter/Normalization.java +++ b/src/main/java/org/wlld/nerveCenter/Normalization.java @@ -10,36 +10,26 @@ import org.wlld.tools.ArithUtil; * @date 1:29 下午 2020/3/15 */ public class Normalization { - private double max; - private double min; private long number; private double avg; private double sigma; - public double getMax() { - return max; - } - - public double getMin() { - return min; - } - public double getAvg() { return avg; } + public void setAvg(double avg) { + this.avg = avg; + } + public void avg() { - avg = ArithUtil.div(sigma, number); - //System.out.println("avg==" + avg); + if (avg == 0) { + avg = ArithUtil.div(sigma, number); + } + System.out.println(avg); } public void putFeature(double nub) { - if (nub > max) { - max = nub; - } - if (min == 0 || (nub != 0 && nub < min)) { - min = nub; - } if (nub != 0) { sigma = ArithUtil.add(sigma, nub); number++; diff --git a/src/main/java/org/wlld/nerveEntity/ModelParameter.java b/src/main/java/org/wlld/nerveEntity/ModelParameter.java index 5e24b30..1fd0051 100644 --- a/src/main/java/org/wlld/nerveEntity/ModelParameter.java +++ b/src/main/java/org/wlld/nerveEntity/ModelParameter.java @@ -1,5 +1,6 @@ package org.wlld.nerveEntity; +import org.wlld.MatrixTools.Matrix; import org.wlld.imageRecognition.border.Frame; import org.wlld.imageRecognition.modelEntity.KBorder; import org.wlld.imageRecognition.modelEntity.LvqModel; @@ -22,7 +23,34 @@ public class ModelParameter { private DymNerveStudy dymOutNerveStudy = new DymNerveStudy();//动态神经元输出层 private Map borderMap = new HashMap<>();//边框距离模型 private LvqModel lvqModel;//LVQ模型 + private Map> matrixK = new HashMap<>();//均值特征向量 private Frame frame;//先验边框 + private double avg;//特别均值 + private double dnnAvg;// + + public double getDnnAvg() { + return dnnAvg; + } + + public void setDnnAvg(double dnnAvg) { + this.dnnAvg = dnnAvg; + } + + public double getAvg() { + return avg; + } + + public Map> getMatrixK() { + return matrixK; + } + + public void setMatrixK(Map> matrixK) { + this.matrixK = matrixK; + } + + public void setAvg(double avg) { + this.avg = avg; + } public Frame getFrame() { return frame; diff --git a/src/main/java/org/wlld/nerveEntity/OutNerve.java b/src/main/java/org/wlld/nerveEntity/OutNerve.java index b77beb3..b877452 100644 --- a/src/main/java/org/wlld/nerveEntity/OutNerve.java +++ b/src/main/java/org/wlld/nerveEntity/OutNerve.java @@ -45,7 +45,7 @@ public class OutNerve extends Nerve { } else { this.E = 0; } - System.out.println("E===" + this.E + ",out==" + out+",nerveId=="+getId()); + System.out.println("E===" + this.E + ",out==" + out+",nerveId=="+getId()); gradient = outGradient();//当前梯度变化 //调整权重 修改阈值 并进行反向传播 updatePower(eventId); @@ -66,8 +66,8 @@ public class OutNerve extends Nerve { Matrix myMatrix = dynamicNerve(matrix, eventId, isKernelStudy); if (isKernelStudy) {//回传 Matrix matrix1 = matrixMapE.get(E); - //System.out.println("E================" + E); - //System.out.println(myMatrix.getString()); + System.out.println("E================" + E); + System.out.println(myMatrix.getString()); if (matrix1.getX() <= myMatrix.getX() && matrix1.getY() <= myMatrix.getY()) { double g = getGradient(myMatrix, matrix1); backMatrix(g, eventId); diff --git a/src/test/java/org/wlld/HelloWorld.java b/src/test/java/org/wlld/HelloWorld.java index c0322ed..05dc7d2 100644 --- a/src/test/java/org/wlld/HelloWorld.java +++ b/src/test/java/org/wlld/HelloWorld.java @@ -25,17 +25,15 @@ import java.util.Map; */ public class HelloWorld { public static void main(String[] args) throws Exception { - test(); - //food(); - //testPic(); - //testModel(); + //test1(); + food(); } public static void test() throws Exception { Picture picture = new Picture(); TempleConfig templeConfig = new TempleConfig(true); templeConfig.setClassifier(Classifier.DNN); - templeConfig.init(StudyPattern.Accuracy_Pattern, true, 1000, 1000, 2); + templeConfig.init(StudyPattern.Accuracy_Pattern, true, 1000, 1000, 3); Operation operation = new Operation(templeConfig); for (int i = 1; i < 300; i++) {//一阶段 System.out.println("study1===================" + i); @@ -113,41 +111,40 @@ public class HelloWorld { //读取本地URL地址图片,并转化成矩阵 Matrix a = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/a" + i + ".jpg"); //Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); - //Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); - Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); + Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); + //Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); //Matrix f = picture.getImageMatrixByLocal("D:\\share\\picture/f" + i + ".png"); //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 //第二次学习的时候，第三个参数必须是 true // operation.learning(f, 0, false); operation.learning(a, 1, false); - //operation.learning(b, 2, false); - //operation.learning(c, 2, false); - operation.learning(d, 2, false); + // operation.learning(b, 2, false); + operation.learning(c, 2, false); + //operation.learning(d, 4, false); } - ModelParameter modelParameter = templeConfig.getModel(); - String model = JSON.toJSONString(modelParameter); - System.out.println(model); - System.out.println("======================================"); -// ModelParameter modelParameter = JSON.parseObject(ModelData.DATA2, ModelParameter.class); +// ModelParameter modelParameter = JSON.parseObject(ModelData.DATA8, ModelParameter.class); // templeConfig.insertModel(modelParameter); //二阶段 for (int i = 1; i < 300; i++) { Matrix a = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/a" + i + ".jpg"); //Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); - Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); + Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); + //Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); + operation.normalization(a, templeConfig.getConvolutionNerveManager()); - //operation.normalization(b); - operation.normalization(d, templeConfig.getConvolutionNerveManager()); + //operation.normalization(b, templeConfig.getConvolutionNerveManager()); + operation.normalization(c, templeConfig.getConvolutionNerveManager()); + //operation.normalization(d, templeConfig.getConvolutionNerveManager()); } templeConfig.getNormalization().avg(); - for (int j = 0; j < 1; j++) { + for (int j = 0; j < 3; j++) { for (int i = 1; i < 300; i++) { System.out.println("study2==================" + i); //读取本地URL地址图片,并转化成矩阵 Matrix a = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/a" + i + ".jpg"); - // Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); - //Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); - Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); + //Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); + Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); + //Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); //Matrix f = picture.getImageMatrixByLocal("D:\\share\\picture/f" + i + ".png"); //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 //第二次学习的时候，第三个参数必须是 true @@ -156,231 +153,104 @@ public class HelloWorld { operation.learning(a, 1, true); //System.out.println("2==============="); //operation.learning(b, 2, true); - operation.learning(d, 2, true); - // operation.learning(d, 3, true); + operation.learning(c, 2, true); + //operation.learning(d, 4, true); } } templeConfig.finishStudy();//结束学习 + ModelParameter modelParameter = templeConfig.getModel(); + String model = JSON.toJSONString(modelParameter); + System.out.println(model); + ModelParameter modelParameter2 = JSON.parseObject(model, ModelParameter.class); + TempleConfig templeConfig2 = new TempleConfig(false); + templeConfig2.init(StudyPattern.Accuracy_Pattern, true, 1000, 1000, 2); + templeConfig2.insertModel(modelParameter2); + + Operation operation2 = new Operation(templeConfig2); int wrong = 0; int allNub = 0; for (int i = 300; i <= 320; i++) { //读取本地URL地址图片,并转化成矩阵 Matrix a = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/a" + i + ".jpg"); //Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); - //Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); - Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); + Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); + //Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 //第二次学习的时候，第三个参数必须是 true allNub += 2; int an = operation.toSee(a); - //int bn = operation.toSee(b); - int dn = operation.toSee(d); + int cn = operation.toSee(c); if (an != 1) { wrong++; } -// if (bn != 2) { -// wrong++; -// } - if (dn != 2) { + if (cn != 2) { wrong++; } - //int cn = operation.toSee(c); - //int dn = operation.toSee(d); } double wrongPoint = ArithUtil.div(wrong, allNub); - System.out.println("错误率：" + (wrongPoint * 100) + "%"); + System.out.println("错误率1：" + (wrongPoint * 100) + "%"); + +// wrong = 0; +// allNub = 0; +// for (int i = 300; i <= 320; i++) { +// //读取本地URL地址图片,并转化成矩阵 +// Matrix a = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/a" + i + ".jpg"); +// //Matrix b = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/b" + i + ".jpg"); +// Matrix c = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/c" + i + ".jpg"); +// //Matrix d = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/picture/d" + i + ".jpg"); +// //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 +// //第二次学习的时候，第三个参数必须是 true +// allNub += 2; +// int an = operation2.toSee(a); +// int cn = operation2.toSee(c); +// if (an != 1) { +// wrong++; +// } +// if (cn != 2) { +// wrong++; +// } +// } +// wrongPoint = ArithUtil.div(wrong, allNub); +// System.out.println("错误率2：" + (wrongPoint * 100) + "%"); // ModelParameter modelParameter2 = templeConfig.getModel(); // String model1 = JSON.toJSONString(modelParameter2); // System.out.println("完成阶段==" + model1); } - public static void testPic() throws Exception { - //测试SPEED模式学习过程 - //初始化图像转矩阵类:作用就是说将一个图片文件转化为矩阵类 + public static void test1() throws Exception {//覆盖率计算 Picture picture = new Picture(); - //初始化配置模板类,设置模式为SPEED_PATTERN模式 即速度模式 - TempleConfig templeConfig = getTemple(true, StudyPattern.Speed_Pattern, false); - //初始化计算类，并将配置模版和输出回调类载入计算类 - //运算类有两个构造一个是配置回调类，一个是不配置回调类 - //若使用定位功能，则无需配置回调类，若不启用，则要配置回调类 - //回调类要实现OutBack接口中的方法 - Ma ma = new Ma(); - Operation operation = new Operation(templeConfig, ma); - //标注主键为 第几种分类，值为标注 1 是TRUE 0是FALSE - //给训练图像进行标注，健是分类的ID,对应的就是输出结果的ID值，值要么写0要么写1 - // 1就是 是这种分类，0就是不是这种分类 + TempleConfig templeConfig = new TempleConfig(false); + templeConfig.init(StudyPattern.Cover_Pattern, true, 320, 240, 2); + Operation operation = new Operation(templeConfig); Map rightTagging = new HashMap<>();//分类标注 Map wrongTagging = new HashMap<>();//分类标注 rightTagging.put(1, 1.0); - wrongTagging.put(1, 0.0); - // 例如上面的标注了 只有一种分类，第一个MAP是true标注，第二个map是false标注 - for (int i = 1; i < 1000; i++) { - System.out.println("开始学习1==" + i); - //读取本地URL地址图片(适用于电脑本地图片),并转化成矩阵 - //注意学习图片至少要一千张+同物体的不同图片，学习的越多就越准，拿同样的图片反复循环学习是没用的 - //picture.getImageMatrixByIo(InputStream) 另外一个api,是通过字节流读取图片矩阵,适用于网络传输的图片 - Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/c/c" + i + ".png"); - Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b" + i + ".png"); - //将图像矩阵和标注加入进行学习，正确的图片配置正确的标注true，错误的图片配置错误的标注false - //right这个矩阵是 正确的图片 所以要配置上面正确的标注1.0 学习告诉计算机这个图片是正确的 - operation.study(right, rightTagging); - //wrong这个矩阵是错误的图片，所以要配置上面错误的标注0.0 学习 告诉计算机这个图片是错误的 - operation.study(wrong, wrongTagging); - } - - Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/test/a101.png"); - Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b1000.png"); - ma.setNub(1); - operation.look(wrong, 3); - ma.setNub(0); - operation.look(right, 2); - - - //如果启用物体坐标定位，则在学习结束的时候，一定要执行boxStudy方法 - //若不启用，则请不要使用，否则会报错 - //templeConfig.boxStudy(); - //获取训练结束的模型参数，提取出来转化成JSON保存数据库，下次服务启动时不用学习 - //直接将模型参数注入 - //获取模型MODLE 这个模型就是我们程序学习的目的，学习结束后我们要拿到这个模型 - ModelParameter modelParameter = templeConfig.getModel(); - //将模型MODEL转化成JSON 字符串 保存到数据库 留待下次服务启动的时候，识别提取用 - String model = JSON.toJSONString(modelParameter); - System.out.println(model); - //以上就是SPEED模式下的学习全过程，识别的过程就是再次初始化，将学习结果注入之后使用 - - //识别过程 - //将从数据库取出的JSON字符串转化为模型MODEL -// ModelParameter modelParameter1 = JSONObject.parseObject(model, ModelParameter.class); -// //初始化模型配置 -// TempleConfig templeConfig1 = getTemple(false, StudyPattern.Speed_Pattern, false); -// //注入之前学习结果的模型MODEL到配置模版里面，将学习结果注入就可以使用识别了 -// templeConfig1.insertModel(modelParameter1); -// //将配置模板配置到运算类 -// Operation operation1 = new Operation(templeConfig1); -// //获取本地图片字节码转化成降纬后的灰度矩阵 -// Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/test/a101.png"); -// Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b1000.png"); -// //进行图像识别 参数说明 eventId,事件id,因为输出结果是在回调类回调的，所以必须有个主键去判断事件 -// //说明你回调是响应的哪一次调用的ID,所以每一次识别调用，请用不同的id -// operation1.look(wrong, 3); -// operation1.look(right, 2); - //若启用定位功能检测请使用lookWithPosition,若没有启用，使用检测会报错 - //返回map,主键是分类id,值是该图片中此分类有多少个物体，每个物体的具体位置坐标的大小 - //Map> map = operation1.lookWithPosition(right, 4); - } - - public static TempleConfig getTemple(boolean isFirst, int pattern - , boolean isPosition) throws Exception { - //创建一个配置模板类，作用：主要是保存及载入一些配置参数用 - TempleConfig templeConfig = new TempleConfig(false); - if (isPosition) { - templeConfig.setHavePosition(true); - Frame frame = new Frame(); - frame.setWidth(3024); - frame.setHeight(4032); - frame.setLengthHeight(100); - frame.setLengthWidth(100); - templeConfig.setFrame(frame); + wrongTagging.put(2, 1.0); + Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/picture/yes1.jpg"); + Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/picture/no4.jpg"); + int a = 1; + for (int i = 0; i < a; i++) { + operation.coverStudy(right, rightTagging, wrong, wrongTagging); } - //全连接层深度,选填可不填 不填默认值为2 - //这就像人类大脑的意识深度原理一样，深度学习越深，训练结果越准，但是训练量成几何倍数增加 - //比如默认深度是2 需要 正负模板各一千+张照片进行训练。识别率70%（数值只是举个例子，不是具体数值） - //当深度改成3，则需要正负模板各三千+张照片进行训练,识别率 80%，深度4，八千+90% - //以此类推，，内存允许的情况下，深度无限 识别率无限接近与百分之百 - //但是有极限，即超过某个深度，即使再增加深度，识别率反而会下降。需要具体不断尝试找到 合适的深度 - //注意：若深度提升，训练量没有成倍增长，则准确度反而更低！ - //templeConfig.setDeep(2); - //启用定位学习 注意启用在图片中对某个物体进行定位，要注意 - //学习的图片必须除了学习的物体以外，其他位置都是白色或者空白(即用PS扣空)。 - //即该图片除了这个物体，没有其他任何干扰杂色（一个像素的杂色都不可以有） - //templeConfig.setHavePosition(true); - //窗口类，就是用来扫描图片的窗口大小和移动距离的设定 - //Frame frame = new Frame(); - //初始化配置模版，参数说明(int studyPattern, boolean initPower, int width, int height - //, int classificationNub) - //studyPattern 学习模式：常量值 StudyPattern.Accuracy_Pattern;StudyPattern.Speed_Pattern - //第一种模式精准模式，第二种模式是速度模式 - //精准模式顾名思义，准确相对高很多，但是缺点也很明显学习速度慢，不是一般的慢，CPU学习1000张图片 - //24小时都不够用！它学习速度比速度模式学习速度慢十倍都不止！但是执行识别速度上，却比速度模式还要快一点！ - //第二种速度模式，学习速度明显很快，一千张图片的学习大概一个半小时左右，但是精准度上差了一些 - //但是依然还是比较精准的，尤其做分类判断的时候，问题不大。 - //如何选择模式：在大部分情况下速度模式就够用了，在分类一张图片，比如这张图片有苹果的概率是多少 - //有橘子的概率是多少，精准度已经足够，它不是不精准，只是相对于精准模式要差一些 - //所以在大部分情况下，还是建议用速度模式，满足很多识别分类需求 - //initPower,是否是第一次初始化 - //学习就是学的模型参数，学完了要把模型参数类拿出来，序列化成JSON字符串，保存数据库 - //下次服务启动，读取JSON字符串，反序列化为MODEL模型 直接注入就可，无需再次学习 - //如果说你是要学习就写true,如果已经有学习结果了，你要注入之前的学习结果就是false - //如果你选了false还没有进行注入的话，你取模型参数你可以看到所有参数都是0 - //width heigth ,要学习的图片宽高，注意：这个宽高不是严格图片尺寸，而是一个大致尺寸 - //要识别和学习的图片尺寸与这个宽高比 必要相差太大就好，而且宁长勿短 - //classificationNub 要识别的有几个分类，比如我就识别苹果，就是1 有两种苹果橘子就是 2 - templeConfig.init(pattern, isFirst, 3204, 4032, 1); - - return templeConfig; - } - - public static void testModel() throws Exception { - // 模型参数获取及注入 实例 - TempleConfig templeConfig = getTemple(true, StudyPattern.Accuracy_Pattern, false); - ModelParameter modelParameter1 = templeConfig.getModel(); - String model = JSON.toJSONString(modelParameter1); - System.out.println(model); - TempleConfig templeConfig2 = getTemple(false, StudyPattern.Accuracy_Pattern, false); - ModelParameter modelParameter3 = JSONObject.parseObject(model, ModelParameter.class); - templeConfig2.insertModel(modelParameter3); - ModelParameter modelParameter2 = templeConfig2.getModel(); - String model2 = JSON.toJSONString(modelParameter2); - System.out.println(model2); + System.out.println("学习完成"); + double point = operation.coverPoint(right, 1); + double point2 = operation.coverPoint(wrong, 1); } - public static void testPic2() throws Exception { - //测试Accuracy_Pattern 模式学习过程，跟SPEED模式相同的部分就不再说明了 - Picture picture = new Picture(); - TempleConfig templeConfig = getTemple(true, StudyPattern.Accuracy_Pattern, false); - Ma ma = new Ma(); - Operation operation = new Operation(templeConfig, ma); - for (int i = 1; i < 100; i++) { - System.out.println("开始学习1==" + i); - //读取本地URL地址图片,并转化成矩阵 - Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/c/c" + i + ".png"); - Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b" + i + ".png"); - //将图像矩阵和标注加入进行学习 注意的是 Accuracy_Pattern 模式 要学习两次 - //这里使用learning方法，前两个参数与SPEED模式相同，多了一个第三个参数 - //第一次学习的时候 这个参数必须是 false - //最后一个参数id - operation.learning(right, 1, false); - operation.learning(wrong, 0, false); - } - for (int i = 1; i < 300; i++) {//神经网络学习 - System.out.println("开始学习2==" + i); - //读取本地URL地址图片,并转化成矩阵 - Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/c/c" + i + ".png"); - Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b" + i + ".png"); - //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 - //第二次学习的时候，第三个参数必须是 true - operation.learning(right, 1, true); - operation.learning(wrong, 0, true); - } - ModelParameter modelParameter = templeConfig.getModel(); - String st = JSON.toJSONString(modelParameter); - System.out.println(st); - for (int i = 300; i < 320; i++) {//神经网络学习 - //读取本地URL地址图片,并转化成矩阵 - Matrix right = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/c/c" + i + ".png"); - Matrix wrong = picture.getImageMatrixByLocal("/Users/lidapeng/Desktop/myDocment/b/b" + i + ".png"); - //将图像矩阵和标注加入进行学习，Accuracy_Pattern 模式 进行第二次学习 - //第二次学习的时候，第三个参数必须是 true - ma.setNub(1); - operation.look(right, 100 + i); - ma.setNub(0); - operation.look(wrong, 200 + i); + private static void compare(List point, List point2) { + int size = point.size(); + int max = 0; + int min = 0; + for (int i = 0; i < size; i++) { + if (point.get(i) >= point2.get(i)) { + max++; + } else { + min++; + } } - //进行图像识别，Accuracy_Pattern 模式学习结果获取和注入，跟SPEED模式一致 - //若有疑问可以参考一下 testModel()方法 - + System.out.println("size==" + size + ",max==" + max + ",min==" + min); } } diff --git a/src/test/java/org/wlld/ModelData.java b/src/test/java/org/wlld/ModelData.java index 2b11ddd..2945a30 100644 --- a/src/test/java/org/wlld/ModelData.java +++ b/src/test/java/org/wlld/ModelData.java @@ -7,9 +7,18 @@ package org.wlld; */ public class ModelData { //3 300 1 - public static final String DATA = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.3184117978057788,0.2538378486754306,0.23598860319585002,0.672857303830912,0.5162121322222845,0.08332256076708677,0.590596227559845,0.22902204460895093,0.43438424724572056],\"threshold\":0.4904237197269504},{\"list\":[0.4763300369733009,0.6734306357037342,0.5984711022099723,0.40438336289961996,0.8830048910514265,0.25604889607546133,0.7170081730748459,0.3174329231415727,0.5884359389471504],\"threshold\":1.056942151131312},{\"list\":[0.11230679688718814,0.7952006043922973,0.7732599103069119,0.038091105645318035,0.34494157051664287,0.5479193903249479,0.907674236602937,0.01202269229004238,0.3021253897254498],\"threshold\":0.745242496346202},{\"list\":[0.31290751538176886,0.5357472257484844,0.272265969371698,0.99789814190066,0.7584162911400247,0.6999516538868418,0.6167205101343987,0.6412732524989405,0.9454394831264122],\"threshold\":0.59278995281841}],\"dymOutNerveStudy\":{\"list\":[0.9936152510402008,0.32742551540649245,0.5213511753804201,0.3622992410855377,0.06901452617920045,0.9950845960569792,0.5692775890932051,0.058550539937031965,0.10371938534237934],\"threshold\":1.21529607620181},\"outNerves\":[]}"; + public static final String DATA = "{\"avg\":0.0,\"borderMap\":{},\"depthNerves\":[],\"dnnAvg\":0.0,\"dymNerveStudies\":[{\"list\":[0.21386561317212516,0.009488977515904384,0.2580300322361818,0.4155623366958594,0.2809883242300064,0.22757431818957274,0.7070233073204675,0.9963383321391794,0.2974674171095313],\"threshold\":0.927980009954601},{\"list\":[0.6139824138406837,0.848592149992762,0.11995668047582697,0.17403917571056982,0.596247928711875,0.1393545841985424,0.8544983006621639,0.6993232783746578,0.0654296158591735],\"threshold\":0.724568522705215},{\"list\":[0.12401829967617672,0.45860989137861896,0.5488276504363337,0.23189301491257874,0.838329140376511,0.36308478272515643,0.6513967078157683,0.27750404816046725,0.04824515867946633],\"threshold\":1.013707467214271},{\"list\":[0.2832448384717695,0.8793199516114596,0.9036631767376881,0.11754402128323371,0.5306081170631864,0.025053066877304686,0.16551488971527617,0.6754107564660323,0.2626782358746901],\"threshold\":1.012338636154329}],\"dymOutNerveStudy\":{\"list\":[0.424119922930295,0.19666754613193516,0.4176647621081778,0.8141387378801389,0.8118335001862937,0.2402037476137422,0.07503053582018648,0.3258679983214372,0.2921011111059505],\"threshold\":0.520419311934906},\"matrixK\":{1:[1.1151047938677752,1.0389059715718838,1.096190163013303,0.0,0.9579145567495949,0.6564978691371489,0.5345890640407466,0.0,0.9221994024897776,0.5368114297533536,0.5955657922130423,0.0,0.0,0.0,0.0,0.0],2:[1.0400421086476799,0.9419389067023733,0.8791312075456774,0.0,0.9719522609262787,0.5710431194961899,0.5197201684885815,0.0,0.9538420082679987,0.4831765736178256,0.48228503593213723,0.0,0.0,0.0,0.0,0.0]},\"outNerves\":[]}"; // 3 1500 1 public static final String DATA2 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.5992498041989176,0.9926179996606052,0.2226186951769814,0.626014877801968,0.41777548580985047,0.5568339809097999,0.4553301785025139,0.8986926580019458,0.006675229011633643],\"threshold\":0.144183721483083},{\"list\":[0.18613381329455836,0.7771421795458648,0.4425601037862027,0.405464967359739,0.7856853392297681,0.4695959784637539,0.5294530572970207,0.9692845726825765,0.7264871890036256],\"threshold\":0.583093688785858},{\"list\":[0.9471842752031596,0.3995683085317374,0.7477195010925697,0.4049622756191821,0.9382658206535007,0.20702488461382695,0.9199611908187407,0.9013998239273493,0.4267215156562749],\"threshold\":0.422794485948362},{\"list\":[0.060941945090878136,0.2661890863915305,0.1722666050945334,0.9879141320902391,0.9987637494050916,0.8029205429981493,0.1687199517742487,0.13708224319845608,0.8503774749629872],\"threshold\":0.689402140612162}],\"dymOutNerveStudy\":{\"list\":[0.21112229956632178,0.005112892022949733,0.4414460069608359,0.5348759353647939,0.0324423149676758,0.498326757782078,0.3288659531837589,0.31799689769781514,0.5999508479679976],\"threshold\":2.468958698521815},\"outNerves\":[]}"; //3 1500 10 public static final String DATA3 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.3609858275677438,0.8695683818272887,0.5329053396889802,0.19690320052250676,0.0012356893002913871,0.08119183573872635,0.567522490930904,0.9580337359942463,0.6320646582386631],\"threshold\":0.418979218798598},{\"list\":[0.08077371105142461,0.64134547426653,0.34961994201692914,0.19070385634295328,0.4416756560213294,0.1423248840621545,0.8044425709436543,0.09950211800238429,0.8801247123840051],\"threshold\":-0.4768406867671554},{\"list\":[3.900735714394976E-4,0.15618059301827414,0.18417958623071085,0.6537323646238727,0.0747588706371376,0.5826734683118383,0.10811618329321016,0.5290284019721624,0.36809827529225303],\"threshold\":-2.745724878837075},{\"list\":[0.21442987124603552,0.6490212557989394,0.5364211380251058,0.4857701296744934,0.06309260570901509,0.4868919004063589,0.8041533980083085,0.8553463093307884,0.3241215738893486],\"threshold\":-5.658666427672271}],\"dymOutNerveStudy\":{\"list\":[0.41321240126264813,0.15021526119360606,0.6295635109979753,0.6011294126313477,0.19829497750926106,0.21710590164847998,0.19626940829264394,0.9006600755036579,0.052962787280072865],\"threshold\":-16.3163161042187},\"outNerves\":[]}"; + //2 300 10 + public static final String DATA4 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.7650868673956612,0.41735680484600424,0.772749504058288,0.8384599613367586,0.06718497215232833,0.8850293262766552,0.8851009321760257,0.3377147487002068,0.026600923407615995],\"threshold\":0.4085539955045393},{\"list\":[0.6323922682200495,0.9312225577559277,0.49848962848457745,0.8877566654400643,0.26067491091518213,0.05808389805584624,0.4959719028971741,0.22358587752136916,0.375118935336723],\"threshold\":-0.822655134763225},{\"list\":[0.21616781794077045,0.21359089014595734,0.9866031753826975,0.039237788355860115,0.48405579610217797,0.8457815806254125,0.9692919219180153,0.21887259464434694,0.49735020888413284],\"threshold\":-1.777078438439913},{\"list\":[0.7032405099206009,0.12322216338010372,0.6691753686809487,0.48265272696372263,0.26687076772952245,0.5671989493130618,0.1477514710970167,0.4174529137169356,0.6341882949153155],\"threshold\":-3.916736185074929}],\"dymOutNerveStudy\":{\"list\":[0.29402787308416467,0.23358880323416897,0.8108657396965971,0.8102529215195801,0.41073391427871375,0.13840233568741056,0.5405034618507846,0.12995627329543935,0.7458170503569194],\"threshold\":-8.44190117544671},\"outNerves\":[]}"; + public static final String DATA5 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.4467703081299109,0.6216350552316628,0.9614933454364657,0.20607668094161646,0.4887977243589058,0.63160869587642,0.5541665393807305,0.6780176493077679,0.311045145099047],\"threshold\":0.806141233738043},{\"list\":[0.16664166723178497,0.6177168961084486,0.5094827323811009,0.8030743749033795,0.2949448909891714,0.5048826684603277,0.29728972921303953,0.5163889826059106,0.31636746120315484],\"threshold\":0.523335756133632},{\"list\":[0.5002599844181366,0.23168031749716456,0.009972722232462483,0.19765661174031213,0.41487704196451936,0.08114152168166133,0.1734755737329785,0.5765370682837576,0.4749258231617214],\"threshold\":0.645293861900744},{\"list\":[0.06267312603488806,0.3148365387915856,0.3261441144961199,0.8599692822928876,0.8794020011762773,0.18877316316816117,0.816967692916158,0.010279303231223502,0.28176395163091383],\"threshold\":1.056555408293605}],\"dymOutNerveStudy\":{\"list\":[0.4493364790159943,0.4464735195422622,0.8194912362912562,0.935208152582449,0.7759469222501951,0.3795323237713125,0.7802158181253224,0.6609269355803631,0.31953583656073115],\"threshold\":0.682843377796887},\"outNerves\":[]}"; + //2 0.1 + public static final String DATA6 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.8069552113481556,0.9709947341686338,0.8838778668807168,0.6858754757820691,0.019100112280012738,0.8675478242399742,0.31779795357047036,0.438831240616934,0.7834457892763799],\"threshold\":0.839652880616655},{\"list\":[0.2819343042226351,0.9392430985853434,0.11897477128098588,0.9414462009850345,0.9357828227358187,0.8242763362124853,0.5897533297885068,0.6613018520014384,0.14782106837196884],\"threshold\":1.912734137149397},{\"list\":[0.7950299356209136,0.8994152720194233,0.757710289644511,0.9890273982984203,0.6684213522161923,0.9597212014443263,0.42162950011258993,0.1524423462033272,0.6710784474787098],\"threshold\":1.595986359815487},{\"list\":[0.8890190098865085,0.9278430186565028,0.5480879104416314,0.5522431496953174,0.9450374957936978,0.5627594309925331,0.8671171308411209,0.7230267707344997,0.1090669307419706],\"threshold\":2.504113323224686}],\"dymOutNerveStudy\":{\"list\":[0.04267175934492384,0.4514547106491408,0.046546962749144716,0.3504629797545291,0.2783094088271686,0.20570794277064375,0.7299870571145072,0.026151657300823472,0.47053571992281096],\"threshold\":8.56096975117539},\"outNerves\":[]}"; + //2 0.6 + public static final String DATA7 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.46173316081373994,0.4486734095170666,0.5029883665752177,0.597600986928206,0.4086387873977577,0.8779142340400046,0.16378077953004444,0.40582618886283484,0.32552136225232164],\"threshold\":0.2562632844306175},{\"list\":[0.7773693672054663,0.4998032282747368,0.5655034730629183,0.07366584261304943,0.9072008562364543,0.636108878788075,0.34388911329160443,0.057250457882118355,0.14325548820175782],\"threshold\":0.2719773200084111},{\"list\":[0.44084568625407994,0.9036050484740112,0.35363401279417217,0.44929011369320904,0.15355220827685778,0.7038226814943652,0.035940861653564915,0.11030056068876015,0.16106743745708696],\"threshold\":0.4858929366389904},{\"list\":[0.573021920573834,0.36173948006294054,0.4851225558555259,0.6551851006862296,0.02350569383822143,0.22903995583183123,0.7866925330329656,0.5370829087777349,0.314080216017122],\"threshold\":0.1522300406859472}],\"dymOutNerveStudy\":{\"list\":[0.9732205668914665,0.010102049212183939,0.5626877976156922,0.13973973457906597,0.684161397063244,0.19497578735439747,0.2814815486171073,0.5839054007704529,0.2943331072996984],\"threshold\":1.246060142517065},\"outNerves\":[]}"; + // 4, 0.5 + public static final String DATA8 = "{\"borderMap\":{},\"depthNerves\":[],\"dymNerveStudies\":[{\"list\":[0.3609022735768631,0.5228843326998576,0.9303941828424276,0.6222262949981907,0.5448921562801232,0.29569896203451584,0.06841809674998456,0.6134193642353059,0.34216270268514937],\"threshold\":0.2389134709633266},{\"list\":[0.9742804594757206,0.10860374841867138,0.8371688165313815,0.17951539490856316,0.546032702635937,0.5176832096036765,0.2495288922188591,0.8478566685542331,0.894923735682754],\"threshold\":0.2850603779895377},{\"list\":[0.36121949630243555,0.5859143906270796,0.5468236332149504,0.05378687354845646,0.3512992097931328,0.13625683405612388,0.6202254630205696,0.0650353007778075,0.5647629276326984],\"threshold\":0.759115425349785},{\"list\":[0.5694386770958892,0.3789577021367092,0.3157748138639176,0.40274289502160465,0.2511063843496081,0.6516883563448134,0.16624052998401884,0.4650047370696786,0.8290682828408158],\"threshold\":0.811893691079533}],\"dymOutNerveStudy\":{\"list\":[0.754223341880164,0.14424114572574498,0.1540688727819346,0.77730972089222,0.6546918655080118,0.433180762988736,0.7364788164529261,0.5682443264202726,0.6344744654518456],\"threshold\":1.842301397138919},\"outNerves\":[]}"; }