S40L12 – 간단한 숫자 분류기

Translation:
html
케라스와 MNIST를 사용한 숫자 분류를 위한 간단한 신경망 구축

목차

    숫자 분류를 위한 신경망 소개
    MNIST 데이터셋 이해하기
    환경 설정
    MNIST 데이터셋 로드 및 탐색
    데이터 전처리: 형태 변환 및 원-핫 인코딩
    케라스를 사용한 신경망 모델 구축
        
            모델 아키텍처
            레이어 설명
        
    
    모델 컴파일: 손실 함수 및 최적화기
    모델 훈련: 학습 및 검증
    모델 평가: 정확도 및 예측
    신경망 구조 시각화
    훈련 최적화: GPU 활용
    결론




숫자 분류를 위한 신경망 소개 
신경망은 기계가 데이터를 해석하고 분석하는 방식을 혁신적으로 변화시켰으며, 특히 이미지 인식 분야에서 큰 발전을 이루었습니다. 손으로 쓴 숫자를 정확하게 식별하는 것이 목표인 숫자 분류는 초보자가 신경망의 기본 개념을 이해하기 위한 전형적인 예시입니다. Keras와 같은 인기 있는 라이브러리와 MNIST와 같은 데이터셋을 활용함으로써 효과적인 숫자 분류기를 구축하는 것이 쉽고 교육적인 과정이 됩니다.

MNIST 데이터셋 이해하기 
MNIST (Modified National Institute of Standards and Technology) 데이터셋은 머신러닝 커뮤니티에서 중요한 기반을 형성하고 있습니다. 이 데이터셋은 70,000개의 손으로 쓴 숫자(0-9)의 그레이스케일 이미지로 구성되어 있으며, 각 이미지는 28x28 픽셀 크기입니다. 전체 데이터는 60,000개의 학습용 이미지와 10,000개의 테스트용 이미지로 나뉘어져 있어 머신러닝 모델을 학습하고 검증하는 데 이상적입니다.

MNIST의 주요 특징:

    크기: 70,000개 이미지 (60k 학습용, 10k 테스트용)
    이미지 크기: 28x28 픽셀
    클래스: 10개 (숫자 0부터 9까지)
    그레이스케일: 각 픽셀 값은 0(검정)에서 255(흰색)까지 범위


환경 설정 
모델 구축 과정에 뛰어들기 전에 개발 환경을 설정하는 것이 중요합니다. Python이 설치되어 있는지 확인하고, 패키지 및 종속성을 원활하게 관리하기 위해 Anaconda와 같은 환경을 사용하는 것을 고려하세요.

필수 라이브러리:

    NumPy: 수치 연산을 위해
    Matplotlib: 데이터 시각화를 위해
    Keras: 신경망 구축 및 훈련을 위해
    Scikit-learn: 전처리 유틸리티를 위해
    Pandas: 데이터 조작을 위해


설치 명령어:




		
		
			
			
Java
			
			pip install numpy matplotlib keras scikit-learn pandas
			
				
					
				
					1
				
						pip install numpy matplotlib keras scikit-learn pandas
					
				
			
		



MNIST 데이터셋 로드 및 탐색 
Keras의 datasets 모듈을 통해 MNIST 데이터셋에 액세스하는 과정을 간소화할 수 있습니다. 데이터 로드 및 검사를 위한 방법은 다음과 같습니다:





		
		
			
			
Java
			
			import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist

# Load MNIST handwritten digit data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(X_train.shape)  # Output: (60000, 28, 28)
print(X_test.shape)   # Output: (10000, 28, 28)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
 
# Load MNIST handwritten digit data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
 
print(X_train.shape)  # Output: (60000, 28, 28)
print(X_test.shape)   # Output: (10000, 28, 28)
					
				
			
		



출력:




		
		
			
			
Java
			
			(60000, 28, 28)
(10000, 28, 28)
			
				
					
				
					1
