跟着【莫烦python】学习神经网络框架TensorFlow和Pytorch学习笔记

视频链接： Tensorflow. and Pytorch.

感想：莫烦老师确实讲的很好，视频课收益很多，Pytorch比Tensorflow好用很多！看完视频课程还要多加动手练习才能真正掌握！！

TF搭建自己的神经网络

case 1

处理结构

神经网络的结构

input layer（x and y）
hidden layer（权重 和 偏置）
output layer

tf：先建立结构——>数据放到结构中

case 2

用代码实现tf的结构

session

类似于指针，指向某个变量，用户指定、输出

第一种用法

sess=tf.session()
res=sees.run(xxx)
print(res)

第二种用法

with tf.Session() as sess:
res = sess.run(xxx)
print(res)

variable

变量，一定要初始化，激活
init=tf.global_variables_initializer()
sess.run(init)

定义：
a = tf.variable(0,name=‘abc’)

placeholder

placeholder 和 feed_dict组合使用

定义，类似于先声明后使用，但是先不赋值：
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

用feed_dict进行赋值：
sess.run(output,feed_dict={input1:[7.],input2:[2.]})
sess.run(loss,feed_dict={xs:x_data,ys:y_data})

激励函数 activation function

解决不能用线性方程解决的问题=解决非线性的问题

线性：y=Wx
激励函数：y=AF(Wx)
激励函数就是AF()，如relu()、sigmod()、tanh()
激励函数必须要可以微分，即求导

激励函数的适应场景

在少量层的神经网络结构中

可以有多种选择

在CNN中

用 relu

在RNN中

用 relu 或 tanh

case 3 定义、添加层

层可以调用，输入不同的参数

可视化——优化过程

import matplotlib.pyplot as plt

fig=plt.figure()
ax = fig.add_subplot(1,1,1)
#先打印真实的数据
ax.scatter(x_data,y_data)
plt.ion()

需要实时显示的内容的代码

plt.show()

try:
    ax.lines.remove(lines[0])  #消除原本的线再打印新的线
except Exception:
    pass
prediction_value= sess.run(prediction,feed_dict={xs:x_data})
lines = ax.plot(x_data,prediction_value,'r-',lw=5)  #红色的线，宽度为5
plt.pause(0.1)

加速神经网络训练——优化器optimizer

1.Stochastic Gradient Descent（SGD） ！！常用
数据分批，每次训练一批

2.Momentum ！！高阶
考虑当前一步和上一步的learning rate

3.AdaGrad

4.RMSProp（合并2和3） ！！高阶

5.Adam ！！高阶

可视化——神经网络结构——tensorboard

分类问题classification

loss用交叉熵计算
数字识别例子classification.py

过拟合

解决方法：
1.增大数据量
2.正规化
2.1 L1： cost=(Wx - realy)^2 + abs(W)
2.2 L2 cost=(Wx - realy)^2 + (W)^2
2.3 Dropout 随机忽略一些神经元的连接

卷积神经网络CNN

1.一块一块像素区域进行处理
2.卷积、池化操作
3.用于图片分类等
4.图片有长宽高、高度表示颜色、卷积的过程是不断缩小长宽同时增加高度

saver保存读取

Pytorch搭建自己的神经网络

TF先搭建静态流程图，再传入数据计算
pytorch搭建的是动态图

numpy和torch的区别

numpy：计算矩阵
torch：张量，神经网络界的numpy，可以替代numpy
torch 和 numpy 是兼容的，并且可以自由转换

#numpy——>torch
torch_data = torch.from_numpy(np_data)

#torch——>numpy
torch2numpy = torch_data.numpy()

激活函数

回归问题

plt 画图只能处理numpy数据
对于variable 数据要 variable_name.data.numpy()
对于神经网络，只能处理variable数据，因此要把tensor数据x转换为x=variable(x),后不需此步
对于torch，只能处理tensor数据

loss_func用均方差 loss=torch.nn.MSEloss()

搭建神经网络的步骤：

1.构建训练data和测试data
2.把数据分批次DataLoader
3.用class nn_name(torch.nn.Module):…定义神经网络，层数，输入输出维数，激活函数
4.创建神经网络
5.定义损失函数和优化器
6.用神经网络进行预测得到prediction
7.计算loss=loss_func(prediciton,y)
8.先把梯度设置为0：optimizer.zero_grad()
9.反向传播 loss.backward()
10.优化梯度 optimizer.step()

