建模过程中的疑问记录

1、连接数据库，接入数据并且转化成dataframe 形式,采用以下语句

dataset=pd.DataFrame(list(cursor.fetchall()),columns=['tjsj','gmyszzyzs','gyydl'])

 说明：运行SQL语句后，必须转化后才能list，最好附带列名columns，生成期望的dataframe进行及进一步的处理加工。

2、数据中空缺值填充

data=dataset.fillna(method='bfill')

说明：1）method参数的取值 ： {‘pad’, ‘ffill’,‘backfill’, ‘bfill’, None}, default None

           2）pad/ffill：用前一个非缺失值去填充该缺失值

          3）backfill/bfill：用下一个非缺失值填充该缺失值

          4）None：指定一个值去替换缺失值（缺省默认这种方式）
3、dataframe 转成ndarray形式

values = data.values   #DataFrame 转化成ndarray

说明：便于后续的处理 

4、数据挖掘处理过程中，数据归一化操作必须是对于ndarray进行处理

    scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))   #归一化操作
    scaled = scaler.fit_transform(values)  #对于数据进行归一化

 说明：以上是对于转化成ndarray后的数据进行归一化操作，其中后期预测出来的数据自然也是归一化会的数据，需要进行归一化还原，采用的什么归一化方法就采用那个方法还原，这里采用的是#Z-Score标准化，重命名为saler 方法如下：

inv_yhat = scaler.inverse_transform(inv_yhat)   #解除归一化

5、数据集送入模型也是以ndarray的形式送入

 values = reframed.values
 X=values[:, :-1]   #数据集
 Y=values[:,-1]     #标签

说明：将dataframe转化成ndarray，然后划分特征和标签

6、数据在送入之前都是（样本数、特征数）构成，例如40个样本，每个样本10个特征，在送入之前就呈现40*10的样子构成，要送入神经网络中训练必须转化为3维的形式（样本数、步数、特征数），由于神经网络中一次性要将整个数据送入，里面按照步数进行一次送入数据训练，因此必须转化成三维数据，

# reshape input to be 3D [samples, timesteps, features] [样本数、步长、特征数]
 train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
 test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))

送入训练数据和测试数据进行模型训练
model.fit(train_X, train_y, epochs=300, batch_size=32, validation_data=(test_X, test_y), verbose=1, shuffle=False)
    #plot history

7、神经网络模型搭建代码如下，这部分就是搭建模型的部分，在模型中样本是一个一个运行处理的，因此输入的形状为一个样本的形状，因此模型中inoput_shape=(样本的长、样本的列)，其他的形状一次推算。keras搭建网络最简单。

# design network
    model = Sequential()
    model.add(GRU(50, input_shape=(train_X.shape[1], train_X.shape[2])))
    model.add(Dense(1))
    model.compile(loss='mae', optimizer='adam')

8、模型评估采用如下方法：预测出来的标签和真实标签对应两个列表，直接回计算出来

   mae = mean_absolute_error(inv_y, inv_yhat)   #真实值和预测值平均绝对误差
   mse = mean_squared_error(inv_y, inv_yhat)

9、pytorch  搭建神经网络模型的过程

1）搭建循环神经网络

import torch
import torch.nn as nn   #导入torch 中封装的函数（pytorch中比较全的函数块）
import torch.nn.functional as F   #导入functional中封装的函数（主要用于不涉及参数变化的函数）
import matplotlib.pyplot as plt
from torch.autograd import Variable  #用于将tensor转化成pytorch计算的数值类型

'''
构建数据
'''
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
y = x.pow(3)+0.1*torch.randn(x.size())
x , y =(Variable(x),Variable(y))   #将构建的tensor数据转化成pytorch模型需要的训练类型
print(x,y)
plt.scatter(x.data,y.data)
print(x.data,y.data)
plt.show()

'''
搭建神经网络
'''

'''
以下为搭建神经网络的模板
class Net(nn.Module):  #继承nn.Module
    def __init__(self):
        super(self).__init__()  #对于继承的类进行初始化
        pass
    def forward(self):
        pass
'''
#搭建神经网络模型
class Net(nn.Module):
    def __init__(self,n_input,n_hidden,n_output):  #子类初始化
        super(Net,self).__init__()  #父类初始化
        '''构建网络中，以一个样本为对象，输入神经元个数为为样本特征数，输出为隐藏层确定的神经元数，本质就是
        网络中采用流水线计算，一个一个计算，因此算法中是以一个样本为对象的'''
        self.hidden1=nn.Linear(n_input,n_hidden)
        '''以下都是遵循该法则依次计算，无非就是设置神经元的个数，该数量没有定数，可随意设置'''
        self.hidden2=nn.Linear(n_hidden,n_hidden)
        self.predict=nn.Linear(n_hidden,n_output)
    '''前向传播算法：该过程就是算法前向传播的过程，将上面构建的网络层串起来。'''
    def forward(self,input):
        out=self.hidden1(input)
        out=F.relu(out)
        out=self.hidden2(out)
        out=F.relu(out)
        out=self.predict(out)
        return out
'''此处设置不同 参数构建网络模型，设置优化器、损失计算方法'''
net=Net(1,20,1)
print(net)
optimizer=torch.optim.SGD(net.parameters(),lr=0.01)
#选择均方根误差进行回归模型评估
loss_fun=torch.nn.MSELoss()

# plt.ion()
# plt.show()

'''训练5000次'''
for t in range(5000):
    #由于数据量少，将整个数据集送入训练
    prediction = net(x)
    #计算损失
    loss = loss_fun(prediction,y)
    #每次计算完损失将更新的权重清零
    optimizer.zero_grad()
    loss.backward()
    #根据损失进行反向传播，更新权重
    optimizer.step()
#
    if t%5 ==0:
        plt.cla()  #清除当前的活动轴
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss = %.4f' % loss.data, fontdict={'size': 20, 'color': 'red'})
        plt.pause(0.05)
#
plt.ioff()
plt.show()

2）搭建卷积神经网络

import torch
from torch.autograd import Variable
#torch.autograd提供了类和函数用来对任意标量函数进行求导。
import torch.nn as nn
import torch.nn.functional as F


class MNISTConvNet(nn.Module):
    def __init__(self):
        super(MNISTConvNet, self).__init__()
        '''
这是对继承自父类的属性进行初始化。而且是用父类的初始化方法来初始化继承的属性。
也就是说，子类继承了父类的所有属性和方法，父类属性自然会用父类方法来进行初始化。
        '''
#定义网络结构
        '''nn.Conv2d(1, 10, 5) 2D卷积的过程中，不需要输入卷积矩阵的尺寸，只需要写入卷积前后的通道，此处的通道就是矩阵的深度，
        1表示输入图像深度为1，例如输入矩阵为100*100*1，此处的1就表示深度，10表示卷积后输出矩阵的深度，5表示5*5卷积核的大小'''
        self.conv1 = nn.Conv2d(1, 10, 5)
        '''nn.MaxPool2d(2, 2) 表示池化层，第一个2表示池化核的大小2*2，第二个2表示移动的步数'''
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(10, 20, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        '''全连接，表示将以上所有层的数据拼接层一条数据的，其中320输入为拼接后尺寸，输出50是在320的基础上抽取特征的输出'''
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)
    def forward(self, input):
        x = self.pool1(F.relu(self.conv1(input)))
        x = self.pool2(F.relu(self.conv2(x))).view(320)
        x = self.fc1(x)
        x = self.fc2(x)
        return x

net = MNISTConvNet()
print(net)
input = Variable(torch.randn(1, 1, 28, 28))
out = net(input)
print(out.size())