2
				
						(60000, 28, 28)
(10000, 28, 28)
					
				
			
		



이는 학습용 이미지가 60,000개이고 테스트용 이미지가 10,000개임을 나타내며, 각 이미지의 크기는 28x28 픽셀입니다.

샘플 이미지 시각화
데이터를 이해하기 위해 샘플 이미지를 시각화해 봅시다:





		
		
			
			
Java
			
			img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
			
				
					
				
					1
2
3
4
				
						img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
					
				
			
		



출력:


참고: 실제 이미지는 레이블에 해당하는 손으로 쓴 숫자를 표시합니다.

데이터 전처리: 형태 변환 및 원-핫 인코딩 
데이터 전처리는 머신러닝 워크플로우에서 중요한 단계입니다. 신경망의 경우, 데이터를 적절하게 형식화하고 레이블을 인코딩하는 것이 필수적입니다.

데이터 형태 변환
신경망은 특정 형태의 입력 데이터를 필요로 합니다. MNIST 데이터셋의 경우, 28x28 픽셀 이미지를 784개의 요소로 이루어진 1차원 배열로 평탄화할 것입니다.





		
		
			
			
Java
			
			from keras.utils import to_categorical

# Reshape and normalize the image data
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
			
				
					
				
					1
2
3
4
5
				
						from keras.utils import to_categorical
 
# Reshape and normalize the image data
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
					
				
			
		



레이블의 원-핫 인코딩
원-핫 인코딩은 범주형 레이블을 이진 행렬로 변환하여 훈련에 더 적합하게 만듭니다.





		
		
			
			
Java
			
			# One-hot encode the labels
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)

print(y_train.shape)  # Output: (60000, 10)
print(y_test.shape)   # Output: (10000, 10)
			
				
					
				
					1
2
3
4
5
6
				
						# One-hot encode the labels
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
 
print(y_train.shape)  # Output: (60000, 10)
print(y_test.shape)   # Output: (10000, 10)
					
				
			
		



출력:




		
		
			
			
Java
			
			(60000, 10)
(10000, 10)
			
				
					
				
					1
2
				
						(60000, 10)
(10000, 10)
					
				
			
		



이는 각 레이블이 이제 10차원의 이진 벡터로 표현됨을 나타냅니다.

케라스를 사용한 신경망 모델 구축 
Keras는 신경망을 구축하고 훈련시키기 위한 사용자 친화적인 API를 제공합니다. 여러 개의 Dense 레이어로 구성된 간단한 Sequential 모델을 구축할 것입니다.

모델 아키텍처 
모델 구조에 대한 고수준 개요는 다음과 같습니다:

    Flatten 레이어: 2D 이미지 데이터를 1D 배열로 변환합니다.
    Dense 레이어 1: 시그모이드 활성화 함수가 적용된 100개의 뉴런.
    Dense 레이어 2: 시그모이드 활성화 함수가 적용된 144개의 뉴런.
    출력 레이어: 10개의 뉴런(각 숫자마다 하나씩)과 소프트맥스 활성화 함수.


레이어 설명 

    Flatten 레이어: 입력 데이터를 2D 행렬(28x28)에서 1D 벡터(784)로 변환하여 Dense 레이어에 공급합니다.
    Dense 레이어: 각 뉴런이 이전 레이어의 모든 뉴런으로부터 입력을 받는 완전 연결 레이어입니다. 활성화 함수는 비선형성을 도입합니다:
        
            시그모이드 활성화 함수: 0과 1 사이의 값을 출력하며, 이진 분류에 유용하지만 다중 클래스 문제의 은닉 레이어에서는 덜 일반적입니다.
            소프트맥스 활성화 함수: 최종 레이어 출력값을 10개 클래스에 대한 확률 분포로 변환합니다.
        
    


모델 구축:




		
		
			
			
Java
			
			from keras.models import Sequential
from keras.layers import Dense, Flatten

