# Regresión de red neuronal recurrente RNN

De vuelta en la preocupación del horizonte

Las redes RNN rara vez se usan para tareas de regresión, pero eso no significa que no puedan usarse para tareas de regresión. Este artículo profundiza aún más la comprensión de RNN a través de RNN de la tarea de regresión simple

1. Preparar datos e hiperparámetros

``````import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()
``````

2. Construir una red neuronal RNN

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

self.rnn = nn.RNN(
input_size=INPUT_SIZE,
hidden_size=32,     # 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(32, 1)

def forward(self, x, h_state):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, hidden_size)
r_out, h_state = self.rnn(x, h_state)

outs = []    # save all predictions
for time_step in range(r_out.size(1)):    # calculate output for each time step
outs.append(self.out(r_out[:, time_step, :]))

# instead, for simplicity, you can replace above codes by follows
# r_out = r_out.view(-1, 32)
# outs = self.out(r_out)
# outs = outs.view(-1, TIME_STEP, 1)
# return outs, h_state

# or even simpler, since nn.Linear can accept inputs of any dimension
# and returns outputs with same dimension except for the last
# outs = self.out(r_out)
# return outs

rnn = RNN()
print(rnn)
``````

3. Elija la función de optimización y pérdida

``````optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()
``````

Nota:

1. adam (): a menudo usamos esta función porque tiene un mejor rendimiento en varias situaciones
2. MSELoss (): función de pérdida de error cuadrático medio, a menudo utilizada en modelos de predicción

4. Inicialice los datos y la imagen plt

``````h_state = None      # for initial hidden state

plt.figure(1, figsize=(12, 5))
plt.ion()           # continuously plot
``````

5. Capacitación y optimización

``````for step in range(100):
start, end = step * np.pi, (step+1)*np.pi   # time range
# use sin predicts cos
steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)
# float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)

x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])
# shape (batch, time_step, input_size)
y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

prediction, h_state = rnn(x, h_state)   # rnn output
# !! next step is important !!
h_state = h_state.data
# repack the hidden state, break the connection from last iteration

loss = loss_func(prediction, y)         # calculate loss
optimizer.zero_grad()                   # clear gradients for this training step
loss.backward()                         # backpropagation, compute gradients
optimizer.step()                        # apply gradients

# plotting
plt.plot(steps, y_np.flatten(), 'r-')
plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()``````

### Supongo que te gusta

Origin blog.csdn.net/ch206265/article/details/106994132