class AddLayer:
  def__init__(self):
    pass

  def forward(self, x, y):
    out = x + y 
    return out

  def backward(self, dout): 
    dx = dout * 1
    dy = dout * 1
    return dx, dy

class MulLayer:
    # 인스턴스 변수인 x와 y를 초기화
    # 두 변수는 순전파시의 입력 값을 유지하기 위해서 사용
    def__init__(self):
        self.x = None 
        self.y = None

    # x와 y를 인수로 받고 두 값을 곱해서 반환
    def forward(self, x, y):
        self.x = x 
        self.y = y 
        out = x * y

        return out

    #상류에서 넘어온 미분(dout)에 순전파 때의 값을 ‘서로 바꿔’ 곱한 후 하류로
    def backward(self, dout):
        dx = dout * self.y # x 와 y 를 바꾼다.
        dy = dout * self.x
    
        return dx, dy

apple = 100
apple_num = 2
tax = 1.1

# 계층들
mul_apple_layer = MulLayer() 
mul_tax_layer = MulLayer()

# 순전파
apple_price = mul_apple_layer.forward(apple, apple_num) 
price = mul_tax_layer.forward(apple_price, tax)

print(price) # 220

# 역전파
dprice = 1
## dapple_price로 dapple, dapple_num에 앞의 역전파 결과 전달
## dapple_price = 1.1
dapple_price, dtax = mul_tax_layer.backward(dprice) 
dapple, dapple_num = mul _apple _layer.backward(dapple _price)

print(dapple, dapple _num, dtax) # 2.2 110 200
   
# backward ( )가 받는 인수는 ‘순전파의 출력에 대한 미분’

apple = 100
apple _num = 2
orange = 150
orange _num = 3
tax = 1.1

# 계층들
mul_apple_layer = MulLayer() 
mul_orange_layer = MulLayer() 
add_apple_orange_layer = AddLayer() 
mul_tax_layer = MulLayer()

# 순전파
apple_price = mul_appl _layer.forward(apple, apple_num)  
orange_price = mul_orange_layer.forward(orange, orange_num) 
all_price = add_apple_orange_layer.forward(apple_price,orange_price) 
price = mul_tax_layer.forward(all_price, tax) 

# 역전파
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice) 
dapple_price, dorange_price = add_apple _orange_layer.backward(dall _price)
dorange, dorange _num = mul_orange_layer.backward(dorange_price) 
dapple, dapple_num = mul_apple_layer.backward(dapple_price) 

print(price) # 715
print(dapple_num, dapple, dorange, dorange_num, dtax) 
# 110 2.2 3.3 165 650

class Relu:
  # mask라는 인스턴스 변수를 가집니다
  # mask는 True/False로 구성된 넘파이 배열
  # 순전파의 입력인 x의 원소 값이 0 이하인 인덱스는 True,
  # 그 외(0보다 큰 원소)는 False로 유지
  def __init__(self):
    self.mask = None

  def forward(self, x): 
    # "순전파 때의 입력 값이 0 이하면" 순전파 시의 값은 0이 돼야 함.
    self.mask = (x < = 0) 
    # 0이상 이면 그냥 똑같은거 보냄
    out = x.copy() 
    # 순전파 때의 입력 값이 0 이하면 "순전파 시의 값은 0이 돼야 함".
    out[self.mask] = 0
    return out

  def backward(self, dout):
    # "순전파 때의 입력 값이 0 이하면" 역전파 때의 값은 0이 돼야 함.
    ## 역전파 때는 순전파 때 만들어둔 mask를 써서 mask의 원소가 True인 곳에는 
    ## 상류에서 전파된 dout을 0으로 설정
    dout[self.mask] = 0
    dx = dout
    return dx

