
%% 清空环境变量
clc
clear
 
%% 训练数据预测数据提取及归一化
 
%1.下载四类语音信号
load data1 c1
load data2 c2
load data3 c3
load data4 c4
 
%2.四个特征信号矩阵合成一个矩阵
data(1:500,:)=c1(1:500,:);
data(501:1000,:)=c2(1:500,:);
data(1001:1500,:)=c3(1:500,:);
data(1501:2000,:)=c4(1:500,:);
 
%3.从1到2000间随机排序
k=rand(1,2000);%生成0-1之中2000个随机数
[m,n]=sort(k);%对k进行从从小到大的排序，序结果放入m（1*2000）向量，n（1*2000）为原数据对应的索引号
 
%4.输入输出数据
input=data(:,2:25);%取出data中2到25列数据构成新矩阵input
output1 =data(:,1);%取出data中第一列数据构成矩阵output1
 
%5.把输出从1维变成4维
for i=1:2000
    switch output1(i)
        case 1
            output(i,:)=[1 0 0 0];
        case 2
            output(i,:)=[0 1 0 0];
        case 3
            output(i,:)=[0 0 1 0];
        case 4
            output(i,:)=[0 0 0 1];
    end
end
 
%6.随机提取1500个样本为训练样本，500个样本为预测样本
input_train=input(n(1:1500),:)';
output_train=output(n(1:1500),:)';
input_test=input(n(1501:2000),:)';
output_test=output(n(1501:2000),:)';
 
%7.输入数据归一化
[inputn,inputps]=mapminmax(input_train);%归一化到[-1,1]之间，inputps用来作下一次同样的归一化
%%8.网络结构初始化，设置节点输入层，隐藏层，输出层
innum=24;
midnum=25;%选择多少个节点才比较好？
outnum=4;
 
 
%9.权值初始化
w1=rands(midnum,innum);%随机给定隐藏层和是输入层间的初始神经元权重   W1= net. iw{1, 1};
b1=rands(midnum,1);%中间各层神经元阈值  B1 = net.b{1};
w2=rands(midnum,outnum);%中间层到输出层的权值  W2 = net.lw{2,1};
b2=rands(outnum,1);%输出层各神经元阈值  B2 = net. b{2}
 
%10.权重，偏差重新赋值
w2_1=w2;w2_2=w2_1;%把w2中的值分别配给w1w2
w1_1=w1;w1_2=w1_1;
b1_1=b1;b1_2=b1_1;
b2_1=b2;b2_2=b2_1;
 
%11.学习率
xite=0.1   %权值阈值更新
alfa=0.01; %学习速率，这里设置为0.01
 
%%12 网络训练
%(1)大循环
for ii=1:10
    E(ii)=0;
    for i=1:1:1500
       %% （2）网络预测输出 
        x=inputn(:,i);
        % (3)隐含层输出
        for j=1:1:midnum
            I(j)=inputn(:,i)'*w1(j,:)'+b1(j); 
            Iout(j)=1/(1+exp(-I(j)));
        end
        % (4)输出层输出
        yn=w2'*Iout'+b2;
        
       %%(5) 权值阀值修正
        %计算误差
        e=output_train(:,i)-yn;     
        E(ii)=E(ii)+sum(abs(e));
        
        %计算权值变化率
        dw2=e*Iout;
        db2=e';
        
        for j=1:1:midnum
            S=1/(1+exp(-I(j)));
            FI(j)=S*(1-S);
        end      
        for k=1:1:innum
            for j=1:1:midnum
                dw1(k,j)=FI(j)*x(k)*(e(1)*w2(j,1)+e(2)*w2(j,2)+e(3)*w2(j,3)+e(4)*w2(j,4));
                db1(j)=FI(j)*(e(1)*w2(j,1)+e(2)*w2(j,2)+e(3)*w2(j,3)+e(4)*w2(j,4));
            end
        end
          %（6）权值阈值更新，学习率在这用 
        w1=w1_1+xite*dw1';
        b1=b1_1+xite*db1';
        w2=w2_1+xite*dw2';
        b2=b2_1+xite*db2';
        
        w1_2=w1_1;w1_1=w1;
        w2_2=w2_1;w2_1=w2;
        b1_2=b1_1;b1_1=b1;
        b2_2=b2_1;b2_1=b2;
    end
end
 
%%13 语音特征信号分类
inputn_test=mapminmax('apply',input_test,inputps);
for ii=1:1
    for i=1:500%1500
        %隐含层输出
        for j=1:1:midnum
            I(j)=inputn_test(:,i)'*w1(j,:)'+b1(j);
            Iout(j)=1/(1+exp(-I(j)));
        end
        
        fore(:,i)=w2'*Iout'+b2;
    end