回归问题

loss_func用交叉熵 loss=torch.nn.CrossEntropyLoss()

快速构建神经网络

net2 = torch.nn.Sequential(
    torch.nn.Linear(2,10),
    torch.nn.ReLU(),
    torch.nn.Linear(10,2),
)

效果等价于

class Net(torch.nn.Module):
    #下面两句一定做，官方步骤
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__()
        #参数是输入、输出的维度
        #隐藏层
        self.hidden = torch.nn.Linear(n_feature,n_hidden)
        #预测层/输出层
        self.pred = torch.nn.Linear(n_hidden,n_output)

    #真正搭建神经网络，x是输入信息
    def forward(self,x):
        #先经过隐藏层，再经理激励函数
        x = F.relu(self.hidden(x))
        #再经过预测层，不用激活函数
        x = self.pred(x)
        return x

net = Net(2,10,2)

效果等价于

class Net(torch.nn.Module):
    #下面两句一定做，官方步骤
    def __init__(self):
        super(Net,self).__init__()
        #参数是输入、输出的维度
        #隐藏层
        self.hidden = torch.nn.Linear(1,10)
        #预测层/输出层
        self.pred = torch.nn.Linear(10,1)

    #真正搭建神经网络，x是输入信息
    def forward(self,x):
        #先经过隐藏层，再经理激励函数
        x = F.relu(self.hidden(x))
        #再经过预测层，不用激活函数
        x = self.pred(x)
        return x

net = Net()

保存提取nn

场景：训练好的神经网络 保存状态 继续提取当前状态 继续实验

批训练

#把数据放入数据库中去
#data_tensor=x,target_tensor=y
torch_dataset = Data.TensorDataset(x,y)
#使得训练成批次
loader = Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=2,#两个线程
)

#把整个数据训练3次
for epoch in range(3):
        for step,(batch_x,batch_y) in enumerate(loader):
            ......

定义程序入口

if __name__ == '__main__':

常见的搭建cnn的步骤

1.输入图片
2.convolution
3.max pooling
4.convolution
5.max pooling
6.fully connected
7.fully connected
8.classifier

