1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220

import java.util.Scanner;
public class BpNet
{
private static final int IM = 1;                  //输入层数量
    private static final int RM = 8;                  //隐含层数量
    private static final int OM = 1;                  //输出层数量
    private double learnRate = 0.55;                       //学习速率
    private double alfa = 0.67;                            //动量因子
    private double Win[][] = new double[IM][RM];     //输入到隐含连接权值
    private double oldWin[][] = new double[IM][RM];
private double old1Win[][] = new double[IM][RM];
private double dWin[][] = new double[IM][RM];
private double Wout[][] = new double[RM][OM];    //隐含到输出连接权值
    private double oldWout[][] = new double[RM][OM];
private double old1Wout[][] = new double[RM][OM];
private double dWout[][] = new double[RM][OM];
private double Xi[] = new double[IM];
private double Xj[] = new double[RM];
private double XjActive[] = new double[RM];
private double Xk[] = new double[OM];
private double Ek[] = new double[OM];
private double J = 0.1;
public static void main(String[] arg)
{
BpNet bpNet = new BpNet();
bpNet.train();
Scanner keyboard = new Scanner(System.in);
System.out.println("Please enter the parameter of input:");
double parameter;
while((parameter = keyboard.nextDouble()) != -1)
System.out.println(parameter + "*2+23=" + bpNet.bpNetOut(parameter / 100.0)[0] * 100.0);
}
public void train()
{
double y;
int n = 0;
//初始化权值和清零//
        bpNetinit();
System.out.println("training...");
while(J > Math.pow(10, -17))
{
for(n = 0; n < 20; n++)
{
y = n * 2 + 23; //逼近对象
                //前向计算输出过程//
                bpNetForwardProcess(n / 100.0, y / 100.0);
//反向学习修改权值//
                bpNetReturnProcess();
}
}
//在线学习后输出//
        for(n = 0; n < 20; n++)
{
y = n * 2 + 23;    //逼近对象
            System.out.printf("%.1f  ", y);
System.out.printf("%f  ", bpNetOut(n / 100.0)[0] * 100.0);
System.out.println("J=" + J);
}
System.out.println("n=20 " + "Out:" + this.bpNetOut(20 / 100.0)[0] * 100);
}
//
    // BP神经网络权值随机初始化
    // Win[i][j]和Wout[j][k]权值初始化为[-0.5,0.5]之间
    //
    public void bpNetinit()
{
//初始化权值和清零//
        for(int i = 0; i < IM; i++)
for(int j = 0; j < RM; j++)
{
Win[i][j] = 0.5 - Math.random();
Xj[j] = 0;
}
for(int j = 0; j < RM; j++)
for(int k = 0; k < OM; k++)
{
Wout[j][k] = 0.5 - Math.random();
Xk[k] = 0;
}
}
//
    // BP神经网络前向计算输出过程
    // @param inputParameter 归一化后的理想输入值(单个double值)
    // @param outputParameter  归一化后的理想输出值(单个double值)
    //
    public void bpNetForwardProcess(double inputParameter, double outputParameter)
{
double input[] = {inputParameter};
double output[] = {outputParameter};
bpNetForwardProcess(input, output);
}
//
    // BP神经网络前向计算输出过程--多个输入，多个输出
    // @param inputParameter  归一化后的理想输入数组值
    // @param outputParameter  归一化后的理想输出数组值
    //
    public void bpNetForwardProcess(double inputParameter[], double outputParameter[])
{
for(int i = 0; i < IM; i++)
{
Xi[i] = inputParameter[i];
}
//隐含层权值和计算//
        for(int j = 0; j < RM; j++)
{
Xj[j] = 0;
for(int i = 0; i < IM; i++)
{
Xj[j] = Xj[j] + Xi[i] * Win[i][j];
}
}
//隐含层S激活输出//
        for(int j = 0; j < RM; j++)
{
XjActive[j] = 1 / (1 + Math.exp(-Xj[j]));
}
//输出层权值和计算//
        for(int k = 0; k < OM; k++)
{
Xk[k] = 0;
for(int j = 0; j < RM; j++)
{
Xk[k] = Xk[k] + XjActive[j] * Wout[j][k];
}
}
//计算输出与理想输出的偏差//
        for(int k = 0; k < OM; k++)
{
Ek[k] = outputParameter[k] - Xk[k];
}
//误差性能指标//
        J = 0;
for(int k = 0; k < OM; k++)
{
J = J + Ek[k] * Ek[k] / 2.0;
}
}
//
    //BP神经网络反向学习修改连接权值过程
    //
    public void bpNetReturnProcess()
{
//反向学习修改权值//
        for(int i = 0; i < IM; i++) //输入到隐含权值修正
        {
for(int j = 0; j < RM; j++)
{
for(int k = 0; k < OM; k++)
{
dWin[i][j] = dWin[i][j] + learnRate * (Ek[k] * Wout[j][k] * XjActive[j] * (1 - XjActive[j]) * Xi[i]);
}
Win[i][j] = Win[i][j] + dWin[i][j] + alfa * (oldWin[i][j] - old1Win[i][j]);

old1Win[i][j] = oldWin[i][j];
oldWin[i][j] = Win[i][j];
}
}

for(int j = 0; j < RM; j++) //隐含到输出权值修正
        {
for(int k = 0; k < OM; k++)
{
dWout[j][k] = learnRate * Ek[k] * XjActive[j];
Wout[j][k] = Wout[j][k] + dWout[j][k] + alfa * (oldWout[j][k] - old1Wout[j][k]);

old1Wout[j][k] = oldWout[j][k];
oldWout[j][k] = Wout[j][k];
}
}
}
//
    // BP神经网络前向计算输出，训练结束后测试输出
    // @param inputParameter  测试的归一化后的输入值
    // @return  返回归一化后的BP神经网络输出值，需逆归一化
    //
    public double[] bpNetOut(double inputParameter)
{
double[] input = {inputParameter};
return bpNetOut(input);
}
//
    // BP神经网络前向计算输出，训练结束后测试输出
    // @param inputParameter 测试的归一化后的输入数组
    // @return  返回归一化后的BP神经网络输出数组
    //
    public double[] bpNetOut(double[] inputParameter)
{
//在线学习后输出//
        for(int i = 0; i < IM; i++)
{
Xi[i] = inputParameter[i];
}
//隐含层权值和计算//
        for(int j = 0; j < RM; j++)
{
Xj[j] = 0;
for(int i = 0; i < IM; i++)
{
Xj[j] = Xj[j] + Xi[i] * Win[i][j];
}
}
//隐含层S激活输出//
        for(int j = 0; j < RM; j++)
{
XjActive[j] = 1 / (1 + Math.exp(-Xj[j]));
}
//输出层权值和计算//
        double Uk[] = new double[OM];
for(int k = 0; k < OM; k++)
{
Xk[k] = 0;
for(int j = 0; j < RM; j++)
{
Xk[k] = Xk[k] + XjActive[j] * Wout[j][k];
Uk[k] = Xk[k];
}
}
return Uk;
}
}