일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 |
Tags
- file descriptors
- 3분 딥러닝
- 디바이스 드라이버
- Transport layer
- Network layer
- 펌웨어
- 신경망 첫걸음
- Linux
- Generalized forward
- 밑바닥부터 시작하는 딥러닝
- function call
- 스위치
- Router
- 모두를 위한 딥러닝]
- TensorFlow
- LED 제어
- 텐서플로우
- RDT
- 인터럽트
- Switch
- demultiplexing
- Interrupt
- 운영체제
- 모두를 위한 딥러닝
- LED
- GPIO
- Class Activation Map
- 딥러닝
- 신경망
- 리눅스
Archives
- Today
- Total
건조젤리의 저장소
[신경망 첫걸음] 정리 본문
Python 으로 신경망을 구축해 봅시다.
전체 3계층 신경망
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | class neuralNetwork: def __init__(self,inputnodes, hiddennodes, outputnodes, learningrate): # 입력, 은닉, 출력 계층의 노드 개수 설정 self.inodes = inputnodes self.hnodes = hiddennodes self.onodes = outputnodes self.wih = numpy.random.normal(0.0 , pow(self.hnodes,-0.5), (self.hnodes, self.inodes)) self.who = numpy.random.normal(0.0 , pow(self.onodes,-0.5), (self.onodes, self.hnodes)) # 학습률 self.lr = learningrate # 활성화 함수로 시그모이드 함수를 이용 self.activation_function = lambda x: scipy.special.expit(x) pass # 신경망 학습시키기 def train(self, inputs_list, targets_list): # 입력 리스트를 2차원의 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T targets = numpy.array(targets_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self,wih, inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) # 오차는 (실제 값 = 계산 값) output_errors = targets - final_outputs # 은닉 계층의 오차는 가중치에 의해 나뉜 출력 계층의 오차들을 재조합해 계산 hidden_errors = numpy.dot(self.who.T, output_errors) # 은닉 계층과 출력 계층 간의 가중치 업데이트 self.who += slef.lr*numpy.dot((ouput_errors*final_outputs*(1.0-final_outputs)), numpy.transpose(hidden_outputs)) # 입력 계층과 은닉 계층 간의 가중치 업데이트 self.wih += slef.lr*numpy.dot((hidden_errors*hidden_outputs*(1.0-hidden_outputs)), numpy.transpose(inputs)) pass # 신경망에 질의하기 def query(self, inputs_list): # 입력 리스트를 2차원 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self.wih,inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) return final_outputs | cs |
MNIST 데이터 학습 및 결과 확인
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | # 3계층의 신경망으로 MNIST 데이터를 학습하는 코드 import numpy # 시그모이드 함수 expit() 사용을 위해 scipy.special 불러오기 import scipy.special # 행렬을 시각화하기 위한 라이브러리 import matplotlib.pyplot # 시각화가 외부 윈도우가 아닌 현재의 노트북 내에서 보이도록 설정 #get_ipython().magic('matplotlib inline') #신경망 클래스의 정의 class neuralNetwork: # 신경망 초기화하기 def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate): # 입력, 은닉, 출력 계층의 노드 개수 설정 self.inodes = inputnodes self.hnodes = hiddennodes self.onodes = outputnodes # 가중치 행렬 wih와 who # 배열 내 가중치는 w_i_j로 표기. 노드 i에서 다음 계층의 노드 j로 연결됨을 의미 # w11 w21 # w12 w22 등 self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes)) self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes)) # 학습률 self.lr = learningrate # 활성화 함수로는 시그모이드 함수를 이용 self.activation_function = lambda x: scipy.special.expit(x) pass # 신경망 학습시키기 def train(self, inputs_list, targets_list): # 입력 리스트를 2차원의 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T targets = numpy.array(targets_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self.wih, inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) # 출력 계층의 오차는 (실제 값 - 계산 값) output_errors = targets - final_outputs # 은닉 계층의 오차는 가중치에의해 나뉜 출력 계층의 오차들을 재조합해 계산 hidden_errors = numpy.dot(self.who.T, output_errors) # 은닉 계층과 출력 계층 간의 가중치 업데이트 self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs)) # 입력 계층과 은닉 계층 간의 가중치 업데이트 self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs)) pass # 신경망에 질의하기 def query(self, inputs_list): # 입력 리스트를 2차원 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self.wih, inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) return final_outputs # 입력, 은닉, 출력 노드의 수 input_nodes = 784 hidden_nodes = 200 output_nodes = 10 # 학습률 learning_rate = 0.2 # 신경망의 인스턴스를 생성 n = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate) # mnist 학습 데이터인 csv 파일을 리스트로 불러오기 training_data_file = open("mnist_dataset/mnist_train.csv", 'r') training_data_list = training_data_file.readlines() training_data_file.close() # 신경망 학습시키기 # 주기(epoch)란 학습 데이터가 학습을 위해 사용되는 횟수를 의미 epochs = 5 for e in range(epochs): # 학습 데이터 모음 내의 모든 레코드 탐색 for record in training_data_list: # 레코드를 쉼표에 의해 분리 all_values = record.split(',') # 입력 값의 범위와 값 조정 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # 결과 값 생성 (실제 값인 0.99 외에는 모두 0.01) targets = numpy.zeros(output_nodes) + 0.01 # all_values[0]은 이 레코드에 대한 결과 값 targets[int(all_values[0])] = 0.99 n.train(inputs, targets) pass pass # mnist 테스트 데이터인 csv 파일을 리스트로 불러오기 test_data_file = open("mnist_dataset/mnist_test.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close() # 신경망 테스트하기 # 신경망의 성능의 지표가되는 성적표를 아무 값도 가지지 않도록 초기화 scorecard = [] # 테스트 데이터 모음 내의 모든 레코드 탐색 for record in test_data_list: # 레코드를 쉼표에 의해 분리 all_values = record.split(',') # 정답은 첫 번째 값 correct_label = int(all_values[0]) # 입력 값의 범위와 값 조정 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # 신경망에 질의 outputs = n.query(inputs) # 가장 높은 값의 인덱스는 레이블의 인덱스와 일치 label = numpy.argmax(outputs) # 정답 또는 오답을 리스트에 추가 if (label == correct_label): # 정답인 경우 성적표에 1을 더함 scorecard.append(1) else: # 정답이 아닌 경우 성적표에 0을 더함 scorecard.append(0) pass pass # 정답의 비율인 성적을 계산해 출력 scorecard_array = numpy.asarray(scorecard) print ("performance = ", scorecard_array.sum() / scorecard_array.size) | cs |
출력
performance = 0.9665
나만의 손글씨 데이터로 테스트 해보기
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | import glob import imageio for image_file_name in glob.glob('dataset/test_?_?.png'): order = int(image_file_name[-7]) label = int(image_file_name[-5]) print("Loading ...", image_file_name) img_array = imageio.imread(image_file_name, as_gray=True) img_data = 255.0 - img_array.reshape(784) img_data = (img_data / 255.0 * 0.99) + 0.01 image_array = numpy.asfarray(img_data).reshape((28,28)) matplotlib.pyplot.subplot(1,9,order+1) matplotlib.pyplot.imshow(image_array, cmap='Greys', interpolation = 'None') correct_label = int(label) print(correct_label,"correct label") inputs = (img_data) outputs = n.query(inputs) print(numpy.argmax(outputs),"network's answer") pass | cs |
출력
Loading ... dataset/test_5_1.png 1 correct label 3 network's answer Loading ... dataset/test_2_1.png 1 correct label 3 network's answer Loading ... dataset/test_7_4.png 4 correct label 4 network's answer
...
(생략)
...
(그림 출력 생략)
Mnist 데이터와 달리 글씨의 굵기가 얇기 때문에 인식률이 떨어진다.
역질의 , 회전을 통해 새로운 학습 데이터 만들기 추가
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 | # 역 질 의 # 3계층의 신경망으로 MNIST 데이터를 학습하는 코드 import numpy # 시그모이드 함수 expit() 사용을 위해 scipy.special 불러오기 import scipy.special import scipy.ndimage # 행렬을 시각화하기 위한 라이브러리 import matplotlib.pyplot # 시각화가 외부 윈도우가 아닌 현재의 노트북 내에서 보이도록 설정 #get_ipython().magic('matplotlib inline') #신경망 클래스의 정의 class neuralNetwork: # 신경망 초기화하기 def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate): # 입력, 은닉, 출력 계층의 노드 개수 설정 self.inodes = inputnodes self.hnodes = hiddennodes self.onodes = outputnodes # 가중치 행렬 wih와 who # 배열 내 가중치는 w_i_j로 표기. 노드 i에서 다음 계층의 노드 j로 연결됨을 의미 # w11 w21 # w12 w22 등 self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes)) self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes)) # 학습률 self.lr = learningrate # 활성화 함수로는 시그모이드 함수를 이용 self.activation_function = lambda x: scipy.special.expit(x) self.inverse_activation_function = lambda x: scipy.special.logit(x) pass # 신경망 학습시키기 def train(self, inputs_list, targets_list): # 입력 리스트를 2차원의 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T targets = numpy.array(targets_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self.wih, inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) # 출력 계층의 오차는 (실제 값 - 계산 값) output_errors = targets - final_outputs # 은닉 계층의 오차는 가중치에의해 나뉜 출력 계층의 오차들을 재조합해 계산 hidden_errors = numpy.dot(self.who.T, output_errors) # 은닉 계층과 출력 계층 간의 가중치 업데이트 self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs)) # 입력 계층과 은닉 계층 간의 가중치 업데이트 self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs)) pass # 신경망에 질의하기 def query(self, inputs_list): # 입력 리스트를 2차원 행렬로 변환 inputs = numpy.array(inputs_list, ndmin=2).T # 은닉 계층으로 들어오는 신호를 계산 hidden_inputs = numpy.dot(self.wih, inputs) # 은닉 계층에서 나가는 신호를 계산 hidden_outputs = self.activation_function(hidden_inputs) # 최종 출력 계층으로 들어오는 신호를 계산 final_inputs = numpy.dot(self.who, hidden_outputs) # 최종 출력 계층에서 나가는 신호를 계산 final_outputs = self.activation_function(final_inputs) return final_outputs #역질의 def backquery(self, targets_list): final_outputs = numpy.array(targets_list, ndmin=2).T final_inputs = self.inverse_activation_function(final_outputs) hidden_outputs = numpy.dot(self.who.T, final_inputs) # scale from 0.01 to .99 hidden_outputs -= numpy.min(hidden_outputs) hidden_outputs /= numpy.max(hidden_outputs) hidden_outputs *= 0.98 hidden_outputs += 0.01 hidden_inputs = self.inverse_activation_function(hidden_outputs) inputs = numpy.dot(self.wih.T, hidden_inputs) # scale from 0.01 to .99 inputs -= numpy.min(inputs) inputs /= numpy.max(inputs) inputs *= 0.98 inputs += 0.01 return inputs # 입력, 은닉, 출력 노드의 수 input_nodes = 784 hidden_nodes = 200 output_nodes = 10 # 학습률 learning_rate = 0.2 # 신경망의 인스턴스를 생성 n = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate) # mnist 학습 데이터인 csv 파일을 리스트로 불러오기 training_data_file = open("mnist_dataset/mnist_train.csv", 'r') training_data_list = training_data_file.readlines() training_data_file.close() # 신경망 학습시키기 # 주기(epoch)란 학습 데이터가 학습을 위해 사용되는 횟수를 의미 epochs = 5 for e in range(epochs): # 학습 데이터 모음 내의 모든 레코드 탐색 for record in training_data_list: # 레코드를 쉼표에 의해 분리 all_values = record.split(',') # 입력 값의 범위와 값 조정 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # 결과 값 생성 (실제 값인 0.99 외에는 모두 0.01) targets = numpy.zeros(output_nodes) + 0.01 # all_values[0]은 이 레코드에 대한 결과 값 targets[int(all_values[0])] = 0.99 n.train(inputs, targets) inputs_plus10_img = scipy.ndimage.interpolation.rotate(inputs.reshape(28,28),10,cval=0.01,order=1,reshape=False) inputs_minus10_img = scipy.ndimage.interpolation.rotate(inputs.reshape(28,28),-10,cval=0.01,order=1,reshape=False) n.train(inputs_plus10_img.reshape(784),targets) n.train(inputs_minus10_img.reshape(784),targets) pass pass # mnist 테스트 데이터인 csv 파일을 리스트로 불러오기 test_data_file = open("mnist_dataset/mnist_test.csv", 'r') test_data_list = test_data_file.readlines() test_data_file.close() # 신경망 테스트하기 # 신경망의 성능의 지표가되는 성적표를 아무 값도 가지지 않도록 초기화 scorecard = [] # 테스트 데이터 모음 내의 모든 레코드 탐색 for record in test_data_list: # 레코드를 쉼표에 의해 분리 all_values = record.split(',') # 정답은 첫 번째 값 correct_label = int(all_values[0]) # 입력 값의 범위와 값 조정 inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # 신경망에 질의 outputs = n.query(inputs) # 가장 높은 값의 인덱스는 레이블의 인덱스와 일치 label = numpy.argmax(outputs) # 정답 또는 오답을 리스트에 추가 if (label == correct_label): # 정답인 경우 성적표에 1을 더함 scorecard.append(1) else: # 정답이 아닌 경우 성적표에 0을 더함 scorecard.append(0) pass pass # 정답의 비율인 성적을 계산해 출력 scorecard_array = numpy.asarray(scorecard) print ("performance = ", scorecard_array.sum() / scorecard_array.size) | cs |
출력
performance = 0.957
정확도가 약간 감소했다?!
새로운 학습 데이터가 영향을 미쳤던 것일까?
역질의 테스트
1 2 3 4 5 6 7 8 9 10 11 12 | for label in range(10): print("label",label) targets = numpy.zeros(output_nodes)+0.01 targets[label] = 0.99 print(targets) image_data = n.backquery(targets) image_array = numpy.asfarray(image_data).reshape((28,28)) matplotlib.pyplot.imshow(image_array, cmap='Greys', interpolation = 'None') matplotlib.pyplot.show() | cs |
출력
3인 경우와 5인 경우
어느정도 형상을 관찰할 수 있다.
'공부 기록 > 인공지능' 카테고리의 다른 글
케라스로 구현하는 RNN (0) | 2019.06.25 |
---|---|
[골빈해커의 3분 딥러닝 텐서플로맛] 정리 (2) | 2019.02.27 |
[골빈해커의 3분 딥러닝 텐서플로맛] 리뷰 (0) | 2019.02.27 |
[밑바닥부터 시작하는 딥러닝] 리뷰 및 정리 (0) | 2019.02.27 |
[신경망 첫걸음] 리뷰 (0) | 2019.02.27 |
Comments