预测算法设计

1.具体应用实例。根据表2，预测序号15的跳高成绩。

表2 国内男子跳高运动员各项素质指标

4.4 (序号15)跳高成绩预测

4.4.1 数据整理

1）我们将前14组国内男子跳高运动员各项素质指标作为输入，即（30m行进跑，立定三级跳远，助跑摸高，助跑4-6步跳高，负重深蹲杠铃，杠铃半蹲系数，100m，抓举），将对应的跳高成绩作为输出。并用matlab自带的premnmx()函数将这些数据归一化处理。

数据集：（注意：每一列是一组输入训练集，行数代表输入层神经元个数，列数输入训练集组数）

P=[3.2 3.2 3 3.2 3.2 3.4 3.2 3 3.2 3.2 3.2 3.9 3.1 3.2;

9.6 10.3 9 10.3 10.1 10 9.6 9 9.6 9.2 9.5 9 9.5 9.7;

3.45 3.75 3.5 3.65 3.5 3.4 3.55 3.5 3.55 3.5 3.4 3.1 3.6 3.45;

2.15 2.2 2.2 2.2 2 2.15 2.14 2.1 2.1 2.1 2.15 2 2.1 2.15;

140 120 140 150 80 130 130 100 130 140 115 80 90 130;

2.8 3.4 3.5 2.8 1.5 3.2 3.5 1.8 3.5 2.5 2.8 2.2 2.7 4.6;

11 10.9 11.4 10.8 11.3 11.5 11.8 11.3 11.8 11 11.9 13 11.1 10.85;

50 70 50 80 50 60 65 40 65 50 50 50 70 70];

T=[2.24 2.33 2.24 2.32 2.2 2.27 2.2 2.26 2.2 2.24 2.24 2.2 2.2 2.35];

4.4.2 模型建立

4.4.2.1 BP网络模型

    BP网络（Back-ProPagation Network）又称反向传播神经网络， 通过样本数据的训练，不断修正网络权值和阈值使误差函数沿负梯度方向下降，逼近期望输出。它是一种应用较为广泛的神经网络模型，多用于函数逼近、模型识别分类、数据压缩和时间序列预测等。

import numpy as np

import scipy.special as sp

