干货！！！基于BP神经网络对加速度计传感器的标定代码（python）

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from torch.autograd import Variable
import torch
from torch.autograd import Variable
import numpy

数据读取

def load_csv(filename):
datax = [];
datay = []
f = pd.read_csv(filename)
datax_1 = (f[‘accX’].values / 16384) * 9.8
datax_2 = (f[‘accY’].values / 16384) * 9.8
datax_3 = (f[‘accZ’].values / 16384) * 9.8

datax.append(datax_1.tolist()[:2958])
datax.append(datax_2.tolist()[:2958])
datax.append(datax_3.tolist()[:2958])
datax = np.array(datax).T
print(datax)
w, h = datax.shape
datay = np.zeros((w, h))
datay[:, 2] = 9.8
return datay, datax

一定要继承 nn.Module

class TwoLayerNet(torch.nn.Module):
def init(self, input_size, hidden_size, output_size):
super(TwoLayerNet, self).init()
self.twolayernet = torch.nn.Sequential(
torch.nn.Linear(input_size, hidden_size),
torch.nn.ReLU(),
torch.nn.Linear(hidden_size, output_size),
)

def forward(self, x):
    y_pred = self.twolayernet(x)
    return y_pred

if name==“main”:
y, x = load_csv(“G:/桌面文件/21zuozu.csv”)
# M是样本数量，input_size是输入层大小， hidden_size是隐含层大小，output_size是输出层大小
input_size, hidden_size, output_size = 3, 12, 3
#输入数据
x1 = Variable(torch.from_numpy(x[:1000,:]).type(torch.FloatTensor))
y1 = Variable(torch.from_numpy(y[:1000,:]).type(torch.FloatTensor))
model = TwoLayerNet(input_size, hidden_size, output_size)
# 定义损失函数
loss_fn = torch.nn.MSELoss(size_average=True)
learning_rate = 0.003
EPOCH = 2000
# 使用optim包来定义优化算法
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

plt.ion()  # something about plotting
losses=[]
for t in range(EPOCH):
    y_pred = model(x1)
    loss = loss_fn(y_pred, y1)
    losses.append(loss)
    #if (t + 1) %1 == 0:
    #    print(loss.data.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if t % 1 == 0:
        # plot and show learning process
        plt.subplot(2, 2, 4)
        t1=list(range(len(losses)))
        plt.cla()
        plt.title("loss-function")
        plt.plot(t1,losses,c='blue',label="loss")
        plt.text(0, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color': 'green'})
        plt.legend()
        plt.pause(0.1)

        #--------------预测的部分--------------------------
        x2 = Variable(torch.from_numpy(x).type(torch.FloatTensor))
        y_pred=model(x2).data
        actual=x
        pre=y_pred.numpy()
        #print(pre)
        t=list(range(len(actual)))
        plt.subplot(2, 2, 3)
        plt.cla()
        plt.title("Z-data")
        plt.plot(t,actual[:,2],c="r",label="actual")
        plt.plot(t,pre[:,2],c="blue",label="pre")
        plt.legend()
        plt.pause(0.1)

        plt.subplot(2, 2, 1)
        plt.cla()
        plt.title("X-data")
        plt.plot(t,actual[:,0],c="r",label="actual")
        plt.plot(t,pre[:,0],c="blue",label="pre")
        plt.legend()
        plt.pause(0.1)

        plt.subplot(2, 2, 2)
        plt.cla()
        plt.title("Y-data")
        plt.plot(t,actual[:,1],c="r",label="actual")
        plt.plot(t,pre[:,1],c="blue",label="pre")
        plt.legend()
        plt.pause(0.1)