PyTorch - เครือข่ายประสาทที่เกิดซ้ำ

เครือข่ายประสาทที่เกิดซ้ำเป็นอัลกอริธึมที่เน้นการเรียนรู้เชิงลึกประเภทหนึ่งซึ่งเป็นไปตามแนวทางลำดับ ในโครงข่ายประสาทเทียมเรามักจะถือว่าอินพุตและเอาต์พุตแต่ละรายการเป็นอิสระจากเลเยอร์อื่น ๆ ทั้งหมด เครือข่ายประสาทเทียมประเภทนี้เรียกว่าการเกิดซ้ำเนื่องจากทำการคำนวณทางคณิตศาสตร์ในลักษณะตามลำดับจนเสร็จสิ้นภารกิจหนึ่ง

แผนภาพด้านล่างระบุแนวทางที่สมบูรณ์และการทำงานของเครือข่ายประสาทที่เกิดซ้ำ -

ในรูปด้านบน c1, c2, c3 และ x1 ถือเป็นอินพุตที่มีค่าอินพุตที่ซ่อนอยู่ ได้แก่ h1, h2 และ h3 ที่ให้เอาต์พุตตามลำดับของ o1 ตอนนี้เราจะมุ่งเน้นไปที่การใช้ PyTorch เพื่อสร้างคลื่นไซน์ด้วยความช่วยเหลือของเครือข่ายประสาทที่เกิดซ้ำ

ในระหว่างการฝึกอบรมเราจะปฏิบัติตามแนวทางการฝึกอบรมกับโมเดลของเราโดยใช้จุดข้อมูลทีละจุด ลำดับอินพุต x ประกอบด้วยจุดข้อมูล 20 จุดและลำดับเป้าหมายจะถือว่าเหมือนกับลำดับอินพุต

ขั้นตอนที่ 1

นำเข้าแพ็คเกจที่จำเป็นสำหรับการใช้งานเครือข่ายประสาทเทียมซ้ำโดยใช้รหัสด้านล่าง -

import torch
from torch.autograd import Variable
import numpy as np
import pylab as pl
import torch.nn.init as init

ขั้นตอนที่ 2

เราจะตั้งค่าพารามิเตอร์ไฮเปอร์โมเดลด้วยขนาดของเลเยอร์อินพุตที่กำหนดเป็น 7 จะมีเซลล์ประสาทบริบท 6 เซลล์และเซลล์ประสาทอินพุต 1 เซลล์สำหรับสร้างลำดับเป้าหมาย

dtype = torch.FloatTensor
input_size, hidden_size, output_size = 7, 6, 1
epochs = 300
seq_length = 20
lr = 0.1
data_time_steps = np.linspace(2, 10, seq_length + 1)
data = np.sin(data_time_steps)
data.resize((seq_length + 1, 1))

x = Variable(torch.Tensor(data[:-1]).type(dtype), requires_grad=False)
y = Variable(torch.Tensor(data[1:]).type(dtype), requires_grad=False)

เราจะสร้างข้อมูลการฝึกอบรมโดยที่ x คือลำดับข้อมูลอินพุตและ y คือลำดับเป้าหมายที่ต้องการ

ขั้นตอนที่ 3

น้ำหนักเริ่มต้นในโครงข่ายประสาทที่เกิดซ้ำโดยใช้การแจกแจงแบบปกติโดยมีค่าเฉลี่ยเป็นศูนย์ W1 จะแสดงถึงการยอมรับตัวแปรอินพุตและ w2 จะแสดงถึงเอาต์พุตที่สร้างขึ้นตามที่แสดงด้านล่าง -

w1 = torch.FloatTensor(input_size, 
hidden_size).type(dtype)
init.normal(w1, 0.0, 0.4)
w1 = Variable(w1, requires_grad = True)
w2 = torch.FloatTensor(hidden_size, output_size).type(dtype)
init.normal(w2, 0.0, 0.3)
w2 = Variable(w2, requires_grad = True)

ขั้นตอนที่ 4

ตอนนี้สิ่งสำคัญคือต้องสร้างฟังก์ชันสำหรับฟีดไปข้างหน้าซึ่งกำหนดโครงข่ายประสาทเทียมโดยเฉพาะ

def forward(input, context_state, w1, w2):
   xh = torch.cat((input, context_state), 1)
   context_state = torch.tanh(xh.mm(w1))
   out = context_state.mm(w2)
   return (out, context_state)

ขั้นตอนที่ 5

ขั้นตอนต่อไปคือการเริ่มขั้นตอนการฝึกอบรมการใช้คลื่นไซน์ของเครือข่ายประสาทที่เกิดซ้ำ วงนอกวนซ้ำในแต่ละลูปและวงในจะวนซ้ำผ่านองค์ประกอบของลำดับ ในที่นี้เราจะคำนวณ Mean Square Error (MSE) ซึ่งช่วยในการคาดคะเนตัวแปรต่อเนื่อง

for i in range(epochs):
   total_loss = 0
   context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = True)
   for j in range(x.size(0)):
      input = x[j:(j+1)]
      target = y[j:(j+1)]
      (pred, context_state) = forward(input, context_state, w1, w2)
      loss = (pred - target).pow(2).sum()/2
      total_loss += loss
      loss.backward()
      w1.data -= lr * w1.grad.data
      w2.data -= lr * w2.grad.data
      w1.grad.data.zero_()
      w2.grad.data.zero_()
      context_state = Variable(context_state.data)
   if i % 10 == 0:
      print("Epoch: {} loss {}".format(i, total_loss.data[0]))

context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = False)
predictions = []

for i in range(x.size(0)):
   input = x[i:i+1]
   (pred, context_state) = forward(input, context_state, w1, w2)
   context_state = context_state
   predictions.append(pred.data.numpy().ravel()[0])

ขั้นตอนที่ 6

ตอนนี้ได้เวลาพล็อตคลื่นไซน์ตามที่ต้องการ

pl.scatter(data_time_steps[:-1], x.data.numpy(), s = 90, label = "Actual")
pl.scatter(data_time_steps[1:], predictions, label = "Predicted")
pl.legend()
pl.show()

เอาต์พุต

ผลลัพธ์สำหรับกระบวนการข้างต้นมีดังนี้ -