machine-learning - 如何使用 tensorflow 实现这个神经网络架构？

Question

我是这个领域的新手，也许这就是我感到困惑的原因。我无法获得所需的结果，因为它显示的准确性非常低，这意味着我做错了。

该图具有 RNN 结构，模型接受输入 (x)，并通过 NNAF(激活函数)，然后在移位运算符的帮助下传回一个值以供将来使用(与vRNN)。该图更像是控制理论中的动态系统。

import sklearn
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
import matplotlib.pyplot as plt
import sklearn.model_selection
from tensorflow.keras import layers
data= pd.read_csv("u.csv")
#print(data.head())
plt.plot(data)
plt.show()
import tensorflow
x=data.iloc[:,:3].values
y=data.iloc[:,-1].values
n_features = 1
n_steps = 3


x_train, x_test, y_train, y_test = sklearn.model_selection.train_test_split(x,y, test_size=0.1)
xtr=x_train
# create and fit the network
n_features = 1
x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], n_features))
model = Sequential()

# expected input data shape: (batch_size, timesteps, data_dim)
model = tensorflow.keras.Sequential()

model.add(layers.Embedding(input_dim=3, output_dim=1))  # returns a sequence of vectors of dimension 
model.add(layers.SimpleRNN(2, return_sequences=True))  # returns a sequence of vectors of dimension 
model.add(layers.SimpleRNN(2))  # return a single vector of dimension 32
model.add(Dense(1, activation='softmax'))
model.compile(optimizer='adam', loss='mse')
model.fit(x_train, y_train)
x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], n_features))
y_pred=model.predict(x_train)
#print(x_train.shape)
#print(y_train.shape)

print(model.layers[0].get_weights()[0]) # W - input weights
print(model.layers[0].get_weights()[1]) # U - recurrent weights
print(model.layers[0].get_weights()[2]) # b - output
m=model.layers[0].get_weights()[0]
   

Answer 1

如果您想使用 pytorch 创建神经网络。 神经网络有很多种类型，三个构建 block 是:

FFN:

1. 前馈神经网络。
2. CNN:卷积神经网络。
3. RNN:循环神经网络。 (LSTM 是 RNN 的一种，您可以使用下面的 RNN 代码并对其进行更改以获得 LSTM ，如果您觉得困难请告诉我，我将发布更改)

让我们从 FNN 开始: FNN 由三层组成:

1. 输入层
2. 隐藏层
3. 读出层。

在 MNIST 的情况下，每个输入层的形状都会发生变化，并且每个层都有自己的行为

1. FNN:扁平28*28
2. CNN: channel ，28,28:主要用于图像
3. RNN:每步输入28个，总共28个时间步。 :对于时间序列数据类型[视频、文本、音频]

FNN 的代码是:

import torch
import torch.nn as nn
from torch.autograd import Variable
import torchvision.datasets as dsets
import torchvision.transforms as transforms

train_dataset = dsets.MNIST(root="./data",
                            train=True,
                            transform=transforms.ToTensor(),
                            download=True
                            )

test_dataset = dsets.MNIST(root="./data",
                           train=False,
                           transform=transforms.ToTensor())


batch_size=100
n_iters = 3000
n_epochs = n_iters / (len(train_dataset)/batch_size)
n_epochs = int(n_epochs)

train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=batch_size,
                                               shuffle=True)

test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,
                                              batch_size=batch_size,
                                              shuffle=False)

class FeedforwardNNModelSIG(nn.Module):
  def __init__(self,input_dim,hidden_dim,output_dim):
      super().__init__()

      #Linear Layar
      self.fc1=nn.Linear(input_dim,hidden_dim)

      #Non Linear Layaer 
      self.sigmoid=nn.Sigmoid()

      #Linear Layar(readout layer)
      self.fc2=nn.Linear(hidden_dim,output_dim)

  def forward(self,x):
      # Linear
      out = self.fc1(x)
      # Non-Linear
      out = self.sigmoid(out)
      # Linear (readout layer)
      out = self.fc2(out)

      return out

input_dim=28*28
hidden_dim=50
output_dim=10
model = FeedforwardNNModelSIG(input_dim,hidden_dim,output_dim)

criterion = nn.CrossEntropyLoss()

learning_rate = 0.1
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)

