本篇只给出实现的代码，下一篇将讲一讲实现的原理，及其Adline网络中的LMS算法原理。
包含两个类：
package com.cgjr.com;
import java.security.DigestInputStream;
import java.util.Arrays;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.data.DataSetRow;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.events.LearningEventListener;
import org.neuroph.util.TransferFunctionType;
public class AdalineDemo implements LearningEventListener {
public final static int CHAR_WIDTH = 5;
public final static int CHAR_HEIGHT = 7;
public static String[][] DIGITS = {
{
" 000 ",
"0 0",
"0 0",
"0 0",
"0 0",
"0 0",
" 000 "
},
{
" 0 ",
" 00 ",
"0 0 ",
" 0 ",
" 0 ",
" 0 ",
" 0 "
}, {
" 000 ",
"0 0",
" 0",
" 0 ",
" 0 ",
" 0 ",
"00000"
}, {
" 000 ",
"0 0",
" 0",
" 000 ",
" 0",
"0 0",
" 000 "
}, {
" 0 ",
" 00 ",
" 0 0 ",
"0 0 ",
"00000",
" 0 ",
" 0 "
}, {
"00000",
"0 ",
"0 ",
"0000 ",
" 0",
"0 0",
" 000 "
}, {
" 000 ",
"0 0",
"0 ",
"0000 ",
"0 0",
"0 0",
" 000 "
}, {
"00000",
" 0",
" 0",
" 0 ",
" 0 ",
" 0 ",
"0 "
}, {
" 000 ",
"0 0",
"0 0",
" 000 ",
"0 0",
"0 0",
" 000 "
}, {
" 000 ",
"0 0",
"0 0",
" 0000",
" 0",
"0 0",
" 000 "
}
};
public static void main(String[] args) {
Adaline ada = new Adaline(CHAR_WIDTH * CHAR_HEIGHT,DIGITS.length,0.01d,TransferFunctionType.LINEAR);
DataSet ds = new DataSet(CHAR_WIDTH * CHAR_HEIGHT, DIGITS.length);
for (int i = 0; i < DIGITS.length; i++) {
//一个数字符号就是一个训练的数据，第0个数字的的期望输出为0，第一个数字的期望输出为1等等。
ds.addRow(createTrainDataRow(DIGITS[i],i));
}
//ada.getLearningRule().addListener(new AdalineDemo());
ada.learn(ds);
for (int i = 0; i < DIGITS.length; i++) {
ada.setInput(image2data(DIGITS[i]));
ada.calculate();
printDIGITS(DIGITS[i]);
System.out.println(maxIndex(ada.getOutput()));
System.out.println(Arrays.toString(ada.getOutput()));
System.out.println();
}
}
private static int maxIndex(double[] output) {
//这其实就是选出最接近一的那个
double maxData=output[0];
int maxIndex=0;
for (int i = 0; i < output.length; i++) {
if(maxData<output[i]){
maxData=output[i];
maxIndex=i;
}
}
return maxIndex;
}
private static void printDIGITS(String[] image) {
for (int i = 0; i < image.length; i++) {
System.out.println(image[i]);
}
System.out.println("\n");
}
private static DataSetRow createTrainDataRow(String[] image, int idealValue) {
//设置所有的为输出为负一，只有当那个等于
double[] output=new double[DIGITS.length];
for (int i = 0; i < output.length; i++) {
output[i]=-1;
}
double[] input=image2data(image);
output[idealValue]=1;
DataSetRow dsr=new DataSetRow(input,output);
return dsr;
}
//将图像转换为数字，空格的地方为-1，不空格的地方为1
private static double[] image2data(String[] image) {
double[] input=new double[CHAR_WIDTH*CHAR_HEIGHT];
//行的长度，即为字符的长度，为整个字体的高度
for (int row = 0; row < CHAR_HEIGHT; row++) {
//有多少个列
for (int col = 0; col < CHAR_WIDTH; col++) {
int index=(row*CHAR_WIDTH)+col;
char ch=image[row].charAt(col);
input[index]=ch==‘0‘?1:-1;
}
}
return input;
}
@Override
public void handleLearningEvent(LearningEvent event) {
// TODO Auto-generated method stub
}
}
网络类：
package com.cgjr.com;
import org.neuroph.core.Layer;
import org.neuroph.core.NeuralNetwork;
import org.neuroph.nnet.comp.neuron.BiasNeuron;
import org.neuroph.nnet.learning.LMS;
import org.neuroph.util.ConnectionFactory;
import org.neuroph.util.LayerFactory;
import org.neuroph.util.NeuralNetworkFactory;
import org.neuroph.util.NeuralNetworkType;
import org.neuroph.util.NeuronProperties;
import org.neuroph.util.TransferFunctionType;
public class Adaline extends NeuralNetwork {
/**
* The class fingerprint that is set to indicate serialization compatibility
* with a previous version of the class.
*/
private static final long serialVersionUID = 1L;
/**
* Creates new Adaline network with specified number of neurons in input
* layer
*
* @param inputNeuronsCount
* number of neurons in input layer
*/
public Adaline(int inputNeuronsCount, int outputNeuronsCount, double learnRate, TransferFunctionType transferFunction) {
this.createNetwork(inputNeuronsCount, outputNeuronsCount, learnRate,transferFunction);
}
/**
* Creates adaline network architecture with specified number of input
* neurons
*
* @param inputNeuronsCount
* number of neurons in input layer
*/
private void createNetwork(int inputNeuronsCount, int outputNeuronsCount, double learnRate,
TransferFunctionType transferFunction) {
// set network type code
this.setNetworkType(NeuralNetworkType.ADALINE);
// create input layer neuron settings for this network
NeuronProperties inNeuronProperties = new NeuronProperties();
inNeuronProperties.setProperty("transferFunction", TransferFunctionType.LINEAR);
// createLayer input layer with specified number of neurons
Layer inputLayer = LayerFactory.createLayer(inputNeuronsCount, inNeuronProperties);
inputLayer.addNeuron(new BiasNeuron()); // add bias neuron (always 1,
// and it will act as bias input
// for output neuron)
this.addLayer(inputLayer);
// create output layer neuron settings for this network
NeuronProperties outNeuronProperties = new NeuronProperties();
if (transferFunction == TransferFunctionType.LINEAR) {
outNeuronProperties.setProperty("transferFunction", TransferFunctionType.LINEAR);
} else {
outNeuronProperties.setProperty("transferFunction", TransferFunctionType.RAMP);
outNeuronProperties.setProperty("transferFunction.slope", new Double(1));
outNeuronProperties.setProperty("transferFunction.yHigh", new Double(1));
outNeuronProperties.setProperty("transferFunction.xHigh", new Double(1));
outNeuronProperties.setProperty("transferFunction.yLow", new Double(-1));
outNeuronProperties.setProperty("transferFunction.xLow", new Double(-1));
}
// createLayer output layer (only one neuron)
Layer outputLayer = LayerFactory.createLayer(outputNeuronsCount, outNeuronProperties);
this.addLayer(outputLayer);
// createLayer full conectivity between input and output layer
ConnectionFactory.fullConnect(inputLayer, outputLayer);
// set input and output cells for network
NeuralNetworkFactory.setDefaultIO(this);
// set LMS learning rule for this network
LMS l = new LMS();
l.setLearningRate(learnRate);
this.setLearningRule(l);
}
}
运行的结果截图：
时间： 2024-10-05 04:15:32