# Create a simple Neural Network model
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from keras.models import Sequential
from keras.layers import Dense, Flatten
 
# Create a simple Neural Network model
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
					
				
			
		



모델 요약
모델 구조와 파라미터를 시각화하려면:





		
		
			
			
Java
			
			model.summary()
			
				
					
				
					1
				
						model.summary()
					
				
			
		



출력:




		
		
			
			
Java
			
			Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
					
				
			
		



이 요약은 각 레이어의 출력 형태와 훈련해야 할 파라미터 수에 대한 통찰을 제공합니다.

모델 컴파일: 손실 함수 및 최적화기 
훈련 전에, 모델을 지정된 손실 함수와 최적화기로 컴파일해야 합니다.

    손실 함수: 모델의 예측이 실제 레이블과 얼마나 일치하는지를 측정합니다.
        
            범주형 크로스엔트로피: 다중 클래스 분류 문제에 적합합니다.
        
    
    최적화기: 손실 함수를 최소화하기 위해 모델의 가중치를 업데이트합니다.
        
            아담 최적화기: 학습률을 조절하는 효율적인 확률적 경사 하강법 방법입니다.
        
    


모델 컴파일:




		
		
			
			
Java
			
			model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
			
				
					
				
					1
				
						model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
					
				
			
		



모델 훈련: 학습 및 검증 
훈련은 모델에 데이터를 제공하고 여러 에포크를 통해 패턴을 학습하게 하는 과정입니다.

    에포크: 전체 데이터셋이 네트워크를 통과하는 횟수.
    검증 데이터: 각 에포크 후에 보지 못한 데이터에 대한 모델의 성능을 평가하는 데 사용됩니다.


훈련 과정:




		
		
			
			
Java
			
			history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
			
				
					
				
					1
				
						history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
					
				
			
		



샘플 출력:




		
		
			
			
Java
			
			Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
			
				
					
				
					1
2
3
4
5
				
						Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
					
				
			
		



10 에포크가 끝날 때쯤, 모델은 학습 데이터와 검증 데이터 모두에서 약 93%의 정확도를 달성하여 우수한 성능을 나타냅니다.

모델 평가: 정확도 및 예측 
훈련 후에는 모델의 성능을 평가하고 새로운 데이터에 대한 예측을 수행하는 것이 중요합니다.

예측 수행




		
		
			
			
Java
			
			# Predicting on the test set
predictions = model.predict(X_test)
			
				
					
				
					1
2
				
						# Predicting on the test set
predictions = model.predict(X_test)
					
				
			
		



각 예측은 10개 클래스에 대한 확률 분포로 구성됩니다. 예측된 클래스를 결정하려면:





		
		
			
			
Java
			
			import numpy as np

# Convert probabilities to class labels
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
			
				
					
				
					1
2
3
4
5
				
						import numpy as np
 
# Convert probabilities to class labels
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
					
				
			
		



예측 시각화
몇몇 테스트 이미지와 그에 대한 예측 레이블 및 실제 레이블을 시각화해 보겠습니다:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()

# Plotting the first test image
plot_prediction(0)

# Plotting another sample
plot_prediction(25)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import matplotlib.pyplot as plt
 
def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()
 
# Plotting the first test image
plot_prediction(0)
 
# Plotting another sample
plot_prediction(25)
					
				
			
		



출력:
실제 레이블과 모델의 예측을 나타내는 제목이 포함된 이미지를 표시합니다.

모델 정확도
모델은 검증 데이터셋에서 93%의 정확도를 달성하여, 보지 못한 데이터에 대해 잘 일반화할 수 있음을 보여줍니다. 성능을 향상시키기 위해 추가적인 튜닝과 보다 복잡한 아키텍처를 탐색할 수 있습니다.

