Programming/(Python)(Ubuntu)
임의의 데이터에서 이진 분류 하기
$choice
2020. 6. 9. 19:53
필요한 모듈 : Numpy, OrderedDict, Matplotlib
추가 설명
OrderedDict 란?
OrderedDict 는 기본 딕셔너리(Dictionary)와 거의 비슷하지만, 입력된 아이템들(items)의 순서를 기억하는 Dictionary 클래스입니다. collections.OrderedDict의 자세한 내용은 docs.python.org 에서 확인할 수 있습니다.
간단하게 소개하자면 일반적인 dict 메소드를 지원하는 dict 서브 클래스의 인스턴트를 리턴합니다. OrderedDict 는 키가 먼저 삽입 된 순서를 기억 사전인가됩니다. 새로운 정렬된 사전은 항목이 삭제될 때 정렬 순서를 유지합니다. 그러나 새 키가 추가되면 키가 끝에 추가되고 정렬이 유지되지 않습니다. 키가 마지막으로 삽입된 순서를 기억하는 정렬된 사전 변형을 작성하는 것도 간단합니다. 새 항목이 기존의 학목을 덮어 쓰면 원래 삽입 위치가 변경되고 끝으로 이동합니다.
예입니다.
# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}
# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))
# Output Result
#OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
# dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))
# Output Result
# OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
# dictionary sorted by length of the key string
OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
# Output Result
#OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])0. 사전 준비 : 모듈 import
import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict
1. 데이터 생성
1-1. Train / Test / Label 데이터 생성 코드 ( dataprocess.py )
# 사용한 라이브러리
import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict
number_len = 50
mean_0 = (1, 1); mean_1 = (-1, -1)
cov = [[1, 0], [0, 1]]
class Data_create:
def __init__(self):
self.train_label = []
self.test_label = []
### 데이터 생성
def Train_data_create(self):
train_0 = np.random.multivariate_normal(mean_0, cov, number_len)
train_1 = np.random.multivariate_normal(mean_1, cov, number_len)
train_0_label = np.zeros((number_len, 1))
train_1_label = np.ones((number_len, 1))
train_data = np.concatenate((train_0, train_1), axis = 0)
self.train_label = np.concatenate((train_0_label, train_1_label), axis = 0)
print("label 0 data size :",train_0.shape)
print("label 1 data size :",train_1.shape)
print('all data size :', train_data.shape)
print('all label size :', self.train_label.shape)
plt.title("train")
plt.plot(train_0[:,0], train_0[:,1], 'r.', marker='x')
plt.plot(train_1[:,0], train_1[:,1], 'b.', marker='o')
plt.axis('equal')
#plt.show()
plt.pause(3)
plt.close()
# 데이터 확인
print("Train x, y location label 0\n", train_data[number_len*0:3])
print("Train x, y location label 1\n", train_data[number_len*1:number_len*1+3])
return train_data
def Test_data_create(self):
test_0 = np.random.multivariate_normal(mean_0, cov, number_len)
test_0_label = np.zeros((number_len, 1))
test_1 = np.random.multivariate_normal(mean_1, cov, number_len)
test_1_label = np.ones((number_len, 1))
test_data = np.concatenate((test_0, test_1), axis = 0)
self.test_label = np.concatenate((test_0_label, test_1_label), axis = 0)
print("label 0 data size :",test_0.shape)
print("label 1 data size :",test_1.shape)
print('all data size :',test_data.shape)
print('all label size :',self.test_label.shape)
plt.title("test")
plt.plot(test_0[:,0], test_0[:,1], 'r.', marker='x')
plt.plot(test_1[:,0], test_1[:,1], 'b.', marker='o')
plt.axis('equal')
#plt.show()
plt.pause(3)
plt.close()
# 데이터 확인
print("Test x, y location label 0\n", test_data[number_len*0:3])
print("Test x, y location label 1\n", test_data[number_len*1:number_len*1+3])
return test_data
### 라벨 생성
# 앞선 코드에서는 라벨을 0과 1로 분류해놓았고 분류해 놓은 라벨을 행렬로 만들어 줍니다.
# 행렬로 만들어주는 이유는 나중에 계산을 하기 편하게 하기 위해서입니다.
# 훈련 라벨 생성 기존 0 행렬을 생성했기 때문에 1만 추가
def Train_label_create(self):
Train_label = np.zeros((len(self.train_label),2))
for i in range(len(self.train_label)):
if self.train_label[i] == 0:
Train_label[i][0] = 1
if self.train_label[i] == 1:
Train_label[i][1] = 1
# 라벨 확인
print(Train_label.shape)
print("Train_label one-hot label 0\n", Train_label[number_len*0:3])
print("Train_label one-hot label 1\n", Train_label[number_len*1:number_len*1+3])
return Train_label
# 테스트 라벨 생성 기존 0 행렬을 생성했기 때문에 1만 추가
def Test_label_create(self):
Test_label = np.zeros((len(self.test_label),2))
for i in range(len(self.test_label)):
if self.test_label[i] == 0:
Test_label[i][0] = 1
if self.test_label[i] == 1:
Test_label[i][1] = 1
# 라벨 확인
print(Test_label.shape)
print("Test_label one-hot label 0\n", Test_label[number_len*0:3])
print("Test_label one-hot label 1\n", Test_label[number_len*1:number_len*1+3])
return Test_label
다음과 같이 라벨이 0일 때에는 0번째에 1로 표현, 라벨이 1일 때에는 1번째에 1로 표현해줍니다.
2. 모델 선언
2-1 필요한 함수 선언
1) Relu
ReLU의 식은 다음과 같습니다.
그리고 미분에 대한 식은 다음과 같습니다.
보기에는 1로 보이지만 이것은 그대로 넘겨준다는 의미를 가지고 있습니다.
아래는 코드입니다.
# Relu 함수 선언
class Relu:
def __init__(self):
self.mask = None
def forward(self, x):
self.mask = (x <= 0)
out = x.copy()
out[self.mask] = 0
return out
def backward(self, dout):
dout[self.mask] = 0
dx = dout
return dx
2) Mean Squared Error
# mean_squared_error_loss 함수 선언
class mean_squared_error_Loss:
def __init__(self):
self.loss = None # 손실함수
self.y = None # layer의 마지막 출력
self.t = None # 정답 레이블(원-핫 인코딩 형태)
def forward(self, x, t):
self.t = t
self.y = x
# loss = mean_squared_error
self.loss = 0.5 * np.sum((self.y-self.t)**2)
return self.loss
def backward(self, dout=1):
batch_size = self.t.shape[0]
if self.t.size == self.y.size: # 정답 레이블이 원-핫 인코딩 형태일 때
dx = (self.y - self.t) / batch_size
else:
dx = self.y.copy()
dx[np.arange(batch_size), self.t] -= 1
dx = dx / batch_size
return dx
2-2 Fully Connected layer 선언
class FC_Layer:
def __init__(self, W, b):
self.W = W
self.b = b
self.x = None
self.original_x_shape = None
# 가중치와 편향 매개변수의 미분
self.dW = None
self.db = None
def forward(self, x):
# 텐서 대응
self.original_x_shape = x.shape
x = x.reshape(x.shape[0], -1)
self.x = x
out = np.dot(self.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)
self.db = np.sum(dout, axis=0)
# input 데이터 모양 변경(텐서 대응)
dx = dx.reshape(*self.original_x_shape)
return dx
2-3 Network 선언
# FC_Layer가 3개인 클래스
class Three_FC_Layer:
def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.001):
# 가중치 선언 및 초기화
self.params = {}
self.params['W1'] = np.random.normal(0,weight_init_std,(input_size, hidden_size))
print('W1 shape :',self.params['W1'].shape)
self.params['b1'] = np.zeros(hidden_size)
print('b1 shape :',self.params['b1'].shape)
self.params['W2'] = np.random.normal(0,weight_init_std,(hidden_size, hidden_size))
print('W2 shape :',self.params['W2'].shape)
self.params['b2'] = np.zeros(hidden_size)
print('b2 shape :',self.params['b2'].shape)
self.params['W3'] = np.random.normal(0,weight_init_std,(hidden_size, output_size))
print('W3 shape :',self.params['W3'].shape)
self.params['b3'] = np.zeros(output_size)
print('b3 shape :',self.params['b3'].shape)
# layers 선언 {FC_Layer1, ReLU1, FC_Layer2, ReLU2, FC_Layer3}
self.layers = OrderedDict()
self.layers['FC_Layer1'] = \
FC_Layer(self.params['W1'], self.params['b1'])
self.layers['ReLU1'] = ReLU()
self.layers['FC_Layer2'] = \
FC_Layer(self.params['W2'], self.params['b2'])
self.layers['ReLU2'] = ReLU()
self.layers['FC_Layer3'] = \
FC_Layer(self.params['W3'], self.params['b3'])
# 마지막 Loss 계산
self.lastLayer = mean_squared_error_Loss()
# 순전파
def foreward_pass(self, x):
for layer in self.layers.values():
x = layer.forward(x)
return x
# x : 입력 데이터, t : 정답 레이블
def loss(self, x, t):
y = self.foreward_pass(x)
return self.lastLayer.forward(y,t)
def accuracy(self, x, t):
y = self.foreward_pass(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
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)
# W, b 결과 저장
grads={}
grads['W1'] = self.layers['FC_Layer1'].dW
grads['b1'] = self.layers['FC_Layer1'].db
grads['W2'] = self.layers['FC_Layer2'].dW
grads['b2'] = self.layers['FC_Layer2'].db
grads['W3'] = self.layers['FC_Layer3'].dW
grads['b3'] = self.layers['FC_Layer3'].db
return grads
전체적인 코드는 다음과 같습니다. ( model.py )
import numpy as np
from collections import OrderedDict
class ReLU:
def __init__(self):
self.mask = None
def forward(self, x):
self.mask = (x <= 0)
out = x.copy()
out[self.mask] = 0
return out
def backward(self, dout):
dout[self.mask] = 0
dx = dout
return dx
class FC_Layer:
def __init__(self, W, b):
self.W = W
self.b = b
self.x = None
self.original_x_shape = None
# 가중치와 편향 매개변수의 미분
self.dW = None
self.db = None
def forward(self, x):
# 텐서 대응
self.original_x_shape = x.shape
x = x.reshape(x.shape[0], -1)
self.x = x
out = np.dot(self.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)
self.db = np.sum(dout, axis=0)
# input 데이터 모양 변경(텐서 대응)
dx = dx.reshape(*self.original_x_shape)
return dx
class mean_squared_error_Loss:
def __init__(self):
self.loss = None # 손실함수
self.y = None # last_layer 전의 출력
self.t = None # 정답 레이블(원-핫 인코딩 형태)
def forward(self, x, t):
self.t = t
self.y = x
# loss = mean_squared_error
self.loss = ((self.y-self.t)**2).mean(axis=None)
return self.loss
def backward(self, dout=1):
batch_size = self.t.shape[0]
# 정답 레이블이 원-핫 인코딩 형태일 때
dx = (self.y - self.t) / batch_size
return dx
# FC_Layer가 3개인 클래스
class Three_FC_Layer:
def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.001):
# 가중치 선언 및 초기화
self.params = {}
self.params['W1'] = np.random.normal(0,weight_init_std,(input_size, hidden_size))
print('W1 shape :',self.params['W1'].shape)
self.params['b1'] = np.zeros(hidden_size)
print('b1 shape :',self.params['b1'].shape)
self.params['W2'] = np.random.normal(0,weight_init_std,(hidden_size, hidden_size))
print('W2 shape :',self.params['W2'].shape)
self.params['b2'] = np.zeros(hidden_size)
print('b2 shape :',self.params['b2'].shape)
self.params['W3'] = np.random.normal(0,weight_init_std,(hidden_size, output_size))
print('W3 shape :',self.params['W3'].shape)
self.params['b3'] = np.zeros(output_size)
print('b3 shape :',self.params['b3'].shape)
# layers 선언 {FC_Layer1, ReLU1, FC_Layer2, ReLU2, FC_Layer3}
self.layers = OrderedDict()
self.layers['FC_Layer1'] = \
FC_Layer(self.params['W1'], self.params['b1'])
self.layers['ReLU1'] = ReLU()
self.layers['FC_Layer2'] = \
FC_Layer(self.params['W2'], self.params['b2'])
self.layers['ReLU2'] = ReLU()
self.layers['FC_Layer3'] = \
FC_Layer(self.params['W3'], self.params['b3'])
# 마지막 Loss 계산
self.lastLayer = mean_squared_error_Loss()
# 순전파
def foreward_pass(self, x):
for layer in self.layers.values():
x = layer.forward(x)
return x
# x : 입력 데이터, t : 정답 레이블
def loss(self, x, t):
y = self.foreward_pass(x)
return self.lastLayer.forward(y,t)
def accuracy(self, x, t):
y = self.foreward_pass(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
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)
# W, b 결과 저장
grads={}
grads['W1'] = self.layers['FC_Layer1'].dW
grads['b1'] = self.layers['FC_Layer1'].db
grads['W2'] = self.layers['FC_Layer2'].dW
grads['b2'] = self.layers['FC_Layer2'].db
grads['W3'] = self.layers['FC_Layer3'].dW
grads['b3'] = self.layers['FC_Layer3'].db
return grads
2-4 학습 진행 코드입니다. (main.py)
from dataprocess import Data_create
from model import ReLU, FC_Layer, mean_squared_error_Loss, Three_FC_Layer
import numpy as np
import matplotlib.pyplot as plt
data_process = Data_create()
Train_data = data_process.Train_data_create()
Test_data = data_process.Test_data_create()
Train_label = data_process.Train_label_create()
Test_label = data_process.Test_label_create()
model = Three_FC_Layer(input_size = 2, hidden_size = 10, output_size = 2)
print('------------- W, b 초기화 -------------')
for key in ('W1', 'b1', 'W2', 'b2', 'W3', 'b3'):
print('{}'.format(key), model.params[key])
print('----------- 역전파 학습 전 Forward pass Accuracy -----------')
test_acc = model.accuracy(Test_data, Test_label)
print("Accuracy :", test_acc*100,"%")
# 학습 및 오차역전파법을 이용한 업데이트
iters_num = 500000
train_size = Train_data.shape[0]
batch_size = 2
learning_rate = 0.005
train_loss_list = []
train_acc_list = []
test_acc_list = []
for i in range(iters_num):
batch_mask = np.random.choice(train_size, batch_size)
x_batch = Train_data[batch_mask]
t_batch = Train_label[batch_mask]
# 오차역전파 기울기
grad = model.gradient(x_batch, t_batch)
# W, b 갱신
for key in ('W1', 'b1', 'W2', 'b2', 'W3', 'b3'):
model.params[key] -= learning_rate * grad[key]
loss = model.loss(x_batch, t_batch)
train_loss_list.append(loss)
# 5000 에폭마다 결과 확인
if i % 5000 == 0:
print('================================================')
print("iters_num :", i)
print("loss :", loss)
train_acc = model.accuracy(Train_data, Train_label)
test_acc = model.accuracy(Test_data, Test_label)
train_acc_list.append(train_acc)
test_acc_list.append(test_acc)
print('train acc : {:.3f} | test acc : {:.3f}'.format(train_acc, test_acc))
# 학습 후 W, b
print('------------- 업데이트 후 W, b -------------')
for key in ('W1', 'b1', 'W2', 'b2', 'W3', 'b3'):
print('{}'.format(key), model.params[key])
# 학습 후 정확도
print('----------- 역전파 학습 후 Forward pass Accuracy -----------')
test_acc = model.accuracy(Test_data, Test_label)
print("Accuracy :", test_acc*100,"%")
# 훈련 정확도 그래프
plt.title("Train Acc list")
plt.plot(train_acc_list)
#plt.show()
plt.pause(3)
plt.close()
# 테스트 정확도 그래프
plt.title("Test Acc list")
plt.plot(test_acc_list)
#plt.show()
plt.pause(3)
plt.close()
main.py를 실행하면 다음과 같이 결과가 출력됩니다.
학습 파라미터 사이즈
학습 파라미터
학습 전 정확도 측정
학습 진행
(중략)
학습 후 파라미터
학습 후 정확도 측정
반응형