#定义CNN

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(         # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,              # input height
                out_channels=16,            # n_filters
                kernel_size=5,              # filter size
                stride=1,                   # filter movement/step
                padding=2,                  # if want same width and length of this image after Conv2d, padding=(kernel_size-1)/2 if stride=1
            ),                              # output shape (16, 28, 28)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(kernel_size=2),    # choose max value in 2x2 area
        )                                   # output shape (16, 14, 14)
        self.conv2 = nn.Sequential(         # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),     # output shape (32, 14, 14)
            nn.ReLU(),                      # activation
            nn.MaxPool2d(2),                # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)  #（batch，32,7,7）
        x = x.view(x.size(0), -1) # flatten the output of conv2 to (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output, x    # return x for visualization

#创建一个CNN

cnn = CNN()

RNN 和 LSTM

解决RNN中的梯度消失和梯度爆炸问题

RNN classification

RNN如何处理图片问题？
把图片的输入看成从上至下按行输入，就是一串累积的信息

定义RNN

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.LSTM(         # if use nn.RNN(), it hardly learns
            input_size=INPUT_SIZE,
            hidden_size=64,         # rnn hidden unit
            num_layers=1,           # number of rnn layer
            batch_first=True,       # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)

    def forward(self, x):
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)
        # h_n shape (n_layers, batch, hidden_size)
        # h_c shape (n_layers, batch, hidden_size)
        r_out, (h_n, h_c) = self.rnn(x, None)   # None represents zero initial hidden state

        # choose r_out at the last time step
        out = self.out(r_out[:, -1, :])
        return out

创建一个RNN

rnn = RNN()

torch.max()用法

x:
 tensor([[0.5285, 0.1247, 0.8332, 0.5485],
        [0.7917, 0.6138, 0.5881, 0.3381],
        [0.4226, 0.6605, 0.8571, 0.0399],
        [0.1716, 0.0609, 0.9712, 0.4838]])
        
torch.max(x,1):
 (tensor([0.8332, 0.7917, 0.8571, 0.9712]), tensor([2, 0, 2, 2]))
 
torch.max(x,0):
 (tensor([0.7917, 0.6605, 0.9712, 0.5485]), tensor([1, 2, 3, 0]))
 
torch.max(x,1)[0]:
 tensor([0.8332, 0.7917, 0.8571, 0.9712])
 
torch.max(x,1)[1]:
 tensor([2, 0, 2, 2])
 
torch.max(x,1)[1].data:
 tensor([2, 0, 2, 2])
 
torch.max(x,1)[1].data.numpy():
 [2 0 2 2]
 
torch.max(x,1)[1].data.numpy().squeeze():
 [2 0 2 2]
 
torch.max(x,1)[0].data:
 tensor([0.8332, 0.7917, 0.8571, 0.9712])
 
torch.max(x,1)[0].data.numpy():
 [0.83318216 0.7917127  0.85708565 0.9711726 ]
 
torch.max(x,1)[0].data.numpy().squeeze():
 [0.83318216 0.7917127  0.85708565 0.9711726 ]

自编码Autoencoder————非监督学习

1.一种神经网络形式
2.原数据————>压缩encoder————精髓————>解压decoder————>new数据
3.计算原数据和新数据的误差

PCA主成分分析————提取主要特征
自编码类似于主成分分析，用于给原数据特征属性降维
只用得到x的数据，用不掉y的数据（标签）
不用test data

#定义autoencoder网络
class AutoEncoder(nn.Module):
    def __init__(self):
        super(AutoEncoder, self).__init__()
        #压缩过程：一个全连接层、tanh、全连接层、tanh、全连接层、tanh
        self.encoder = nn.Sequential(
            nn.Linear(28*28, 128),
            nn.Tanh(),
            nn.Linear(128, 64),
            nn.Tanh(),
            nn.Linear(64, 12),
            nn.Tanh(),
            nn.Linear(12, 3),   # compress to 3 features which can be visualized in plt
        )
        #解压过程：一个全连接层、tanh、全连接层、tanh、全连接层、tanh、全连接层、sigmoid
        self.decoder = nn.Sequential(
            nn.Linear(3, 12),
            nn.Tanh(),
            nn.Linear(12, 64),
            nn.Tanh(),
            nn.Linear(64, 128),
            nn.Tanh(),
            nn.Linear(128, 28*28),
            nn.Sigmoid(),       # compress to a range (0, 1)
        )

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return encoded, decoded

#创建autoencoder网络
autoencoder = AutoEncoder()

强化学习reinforcement

#定义网络

#创建网络

生成对抗网络 GAN

#定义autoencoder网络

#创建autoencoder网络

用gpu加速,代码如何修改？

1.第一个修改的地方

test_x = test_data.test_data.type(torch.FloatTensor)[:2000].cuda()/255.  
test_y = test_data.test_labels.numpy()[:2000].cuda()

2.第二个修改的地方

for step, (x, y) in enumerate(train_loader):
    b_x = x.cuda()  
    b_y = y.cuda()

3.第三个修改的地方

pred_y = torch.max(test_output, 1)[1].cuda().data.numpy()

#pred_y = pred_y.cup() #转回cpu上计算

4.第四个修改的地方

cnn = CNN()
cnn.cuda()

过拟合、缓解过拟合————Dropout

过拟合现象

1.数据量小的情况可能发生过拟合
2.泛化能力差

缓解过拟合现象————dropout

#有dropout
net_dropped = torch.nn.Sequential(
    torch.nn.Linear(1, N_HIDDEN),
    torch.nn.Dropout(0.5),  # drop 50% of the neuron
    torch.nn.ReLU(),
    torch.nn.Linear(N_HIDDEN, N_HIDDEN),
    torch.nn.Dropout(0.5),  # drop 50% of the neuron
    torch.nn.ReLU(),
    torch.nn.Linear(N_HIDDEN, 1),
)

#没有dropout易导致过拟合
net_overfitting = torch.nn.Sequential(
    torch.nn.Linear(1, N_HIDDEN),
    torch.nn.ReLU(),
    torch.nn.Linear(N_HIDDEN, N_HIDDEN),
    torch.nn.ReLU(),
    torch.nn.Linear(N_HIDDEN, 1),
)

注意：在evaluate时为了取消dropout的影响，切换为eval()模式

net_overfitting.eval()
net_dropped.eval()

切换回train模式

net_overfitting.train()
net_dropped.train()