신경망 구조 시각화 
신경망의 아키텍처를 이해하면 데이터가 어떻게 흐르고 변환이 일어나는지 이해하는 데 도움이 될 수 있습니다. 아래는 구축된 신경망의 시각적 표현입니다:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Draws a neural network diagram.
    
    :param ax: Matplotlib Axes object
    :param left: Left boundary
    :param right: Right boundary
    :param bottom: Bottom boundary
    :param top: Top boundary
    :param layer_sizes: List containing the number of neurons in each layer
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Draw neurons
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Draw edges
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)

# Drawing the neural network
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
			
				
					
				
					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
				
						import matplotlib.pyplot as plt
 
def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Draws a neural network diagram.
    
    :param ax: Matplotlib Axes object
    :param left: Left boundary
    :param right: Right boundary
    :param bottom: Bottom boundary
    :param top: Top boundary
    :param layer_sizes: List containing the number of neurons in each layer
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Draw neurons
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Draw edges
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)
 
# Drawing the neural network
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
					
				
			
		



출력:


이 다이어그램은 입력 뉴런(784개)에서 은닉 레이어를 거쳐 출력 뉴런(10개)으로의 흐름을 보여줍니다.

훈련 최적화: GPU 활용 
신경망을 훈련시키는 것은, 특히 딥 네트워크의 경우, 계산 비용이 많이 들고 시간이 많이 걸릴 수 있습니다. 그래픽 처리 장치(GPU)를 활용하면 훈련 과정을 상당히 가속화할 수 있습니다. 다음은 Keras에서 GPU를 활용하는 방법입니다:

    GPU 호환성 확보:
        
            NVIDIA CUDA Toolkit 및 cuDNN 설치.
            GPU가 TensorFlow(Keras의 백엔드)와 호환되는지 확인.
        
    
    GPU 호환 TensorFlow 설치:
        



		
		
			
			
Java
			
			pip install tensorflow-gpu
			
				
					
				
					1
				
						pip install tensorflow-gpu
					
				
			
		


    
    TensorFlow를 GPU 사용하도록 구성:
        TensorFlow는 자동으로 GPU를 감지하고 활용합니다. 그러나 필요에 따라 GPU 설정을 명시적으로 지정할 수 있습니다.
        



		
		
			
			
Java
			
			import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # TensorFlow를 첫 번째 GPU만 사용하도록 제한
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import tensorflow as tf
 
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # TensorFlow를 첫 번째 GPU만 사용하도록 제한
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
					
				
			
		


    


GPU 사용의 장점:

    병렬 처리: GPU는 여러 계산을 동시에 처리할 수 있어 신경망의 행렬 연산에 이상적입니다.
    더 빠른 훈련: 모델을 훨씬 빠르게 훈련시켜, 더 많은 실험과 빠른 반복이 가능합니다.


참고: GPU 사용 최적화는 특정 시스템 설정에 따라 추가 구성을 필요로 할 수 있습니다.

결론 
Keras와 MNIST 데이터셋을 사용하여 숫자 분류를 위한 간단한 신경망을 구축하는 것은 머신러닝과 딥러닝의 세계에 대한 훌륭한 입문입니다. 이 가이드를 따라, 다음을 배우셨습니다:

    MNIST 데이터셋을 이해하고 전처리하는 방법.
    Keras를 사용하여 신경망 모델을 구축하는 방법.
    모델의 성능을 훈련하고 평가하는 방법.
    네트워크 아키텍처를 시각화하는 방법.
    GPU를 활용하여 훈련을 최적화하는 방법.


논의된 모델은 상당한 정확도를 달성하지만, 개선의 여지가 충분히 있습니다. 보다 복잡한 아키텍처를 탐색하거나, 다양한 활성화 함수로 실험하거나, 정규화 기법을 구현함으로써 성능을 향상시킬 수 있습니다. 머신러닝 여정을 계속하는 동안 이러한 기본 사항을 바탕으로, 더 복잡하고 영향력 있는 프로젝트에 도전할 수 있을 것입니다.

즐거운 코딩 되세요!