in this chapter, we will focus on creating a convent from scratch. this infers in creating the respective convent or sample neural network with torch.

step 1

create a necessary class with respective parameters. the parameters include weights with random value.

class neural_network(nn.module):
   def __init__(self, ):
      super(neural_network, self).__init__()
      self.inputsize = 2
      self.outputsize = 1
      self.hiddensize = 3
      # weights
      self.w1 = torch.randn(self.inputsize, 
      self.hiddensize) # 3 x 2 tensor
      self.w2 = torch.randn(self.hiddensize, self.outputsize) # 3 x 1 tensor

step 2

create a feed forward pattern of function with sigmoid functions.

def forward(self, x):
   self.z = torch.matmul(x, self.w1) # 3 x 3 ".dot" 
   does not broadcast in pytorch
   self.z2 = self.sigmoid(self.z) # activation function
   self.z3 = torch.matmul(self.z2, self.w2)
   o = self.sigmoid(self.z3) # final activation 
   function
   return o
   def sigmoid(self, s):
      return 1 / (1 + torch.exp(-s))
   def sigmoidprime(self, s):
      # derivative of sigmoid
      return s * (1 - s)
   def backward(self, x, y, o):
      self.o_error = y - o # error in output
      self.o_delta = self.o_error * self.sigmoidprime(o) # derivative of sig to error
      self.z2_error = torch.matmul(self.o_delta, torch.t(self.w2))
      self.z2_delta = self.z2_error * self.sigmoidprime(self.z2)
      self.w1 + = torch.matmul(torch.t(x), self.z2_delta)
      self.w2 + = torch.matmul(torch.t(self.z2), self.o_delta)

step 3

create a training and prediction model as mentioned below −

def train(self, x, y):
   # forward + backward pass for training
   o = self.forward(x)
   self.backward(x, y, o)
def saveweights(self, model):
   # implement pytorch internal storage functions
   torch.save(model, "nn")
   # you can reload model with all the weights and so forth with:
   # torch.load("nn")
def predict(self):
   print ("predicted data based on trained weights: ")
   print ("input (scaled): \n" + str(xpredicted))
   print ("output: \n" + str(self.forward(xpredicted)))

Save or share this article