end
%% 14结果分析
%（1）根据网络输出找出数据属于哪类
for i=1:500
    output_fore(i)=find(fore(:,i)==max(fore(:,i)));
end
%（2）BP网络预测误差
error=output_fore-output1(n(1501:2000))';
 
 
 
%画出预测语音种类和实际语音种类的分类图
figure(1)
plot(output_fore,'r')
hold on
plot(output1(n(1501:2000))','b')
legend('预测语音类别','实际语音类别')
%画出误差图
figure(2)
plot(error)
title('BP网络分类误差','fontsize',12)
xlabel('语音信号','fontsize',12)
ylabel('分类误差','fontsize',12)
%print -dtiff -r600 1-4
k=zeros(1,4);  
%找出判断错误的分类属于哪一类
for i=1:500
    if error(i)~=0               %~表示非也就是error不等于0是
        [b,c]=max(output_test(:,i));
        switch c
            case 1 
                k(1)=k(1)+1;
            case 2 
                k(2)=k(2)+1;
            case 3 
                k(3)=k(3)+1;
            case 4 
                k(4)=k(4)+1;
        end
    end
end
%找出每类的个体和
kk=zeros(1,4);
for i=1:500
    [b,c]=max(output_test(:,i));
    switch c
        case 1
            kk(1)=kk(1)+1;
        case 2
            kk(2)=kk(2)+1;
        case 3
            kk(3)=kk(3)+1;
        case 4
            kk(4)=kk(4)+1;
    end
end
%正确率
rightridio=(kk-k)./kk

这个我在程序中进行了比较详细的备注，数据集在前面网盘链接中可以获取，这个项目的python文件是我完全仿照matlab中写了，流程基本一样，不太具有再利用价值，所以可以看下视频中的思路和讲解。

2.2 蝴蝶花分类预测

这里需要注意的是这里数据集是已经打乱好的数据，python中不在是墨守成规的仿照matlab文件，而是写好了一个框架，虽然是打乱的数据集，但是也配备了随机抽取数据的函数，方便大家拿了就用！！

这里用的改进的bp神经网路，动量下降法进行加速收敛大致步骤原理公式如下

Step 1 ：初始化数据，设定各层节点数和学习效率等值。

Step 2 ：输入层 FA 输入样品，计算出隐层 FB 活动。

b(ki)=logsig(a*V(:,ki)+Pi(ki))

Step 3 ：计算出输出层 FC 活动。

c(kj)=logsig(b*W(:,kj)+Tau(kj))

Step 4 ：网络输出和期望输出相比较，计算出输出层 FC 的错误。

d=c.*(1-c).*(ck-c)

Step 5 ：反传，计算出隐层 FB 的错误。

e=b.*(1-b).*(d*W')

Step 6 ：修改 FC 层和 FB 之间的权值 wij 。

DeltaW(ki,kj)=Alpha*b(ki)*d(kj)+Gamma*DeltaWOld(ki,kj)

W=W+DeltaW

Step 7 ：修改 FA 层和 FB 之间的权值 vhj 。

DeltaV(kh,ki)=Beta*a(kh)*e(ki)

V=V+DeltaV

Step 8 ：修改偏差。

重复 Step 2 ～ Step 8 ，直到输出层 FC 的错误足够小。

2.2.1matlab程序如下


clc %清屏
clear all; %删除 workplace 变量
close all; %关掉显示图形窗口
format long 
% Initial 
% parameters for the NN structure 
h=4; 
i=3; 
j=3; 
Alpha=0.9; 
Beta=0.5; 
Gamma=0.85; 
Tor=0.0005; 
Maxepoch=2000;
Accuracy=0; 
Ntrain=115; 
Ntest=35; 
%随机赋值 [-1, +1] 
V=2*(rand(h,i)-0.5); 
W=2*(rand(i,j)-0.5); 
Pi=2*(rand(1,i)-0.5); 
Tau=2*(rand(1,j)-0.5); 
DeltaWOld(i,j)=0; 
DeltaVOld(h,i)=0; 
DeltaPiOld(i)=0; 
DeltaTauOld(j)=0; 
% the learning process 
Epoch=1; 
Error=10; 
%加载数据
load data.dat 
Odesired=data(:,2); 
% normalize the input data to rang [-1 +1] 
datanew=data(:,3:6); 
maxv=max(max(datanew)); 
minv=min(min(datanew)); 
datanorm=2*((datanew-minv)/(maxv-minv)-0.5); 
while Error>Tor 
 Err(Epoch)=0; 
 for k=1:Ntrain % k = the index of tranning set 
 a=datanorm(k,:); 
 % set the desired output ck[j] 
 if data(k,2)==0 
 ck=[1 0 0]; 
 elseif data(k,2)==1 
 ck=[0 1 0]; 
 else 
 ck=[0 0 1]; 
 end; 
 % calculate the hidden nodes activation 
 for ki=1:i 
 b(ki)=logsig(a*V(:,ki)+Pi(ki)); 
 end; 
 % calculate the output nodes activation 
 for kj=1:j 
 c(kj)=logsig(b*W(:,kj)+Tau(kj)); 
 end; 
 % calculate error in output Layer FC 
 d=c.*(1-c).*(ck-c); 
 % calculate error in hidden layer FB 
 e=b.*(1-b).*(d*W'); 
 % adjust weights Wij between FB and FC 
 for ki=1:i 
 for kj=1:j 
 DeltaW(ki,kj)=Alpha*b(ki)*d(kj)+Gamma*DeltaWOld(ki,kj); 
 end 
 end; 
 W=W+DeltaW; 
 DeltaWOld=DeltaW; 
 % adjust weights Vij between FA and FB 
 for kh=1:h 
 for ki=1:i 
 DeltaV(kh,ki)=Beta*a(kh)*e(ki); 
 end
end; 
 V=V+DeltaV; 
 DeltaVold=DeltaV; 
 % adjust thresholds Pi and Tau 
 DeltaPi=Beta*e+Gamma*DeltaPiOld; 
 Pi=Pi+DeltaPi; 
 DeltaPiold=DeltaPi; 
 DeltaTau=Alpha*d+Gamma*DeltaTauOld; 
 Tau=Tau+DeltaTau; 
 DeltaTauold=DeltaTau; 
 % the error is the max of d(1),d(2),d(3) 
 Err(Epoch)=Err(Epoch)+0.5*(d(1)*d(1)+d(2)*d(2)+d(3)*d(3)); 
 end %for k=1:Ntrain 
 Err(Epoch)=Err(Epoch)/Ntrain; 
 Error=Err(Epoch); 
 % the training stops when iterate is too much 
 if Epoch > Maxepoch 
 break; 
 end 
 Epoch = Epoch +1; % update the iterate number 
end 
% test data 
for k=1:Ntest % k = the index of test set 
 a=datanorm(Ntrain+k,:); 
 % calculate the hidden nodes activation 
 for ki=1:i 
 b(ki)=logsig(a*V(:,ki)+Pi(ki)); 
 end; 
 % calculate the output of test sets 
 for kj=1:j 
 c(kj)=logsig(b*W(:,kj)+Tau(kj)); 
 end; 
 % transfer the output to one field format 
 if (c(1)> 0.9) 
 Otest(k)=0; 
 elseif (c(2)> 0.9) 
 Otest(k)=1; 
 elseif (c(3)> 0.9) 
 Otest(k)=2; 
 else 
 Otest(k)=3; 
 end; 
 % calculate the accuracy of test sets 
 if Otest(k)==Odesired(Ntrain+k) 
 Accuracy=Accuracy+1; 
 end; 
end; % k=1:Ntest 
% plot the error 
plot(Err); 
% plot the NN output and desired output during test 
N=1:Ntest; 
figure; plot(N,Otest,'b-',N,Odesired(116:150),'r-'); 
% display the accuracy 
Accuracy = 100*Accuracy/Ntest; 
t=['正确率: ' num2str(Accuracy) '%' ]; 
disp(t);

2.2.2 python实现和框架如下

每一部分具体的功能都进行了标注


import math
import random
import numpy
from sklearn import preprocessing
import time
import xlwt
import matplotlib.pyplot as plt
 
 
random.seed(0)
 
def read_data(dir_str):
    '''
    读取txt文件中的数据
    数据内容：科学计数法保存的多行多列数据
    输入：txt文件的路径
    输出：小数格式的数组，行列与txt文件中相同
    '''
    data_temp = []
    with open(dir_str) as fdata:
        while True:
            line=fdata.readline()
            if not line:
                break
            data_temp.append([float(i) for i in line.split()])
    return numpy.array(data_temp)
 
 
def randome_init_train_test(data, n_tr):
    ''' 随机划分训练集和测试集 '''
    # sklearn提供一个将数据集切分成训练集和测试集的函数train_test_split
    train_index = numpy.random.choice(data.shape[0], size=n_tr, replace=False, p=None)
    train_data = data[train_index]  
    test_index = numpy.delete(numpy.arange(data.shape[0]),train_index)  # 删除train_index对应索引的行数
    test_data = data[test_index] 
    return train_data, test_data
 
 
def min_max_normalization(np_array):
    ''' 离差标准化，(Xi-min(X))/(max(X)-min(X)) '''
    min_max_scaler = preprocessing.MinMaxScaler()  
    ret = min_max_scaler.fit_transform(np_array)  
    return ret
 
 
def label_to_value(label):
    ''' 标签转换为对应输出值 (由于输出层结构，需要修改输出数据结构)'''
    switch = {
        0.0: [1,0,0],
        1.0: [0,1,0],
        2.0: [0,0,1]
    }
    return switch[label]
 
 
def value_to_label(value):
    ''' 神经网络输出值转换为对应标签 '''
    return value.index(max(value)) 
 
 
def rand(min, max):
    ''' 随机取[a, b]范围内的值 '''
    return (max - min) * random.random() + min
 
 
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):  # 设置在BP神经网络中用到的参数
        self.input_n = 0
        self.hidden_n = 0
        self.output_n = 0
        self.input_values = []  # [1.0] * self.input_n
        self.hidden_values = []  # [1.0] * self.hidden_n
        self.output_values = []  # [1.0] * self.output_n
        self.input_weights = []
        self.output_weights = []
        self.input_correction = []                     # dw1
        self.output_correction = []                    # dw2
        self.input_bias = []
        self.output_bias = []
 
    def setup(self, ni, nh, no):  # 参数设置
        self.input_n = ni
        self.hidden_n = nh
        self.output_n = no
        # init
        self.input_values = [1.0] * self.input_n    # 输入层神经元输出（输入特征）
        self.hidden_values = [1.0] * self.hidden_n  # 中间层神经元输出
        self.output_values = [1.0] * self.output_n  # 隐藏层神经元输出（预测结果）
        self.input_weights = make_matrix(self.input_n, self.hidden_n)
        self.output_weights = make_matrix(self.hidden_n, self.output_n)
        # 初始随机赋值，在范围[-1, +1]内
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                self.input_weights[i][h] = rand(-1, 1)
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                self.output_weights[h][o] = rand(-1, 1)
        self.input_correction = make_matrix(self.input_n, self.hidden_n)
        self.output_correction = make_matrix(self.hidden_n, self.output_n)
        self.input_bias = [0.0] * self.input_n
        self.output_bias = [0.0] * self.output_n
 
    def predict(self, inputs):  # 前向传播（在train中套在反向传播的train前面）
        # 输入层计算
        for i in range(self.input_n - 1):
            self.input_values[i] = inputs[i]
        # 隐藏层计算
        for j in range(self.hidden_n):
            total = 0.0
            for i in range(self.input_n):
                total += self.input_values[i] * self.input_weights[i][j]
            self.hidden_values[j] = sigmoid(total + self.input_bias[i])
        # 输出层计算
        for k in range(self.output_n):
            total = 0.0
            for j in range(self.hidden_n):
                total += self.hidden_values[j] * self.output_weights[j][k]
            self.output_values[k] = sigmoid(total + self.output_bias[j])
        return self.output_values[:]
 
    def back_propagate(self, case, label, learn, correct):
        # 前向预测
        self.predict(case)
        # 计算输出层的误差 w2
        output_deltas = [0.0] * self.output_n
        for o in range(self.output_n):
            error = label[o] - self.output_values[o]
            output_deltas[o] = sigmoid_derivative(self.output_values[o]) * error
        # 计算隐藏层的误差 w1
        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_weights[h][o]
            hidden_deltas[h] = sigmoid_derivative(self.hidden_values[h]) * error
        # 更新隐藏-输出层权重 b2
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                change = output_deltas[o] * self.hidden_values[h]
                self.output_weights[h][o] += learn * change + correct * self.output_correction[h][o]
                self.output_correction[h][o] = change
                self.output_bias[o] += learn * change
        # 更新输入-隐藏层权重 b1
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                change = hidden_deltas[h] * self.input_values[i]
                self.input_weights[i][h] += learn * change + correct * self.input_correction[i][h]
                self.input_correction[i][h] = change
                self.input_bias[h] += learn * change
 
        # 计算样本的均方误差
        error = 0.0
        for o in range(len(label)):
            error += 0.5 * (label[o] - self.output_values[o]) ** 2
        return error
 
    def train(self, datas, labels, epochs=5000, learn=0.05, correct=0.1, stop_error=0.001):
        for j in range(epochs):
            error = 0.0
            for i in range(len(datas)):
                label = labels[i]
                data = datas[i]
                error += self.back_propagate(data, label, learn, correct)
            if error <= stop_error:
                return j+1
        return epochs
 
def save_excel(datas, output_file):
    # 将数据保存到新的excel表格里
    # 因为xls文件支持最大数据行数为65536，所以大文件输出成几个小文件，每个小文件有MAX_EXCEL_ROWS行数据
    MAX_EXCEL_ROWS = 60000
    for no in range(0, datas.__len__()//MAX_EXCEL_ROWS + 1):
        sheet_name = 'sheet' + str(no+1)
        output_file_name = output_file.split('.')[0] + str(no+1) + '.' + output_file.split('.')[-1]
        print('输出文件：', output_file_name)
        excel = xlwt.Workbook() 
        sh = excel.add_sheet(sheet_name)
        for i, data in enumerate(datas[no*MAX_EXCEL_ROWS:(no+1)*MAX_EXCEL_ROWS]):
            for j, d in enumerate(data):
                sh.write(i, j, d)
        try:
            excel.save(output_file_name)
        except:
            xxx = input('输出异常!!请检查输出路径是否异常或文件是否已存在(需删除已存在文件)。然后输入任意键即可...')
            no = no - 1
    print('结束gool luck')
 
if __name__ == '__main__':
    n_tr = 115
    input_nodes = 4
    hidden_nodes = 3        #
    output_nodes = 3
    epochs = 1000           
    learn_rate = 0.5       # 学习率
    momentum_rate = 0.09    # 动量参数
    correct_rate = 0.1      # 矫正率
 
    data = read_data(r"D:\优化大作业\BPNN_Butterfly classification\data.txt")
    normal_data = min_max_normalization(data[:, 2:])  # 变量归一化
    data = numpy.concatenate((data[:, 1:2],normal_data),axis=1)  # 取出输出的结果和标准化的数据拼接在一起
    tr, te = randome_init_train_test(data, n_tr)  # 随机划分训练集和测试集
    tr_in = tr[:, 1:]
    tr_out = [label_to_value(v[0]) for v in tr[:, :1]]  # 由于输出层使用3个节点，需要修改输出数据结构
    n_true = 0      # 统计正确预测数量
 
    nn = BPNeuralNetwork()  
    nn.setup(input_nodes, hidden_nodes, output_nodes)   # 设置BP神经网络框架
    st = time.perf_counter()
    epoch = nn.train(tr_in, tr_out, epochs, learn_rate, correct_rate)   # train(self, datas, labels, epochs=5000, learn=0.05, correct=0.1, stop_error=0.001)
    print('epoch:', epoch, '\nTrain_time:', time.perf_counter() - st)
    pre = []
    for t in te:
        t_in = t[1:]
        label = value_to_label(nn.predict(t_in))
        if label == t[0]:
            n_true += 1
        # print(t, label)
        pre.append([label])
    
    # 输出统计结果
    accuracy = n_true/(data.shape[0]-n_tr)
    print('accuracy:', accuracy)
    print(nn.input_bias, nn.output_bias)
    # numpy.savetxt(r'bpnn_param\input_weights.txt', (nn.input_weights), fmt='%s')
    # numpy.savetxt(r'bpnn_param\output_weights.txt', (nn.output_weights), fmt='%s')
    # numpy.savetxt(r'bpnn_param\input_correction.txt', (nn.input_correction), fmt='%s')
    # numpy.savetxt(r'bpnn_param\output_correction.txt', (nn.output_correction), fmt='%s')
 
    # 将数据保存到新的excel表格里
    te_pre = numpy.concatenate((te, numpy.array(pre)), axis=1)
    save_excel(te_pre, 'test_result.xls')
 
    # 绘制准确率曲线
    x_axis_data = [i for i in range(35)]
    y_axis_data1 = te[:, :1]    # 真实结果
    y_axis_data2 = pre          # 预测结果
    plt.xlabel('测试集数', fontproperties='SimHei')
    plt.ylabel('预测分类', fontproperties='SimHei')
    plt.plot(x_axis_data, y_axis_data1, color='blue', label='真实结果' )
    plt.plot(x_axis_data, y_axis_data2, color='red', label='预测结果')
    plt.show()

3.心得分享

经过自己的学习和研究，感觉可以先看懂公式，然后把程序导进去，用好断点，一步一步步进或者调试模式，看看得到的程序的结果和应该得出的结果得维数是不是相同，数据是否合理，研究透之后可以多自己写一写练一练，基本就没啥问题啦~

up也是刚开始学习，有什么问题可以多多交流，互相学习~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/105628