iter=0
for epoch in range(n_epochs):
  for i,(images, labels) in enumerate(train_dataloader):

      ##1 Convert inputs/labels to Variable
      images = Variable(images.view(-1,28*28))
      labels = Variable(labels)

      ##2 Clear the gradients 
      optimizer.zero_grad()

      ##3 Get output given input
      outputs = model(images)

      ##4 Get Loss
      loss = criterion(outputs,labels)

      ##5 Get gradients wrt parameters
      loss.backward()

      ##6 Update paramters using Gradients
      optimizer.step()

      ##7 Repeat

      iter +=1
      if iter % 500 == 0 :
        correct = 0.
        total = 0.
      # Iter thorough test dataset
        for images,labels in test_dataloader:
          images = Variable(images.view(-1,28*28))
          labels = Variable(labels)

          outputs = model(images)
          # Get the max value of the prediction
          _,predicted=torch.max(outputs.data,1)
          # number of labels 
          total += labels.size(0)
          # Total correct predictions
          correct += (predicted==labels).sum()

        accuracy = 100*(correct/total)
        print("Iteration: {} , Loss:{} , Accuracy:{}".format(iter,loss.data,accuracy))

RNN 的代码是:

import torch
import torch.nn as nn
from torch.autograd import Variable
import torchvision.datasets as dsets
import torchvision.transforms as transforms

train_dataset = dsets.MNIST(root="./data",
                            train=True,
                            transform=transforms.ToTensor(),
                            download=True
                            )

test_dataset = dsets.MNIST(root="./data",
                           train=False,
                           transform=transforms.ToTensor())


batch_size=100
n_iters = 3000
n_epochs = n_iters / (len(train_dataset)/batch_size)
n_epochs = int(n_epochs)

train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=batch_size,
                                               shuffle=True)

test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,
                                              batch_size=batch_size,
                                              shuffle=False)

class RNNModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
        super(RNNModel, self).__init__()
        # Hidden dimensions
        self.hidden_dim = hidden_dim

        # Number of hidden layers
        self.layer_dim = layer_dim

        self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='tanh')

        # Readout layer
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # Initialize hidden state with zeros
        #######################
        #  USE GPU FOR MODEL  #
        #######################
        if torch.cuda.is_available():
            h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).cuda())
        else:
            h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim))

        # One time step
        out, hn = self.rnn(x, h0)

        out = self.fc(out[:, -1, :]) 
        # out.size() --> 100, 10
        return out

input_dim = 28
hidden_dim = 100
layer_dim = 1  # ONLY CHANGE IS HERE FROM ONE LAYER TO TWO LAYER
output_dim = 10

model = RNNModel(input_dim, hidden_dim, layer_dim, output_dim)

criterion = nn.CrossEntropyLoss()

if torch.cuda.is_available():
    model.cuda()

learning_rate = 0.1
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)

seq_dim = 28  

iter = 0
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # Load images as Variable
        #######################
        #  USE GPU FOR MODEL  #
        #######################
        if torch.cuda.is_available():
            images = Variable(images.view(-1, seq_dim, input_dim).cuda())
            labels = Variable(labels.cuda())
        else:
            images = Variable(images.view(-1, seq_dim, input_dim))
            labels = Variable(labels)

        # Clear gradients w.r.t. parameters
        optimizer.zero_grad()

        # Forward pass to get output/logits
        # outputs.size() --> 100, 10
        outputs = model(images)

        # Calculate Loss: softmax --> cross entropy loss
        loss = criterion(outputs, labels)

        # Getting gradients w.r.t. parameters
        loss.backward()

        # Updating parameters
        optimizer.step()

        iter += 1

        if iter % 500 == 0:
            # Calculate Accuracy         
            correct = 0
            total = 0
            # Iterate through test dataset
            for images, labels in test_loader:
                #######################
                #  USE GPU FOR MODEL  #
                #######################
                if torch.cuda.is_available():
                    images = Variable(images.view(-1, seq_dim, input_dim).cuda())
                else:
                    images = Variable(images.view(-1, seq_dim, input_dim))

                # Forward pass only to get logits/output
                outputs = model(images)

                # Get predictions from the maximum value
                _, predicted = torch.max(outputs.data, 1)

                # Total number of labels
                total += labels.size(0)

                # Total correct predictions
                #######################
                #  USE GPU FOR MODEL  #
                #######################
                if torch.cuda.is_available():
                    correct += (predicted.cpu() == labels.cpu()).sum()
                else:
                    correct += (predicted == labels).sum()

            accuracy = 100 * correct / total

            # Print Loss
            print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss, accuracy))