classification - Stochastic Gradient Descent (분류 - 확률적경사하강법)

import numpy as np

import matplotlib.pyplot as plt

from sklearn import datasets

# 아이리스 데이터셋 로드

iris_data = datasets.load_iris()

input_data = iris_data.data

correct = iris_data.target

n_data = len(correct)

# 입력 데이터 정규화

ave_input = np.average(input_data, axis=0)

std_input = np.std(input_data, axis=0)

input_data = (input_data - ave_input) / std_input

# 정답 데이터를 원-핫 인코딩으로 변환

correct_data = np.zeros((n_data, 3))

for i in range(n_data):

    correct_data[i, correct[i]] = 1.0

# 학습용, 테스트용 데이터 분할

index = np.arange(n_data)

index_train = index[index % 2 == 0]

index_test = index[index % 2 != 0]

input_train = input_data[index_train, :]

correct_train = correct_data[index_train, :]

input_test = input_data[index_test, :]

correct_test = correct_data[index_test, :]

n_train = input_train.shape[0]

n_test = input_test.shape[0]

# 네트워크 매개변수 설정

n_in = 4

n_mid = 25

n_out = 3

wb_width = 0.1

eta = 0.01  # 학습률

epoch = 1000

interval = 100

# 기본 레이어 클래스 정의

class BaseLayer:

    def __init__(self, n_upper, n):

        self.w = wb_width * np.random.randn(n_upper, n)

        self.b = wb_width * np.random.randn(n)

    def update(self, eta):

        self.w -= eta * self.grad_w

        self.b -= eta * self.grad_b

# 중간 레이어 클래스 정의

class MiddleLayer(BaseLayer):

    def forward(self, x):

        self.x = x

        self.u = np.dot(x, self.w) + self.b

        self.y = np.where(self.u <= 0, 0, self.u)

       

    def backward(self, grad_y):

        delta = grad_y * np.where(self.u <= 0, 0, 1)

        self.grad_w = np.dot(self.x.T, delta)

        self.grad_b = np.sum(delta, axis=0)

        self.grad_x = np.dot(delta, self.w.T)

# 출력 레이어 클래스 정의

class OutputLayer(BaseLayer):

    def forward(self, x):

        self.x = x

        u = np.dot(x, self.w) + self.b

        self.y = np.exp(u) / np.sum(np.exp(u), axis=1, keepdims=True)

   

    def backward(self, t):

        delta = self.y - t

        self.grad_w = np.dot(self.x.T, delta)

        self.grad_b = np.sum(delta, axis=0)

        self.grad_x = np.dot(delta, self.w.T)

# 레이어 생성

middle_layer_1 = MiddleLayer(n_in, n_mid)

middle_layer_2 = MiddleLayer(n_mid, n_mid)

output_layer = OutputLayer(n_mid, n_out)

# 순전파 함수 정의

def forward_propagation(x):

    middle_layer_1.forward(x)

    middle_layer_2.forward(middle_layer_1.y)

    output_layer.forward(middle_layer_2.y)

# 역전파 함수 정의

def backpropagation(t):

    output_layer.backward(t)

    middle_layer_2.backward(output_layer.grad_x)

    middle_layer_1.backward(middle_layer_2.grad_x)

# 오류 계산 함수 (교차 엔트로피)

def get_error(t, batch_size):

    return -np.sum(t * np.log(output_layer.y + 1e-7)) / batch_size

# 학습 루프

train_error_x = []

train_error_y = []

test_error_x = []

test_error_y = []

for i in range(epoch):

    # 학습 오류 계산

    forward_propagation(input_train)

    error_train = get_error(correct_train, n_train)

   

    # 테스트 오류 계산

    forward_propagation(input_test)

    error_test = get_error(correct_test, n_test)

   

    train_error_x.append(i)

    train_error_y.append(error_train)

    test_error_x.append(i)

    test_error_y.append(error_test)

   

    if i % interval == 0:

        print("에포크:", str(i) + "/" + str(epoch),

              "훈련 오류:", str(error_train),

              "테스트 오류:", str(error_test))

    # 학습 데이터 섞기

    index_random = np.arange(n_train)

    np.random.shuffle(index_random)

   

    # 확률적 경사 하강법

    for j in range(n_train):

        x = input_train[index_random[j], :].reshape(1, -1)

        t = correct_train[index_random[j], :].reshape(1, -1)

       

        forward_propagation(x)

        backpropagation(t)

        middle_layer_1.update(eta)

        middle_layer_2.update(eta)

        output_layer.update(eta)

# 오류 그래프 그리기

plt.plot(train_error_x, train_error_y, label="Train")

plt.plot(test_error_x, test_error_y, label="Test")

plt.legend()

plt.xlabel("에포크")

plt.ylabel("오류")

plt.show()

# 정확도 계산

forward_propagation(input_train)

count_train = np.sum(np.argmax(output_layer.y, axis=1) == np.argmax(correct_train, axis=1))

forward_propagation(input_test)

count_test = np.sum(np.argmax(output_layer.y, axis=1) == np.argmax(correct_test, axis=1))

print("훈련 정확도:", str(count_train / n_train * 100) + "%",

      "테스트 정확도:", str(count_test / n_test * 100) + "%")