16번째 수업(0508)

변형 과제 C E lll 을 테스트 케이스로 두고 결과 보이기

 

다층 퍼셉트론(학습부분)

# MLP
# 2 class : XOR
# 4 patterns / 1 class
# 2 Layer

import numpy as np
import math as m

def sigmoid(x) :
    return(1.0/(1+m.exp(-x)))

lrate = 0.05
INDIM   = 26
H1DIM    = 5
OUTDIM  = 3

PTTN_NUM    = 3

x  = np.array([[1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
                     0.1, 0.1, 1.0, 0.1, 0.1,
                     0.1, 0.1, 1.0, 0.1, 0.1,
                     0.1, 0.1, 1.0, 0.1, 0.1,
                     0.1, 0.1, 1.0, 0.1, 0.1],  #T
               [1.0, 0.1, 1.0, 1.0, 1.0, 1.0,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     0.1, 1.0, 1.0, 1.0, 1.0],  #C
               [1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 1.0, 1.0, 1.0, 1.0,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 1.0, 1.0, 1.0, 1.0,]  #E
                ])

t  = np.array([ [1.0, 0.0, 0.0],
                [0.0, 1.0, 0.0],
                [0.0, 0.0, 1.0]
                ])

x_t  = np.array([[1.0, 0.1, 1.0, 1.0, 1.0, 1.0,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 0.1, 0.1, 0.1, 1.0,
                     0.1, 1.0, 1.0, 1.0, 1.0],  #C
                 [1.0, 1.0, 1.0, 1.0, 1.0, 0.1,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 1.0, 1.0, 1.0, 1.0,
                     1.0, 0.1, 0.1, 0.1, 0.1,
                     1.0, 1.0, 1.0, 1.0, 0.1],  #E
                [1.0, 1.0, 0.1, 1.0, 0.1, 1.0,  #lll
                     1.0, 0.1, 1.0, 0.1, 1.0,
                     1.0, 0.1, 1.0, 0.1, 1.0,
                     1.0, 0.1, 1.0, 0.1, 1.0,
                     1.0, 0.1, 1.0, 0.1, 1.0]])



w1 = np.zeros([H1DIM, INDIM])
for i in range(H1DIM):
    for j in range(INDIM):
        w1[i][j] = np.random.rand() / 10.0

w2 = np.zeros([OUTDIM, H1DIM])
for i in range(OUTDIM):
    for j in range(H1DIM):
        w2[i][j] = np.random.rand() / 10.0

print(w1)
print(w2)

y1 = np.zeros(H1DIM)
y2 = np.zeros(OUTDIM)

d1 = np.zeros(H1DIM)
d2 = np.zeros(OUTDIM)

for epoch in range (100000):
    if (epoch % 1000) == 0:
        print("epoch", epoch)
    for p in range(PTTN_NUM):
        ###########################################
        # feed forwarding
        ###########################################
        # LAYER-1 (Hidden Layer)
        for i in range(H1DIM):
            out = 0.0
            for j in range(INDIM):
                out += w1[i][j] * x[p][j]
            y1[i] = sigmoid(out)
        # LAYER-2 (Output Layer)
        # y1[0] = 1.0  ### bias

        for i in range(OUTDIM):
          out = 0.0
          for j in range(H1DIM):
            out += w2[i][j] * y1[j]
          y2[i] = sigmoid(out)

        ###########################################
        # Back Propagation
        ###########################################
        # delta(error)  for Layer-2 (Output Layer)
        for i in range(OUTDIM):
          d2[i] = (t[p][i] - y2[i]) * (y2[i]*(1 - y2[i]))
        # delta(error)  for Layer-1 (Hidden Layer)
        for i in range(H1DIM):
          for j in range(OUTDIM) :
            d1[i] = d2[j] * w2[j][i] * (y1[i]*(1 - y1[i]))

        ###########################################
        # Weight Adjustment
        ###########################################
        # for Layer-2 (Output Layer)
        for i in range(OUTDIM):
          for j in range(H1DIM):
            w2[i][j] += lrate * d2[i] * y1[j]

        # for Layer-1 (Hidden Layer)
        for i in range(H1DIM):
            for j in range(INDIM):
                w1[i][j] += lrate * d1[i] * x[p][j]

        if (epoch % 1000) == 0:
            print("pattern number[%d] : " % p)
            print("target : ", "%7.2f" % t[p][0],  "%7.2f" % t[p][1], "%7.2f" % t[p][2])
            print("output : ", "%7.2f" % y2[0],  "%7.2f" % y2[1],  "%7.2f" % y2[2])

 

 

다층 퍼셉트론(출력부분)

for p in range(3):
  for i in range(H1DIM):
    out = 0.0
    for j in range(INDIM):
      out += w1[i][j] * x_t[p][j]
      y1[i] = sigmoid(out)
        # LAYER-2 (Output Layer)
        # y1[0] = 1.0  ### bias

  for i in range(OUTDIM):
    out = 0.0
    for j in range(H1DIM):
      out += w2[i][j] * y1[j]
      y2[i] = sigmoid(out)

  print("pattern number[%d] : " % p)
  print("output : ", "%7.2f" % y2[0],  "%7.2f" % y2[1],  "%7.2f" % y2[2])

 

 

 

---

 

epoch 로 10만번하게 하지 말고 cost가 0.1 또는 0.3 이하로 될 경우 exit 하게 해라

 

INDIM   = 4                    o  o  o (OUTDIM)
H1DIM    = 5                o o o o o  (H1DIM)
OUTDIM  = 3                 o o o o  (INDIM)

 

 

pss 는 패턴 에러, tss 는 토탈 에러를 뜻함

일반적으로 OUTDIM < H1DIM < INDIM , ex) 4 < 10 < 26

 

pytorch 에서 np.array 는 torch.tensor 로 대체
w = torch.randn(INDIM, OUTDIM, requires_grad = true) 에서  requires_grad = true는 무조건 쓸것

b = torch.randn(INDIM, requires_grad = true)