class Sigmoid:
	def __init __(self):
		self.out = None

	def forward(self, x):
		out = 1 / (1 + np.exp(-x)) 
		# 순전파의 출력을 인스턴스 변수 out에 보관
		## 역전파 계산 때 그 값을 사용합니다
		self.out = out

		return out

	# self.out = y
	def backward(self, dout):
		dx = dout * (1.0 - self.out) * self.out

		return dx

class Affine:
	def __init __(self, W, b):
		self.W = W 
		self.b = b 
		self.x = None 
		self.dW = None 
		self.db = None

	def forward(self, x):
		self.x = x 
		out = np.dot(x, self.W) + self.b
		return out

	def backward(self, dout):
		dx = np.dot(dout, self.W.T) 
		self.dW = np.dot(self.x.T, dout) 
		#[3]구현 얘는 열로 더해버려
		self.db = np.sum(dout, axis = 0)
		return dx

class SoftmaxWithLoss: 
	def __init __(self):
		self.loss = None # 손실
		self.y = None # softmax 의 출력
		self.t = None # 정답 레이블(원-핫 벡터)

	def forward(self, x, t):
		self.t = t 
		self.y = softmax(x) 
		# 소프트 맥스의 출력과 정답레이블을 비교
		self.loss = cross_entropy_error(self.y, self.t) 

		return self.loss

	# 역전파 때는 전파하는 값을 배치의 수(batch_size) 로 나눠서 
	# 데이터 1개당 오차를 앞 계층으로 전파하는 점에 주의
	def backward(self, dout = 1):
		batch_size = self.t.shape[0] 
		dx = (self.y - self.t) / batch_size

		return dx

import sys, os 
sys.path.append(os.pardir) 
import numpy as np

from common.layers import * 
from common.gradient import numerical _gradient 
# 입력된 아이템들(items)의 순서를 기억하는 Dictionary 클래스 
from collections import OrderedDict

class TwoLayerNet:
	def __init __(self, input_size, hidden_size, output_size, weight_init_std = 0.01):

		# 가중치 초기화
		self.params = {} 
		self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size) self.params['b1'] = np.zeros(hidden_size) 
		self.params['W2'] = weight _init _std * np.random.randn(hidden_size,output_size) 
		self.params['b2'] = np.zeros(output _size)

		# 계층 생성
		self.layers = OrderedDict() 
		self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1']) self.layers['Relu1'] = Relu() 
	self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

		self.lastLayer = SoftmaxWithLoss()
		
	def predict(self, x):
		for layer in self.layers.values():
			x = layer.forward(x)

		return x

	# x : 입력 데이터 , t : 정답 레이블
	def loss(self, x, t):
		y = self.predict(x) 

		return self.lastLayer.forward(y, t)

	def accuracy(self, x, t):
		y = self.predict(x)
		y = np.argmax(y, axis = 1)
		if t.ndim ! = 1 : t = np.argmax(t, axis = 1)

		accuracy = np.sum(y == t) / float(x.shape[0])

		return accuracy

	# x : 입력 데이터 , t : 정답 레이블
	def numerical_gradient(self, x, t):
		loss_W = lambda W: self.loss(x, t)
		grads = {} 
		grads['W1'] = numerical_gradient(loss_W, self.params['W1']) 
		grads['b1'] = numerical_gradient(loss_W, self.params['b1']) 
		grads['W2'] = numerical_gradient(loss_W, self.params['W2']) 
		grads['b2'] = numerical _gradient(loss_W, self.params['b2']) 
		
		return grads

	def gradient(self, x, t):
		# 순전파
		self.loss(x, t)

		# 역전파
		dout = 1
		dout = self.lastLayer.backward(dout)

		layers = list(self.layers.values()) 
		layers.reverse() 
		for layer in layers:
			dout = layer.backward(dout)

		# 결과 저장
		grads = {}
		grads['W1'] = self.layers['Affine1'].dW 
		grads['b1'] = self.layers['Affine1'].db 
		grads['W2'] = self.layers['Affine2'].dW 
		grads['b2'] = self.layers['Affine2'].db

		return grads