Go to: 50488727

Input data becomes price forecast:

105.0,2,0.89,510.0

105.0,2,0.89,510.0

138.0,3,0.27,595.0

135.0,3,0.27,596.0

106.0,2,0.83,486.0

105.0,2,0.89,510.0

105.0,2,0.89,510.0

143.0,3,0.83,560.0

108.0,2,0.91,450.0

Recently, a method is used to write a paper, which is based on the optimal combination prediction of neural network, the main ideas are as follows: based on the combination forecasting model base of regression model, grey Prediction model and BP Neural Network prediction model, the combination of the above three single prediction models is used to form the BP neural network combined forecasting model. (I am referring to this article: Lu Yulong, Han Jing, Yu Si, Zhang Hongyan. Application of BP neural network combination forecast in the prediction of municipal solid waste production

My purpose.

I need a BP neural network to make continuous predictions. There are a lot of Python implementations on the BP neural network, but most of them are used for categorical decision making, so we have to figure out how to change the code.

Here is my reference to a BP neural network classification decision-making implementation (my continuous prediction code is based on the following link to change, thank you here):

Https://www.cnblogs.com/Finley/p/5946000.html

Modify the idea:

(1) The last layer does not activate, direct output. Or think of the activation function as f (x) =x

(2) The loss function function is changed to MSE

Code

The code with two # ——-around is the part I corrected.

Import Math

Import Random

Random.seed (0)

def rand (A, B):

Return (B-A) * Random.random () + A

Def Make_matrix (M, N, fill=0.0):

Mat = []

For I in range (m):

Mat.append ([fill] * N)

return mat

def sigmoid (x):

return 1.0/(1.0 + MATH.EXP (-X))

def sigmoid_derivative (x):

return x * (1-x)

Class Bpneuralnetwork:

def __init__ (self):

Self.input_n = 0

Self.hidden_n = 0

Self.output_n = 0

Self.input_cells = []

Self.hidden_cells = []

Self.output_cells = []

Self.input_weights = []

Self.output_weights = []

Self.input_correction = []

Self.output_correction = []

Def setup (self, NI, NH, no):

Self.input_n = ni + 1

self.hidden_n = NH

Self.output_n = no

# init cells< br> self.input_cells = [1.0] * self.input_n

Self.hidden_cells = [1.0] * self.hidden_n

Self.output_cells = [1.0] * Self.output_n

# init weights

Self.input_weights = Make_matrix (Self.input_n, self.hidden_n)

Self.output_ weights = Make_matrix (Self.hidden_n, Self.output_n)

# Random Activate

for I in Range (self.input_n):

for H in R Ange (self.hidden_n):

Self.input_weights[i][h] = rand ( -0.2, 0.2)

for h in range (Self.hidden_n):

for O in range ( Self.output_n):

Self.output_weights[h][o] = rand ( -2.0, 2.0)

# init correction matrix

Self.input_correction = Make_matrix (Self.input_n, self.hidden_n)

Self.output_correction = Make_matrix (Self.hidden_n, Self.output_n)

Def predict (self, inputs):

# Activate input layer

for I in Range (self.input_n-1):

Self.input_cells[i] = Inputs[i] #输入层输出值

# activate hidden layer

for J in Range (Self.hidden_n):

Total = 0.0

For i in range (self.in Put_n):

Total + = self.input_cells[i] * self.input_weights[i][j] #隐藏层输入值

Self.hidden_cells[j] = sigmoid Hidden layer Output Value

# Activate output layer

for K in range (Self.output_n):

Total = 0.0

for j in Range (Self.hidden_n): br> Total + = self.hidden_cells[j] * self.output_weights[j][k]

#-----------------------------------------------

# Self.output_cells[k] = sigmoid (total)

Self.output_cells[k] The excitation function of the =total# output layer is f (x) =x

#------------------- ----------------------------

return self.output_cells[:]

Def back_propagate (self, case, label, learn, correct): #x, Y, modify the maximum number of iterations, learning rate λ, correction rate μ three parameters.

# Feed forward

Self.predict (case)

# get output layer error

Output_deltas = [0.0] * Self.output_n

for o in range (self.output_n):

Error = Label[o]-self.output_cells[o]

#------------------------------------------ -----

# Output_deltas[o] = sigmoid_derivative (Self.output_cells[o]) * ERROR

Output_deltas[o] = Error

#------ -----------------------------------------

# get hidden layer error

Hidden_deltas = [0.0] * Self.hidden_n

for H In range (self.hidden_n):

Error = 0.0

for o in range (self.output_n):

Error + = output_deltas[o] * self.output_w Eights[h][o]

Hidden_deltas[h] = sigmoid_derivative (self.hidden_cells[h]) * ERROR

# Update Output weights

For h in range (Self.hidden_n):

For O in range (self.output_n):

Change = output_deltas[o] * Self.hidden_cells[h]

Self.output_weights[h][o] + = learn * change + correct * self.output_correction[h][o]#????????????????

Self.output_correction[h][o] = Change

# Update Input weights

For I in Range (Self.input_n):

For h in range (Self.hidden_n):

Change = hidden_deltas[h] * Self.input_cells[i]

SELF.INPUT_WEIGHTS[I][H] + = learn * change + correct * self.input_correction[i][h]

SELF.INPUT_CORRECTION[I][H] = Change

# Get global Error

Error = 0.0

For O in range (len label):

Error + = 0.5 * (Label[o]-self.output_cells[o]) * * 2

return error

Def train (self, cases, labels, limit=10000, learn=0.05, correct=0.1):

For j in range (limit):

Error = 0.0

For I in range (len (cases)):

label = Labels[i]

case = Cases[i]

Error + = Self.back_propagate (case, label, learn, correct)

def test (self):

cases = [

[10.5,2,0.89],

[10.5,2,0.89],

[13.8,3,0.27],

[13.5,3,0.27],

]

labels = [[0.51], [0.51], [0.595], [0.596]]

Self.setup (3, 5, 1)

Self.train (cases, labels, 10000, 0.05, 0.1)

For case in cases:

Print (self.predict (case))

if __name__ = = ' __main__ ':

nn = Bpneuralnetwork ()

Nn.test ()

Experimental results:

[0.5095123779256603]

[0.5095123779256603]

[0.5952606219141522]

[0.5939697670509705]

Neural network for regression prediction of continuous variables (python)