class net:

    def __init__(self, sample_data, output_data, hidden_num1,error=0.001, rate=0.8):

        sample_num, input_num = np.shape(sample_data)

        self.sample_data = sample_data  ##每个选手的各项成绩作为一行

        self.output_data = output_data

        self.sample_num = sample_num

        self.input_num = input_num

        self.hidden_num1 = hidden_num1

        self.rate = rate

        self.error = error

        self.max_data = max(self.output_data)

        self.min_data = min(self.output_data)

        self.output_data = (self.output_data-self.min_data)/(self.max_data-self.min_data)

        ##初始化权重矩阵

        self.w1 = np.random.rand(hidden_num1, input_num) * 2 - 1

        self.w2 = np.random.rand(hidden_num2, hidden_num1) * 2 - 1

        self.w3 = np.random.rand(1, hidden_num2) * 2 - 1

        self.b1 = np.random.rand(hidden_num1, 1) * 2 - 1

        self.b2 = np.random.rand(hidden_num2, 1) * 2 - 1

        self.b3 = np.random.rand(1,1) * 2 - 1

        self.train()

    def train(self):

        for i in range(self.sample_num):

            input_data = self.sample_data[i]

            lable  = self.output_data[i]

            input_data = input_data.reshape(self.input_num,1)

            lable = lable.reshape(1,1)

            input_hidden1 = np.dot(self.w1, input_data)+self.b1

            output_hidden1 = sp.expit(input_hidden1)

            output_hidden1 = output_hidden1.reshape(hidden_num1,1)

            input_hidden2 = np.dot(self.w2, output_hidden1)+self.b2

            output_hidden2 = sp.expit(input_hidden2)

            output_hidden2 = output_hidden2.reshape(hidden_num2, 1)

            input_out = np.dot(self.w3, output_hidden2)+self.b3

            final = sp.expit(input_out)

            E3 = final * (1 - final) * (lable - final)

            while (abs(E3) >= self.error):

                E2 = output_hidden2*(1-output_hidden2)*np.dot(self.w3.T,E3)

                E1 = output_hidden1*(1-output_hidden1)*np.dot(self.w2.T,E2)

                self.w1 += self.rate * E1 * input_data.T

                self.w2 += self.rate * E2 * output_hidden1.T

                self.w3 += self.rate * E3 * output_hidden2.T

                self.b1 += self.rate * E1

                self.b2 += self.rate * E2

                self.b3 += self.rate * E3

                input_hidden1 = np.dot(self.w1, input_data)+self.b1

                output_hidden1 = sp.expit(input_hidden1)

                output_hidden1 = output_hidden1.reshape(hidden_num1, 1)

                input_hidden2 = np.dot(self.w2, output_hidden1)+self.b2

                output_hidden2 = sp.expit(input_hidden2)

                output_hidden2 = output_hidden2.reshape(hidden_num2, 1)

                input_out = np.dot(self.w3, output_hidden2)+self.b3

                final = sp.expit(input_out)

                E3 = final * (1 - final) * (lable - final)

        print('finish train!')

    def privite(self, privite_data):

        privite_data = privite_data.reshape(self.input_num, 1)

        input_hidden1 = np.dot(self.w1, privite_data)+self.b1

        output_hidden1 = sp.expit(input_hidden1)

        output_hidden1 = output_hidden1.reshape(hidden_num1, 1)

        input_hidden2 = np.dot(self.w2, output_hidden1)+self.b2

        output_hidden2 = sp.expit(input_hidden2)

        output_hidden2 = output_hidden2.reshape(hidden_num2, 1)

        input_out = np.dot(self.w3, output_hidden2)+self.b3

        final = sp.expit(input_out)

        return (final*(self.max_data-self.min_data)+self.min_data)

sample_data =np.array([[3.2, 9.6, 3.45,2.15, 140,  2.8,11, 50 ],

 [  3.2,10.3, 3.75,2.2  ,120,  3.4,10.9,70 ],

 [  3,  9,  3.5, 2.2  ,140,  3.5,11.4,50 ],

 [  3.2,10.3, 3.65,2.2 , 150,  2.8,10.8,80 ],

 [  3.2,10.1, 3.5, 2, 80,  1.5,11.3,50 ],

 [  3.4,10,  3.4, 2.15, 130,  3.2,11.5,60 ],

 [  3.2, 9.6, 3.55,2.1, 130,  3.5,11.8,65 ],

 [  3,  9,  3.5, 2.1,  100,  1.8,11.3,40 ],

 [  3.2, 9.6, 3.55,2.1 , 130,  3.5,11.8,65 ],

 [  3.2, 9.2, 3.5, 2.1 , 140,  2.5,11, 50 ],

 [  3.2, 9.5, 3.4, 2.15, 115,  2.8,11.9,50 ],

 [  3.9, 9,  3.1, 2, 80,  2.2,13, 50 ],

 [  3.1, 9.5, 3.6, 2.1,90,  2.7,11.1,70 ],

 [  3.2, 9.7, 3.45,2.15, 130,  4.6,10.85 , 70 ]])

output_data = np.array([[2.24],[ 2.33],[2.24] , [2.32], [2.2], [2.27], [2.2], [2.26], [2.2], [2.24], [2.24], [2.2], [2.2], [2.35]])

hidden_num1 = 2

hidden_num2 = 1

a = net(sample_data,output_data,hidden_num1,hidden_num2)

privite_data = np.array([3.0,9.3,3.3,2.05,100,2.8,11.2,50])

y = a.privite(privite_data)

print("预测得到的跳高成绩为：",y[0][0])

运行结果如下：