내용
신경모형망의 구성
신경모형망의 기본 과정
- 네트워크(또는 모델)로 결합되는 계층
- 입력 데이터 및 해당 대상
- 학습에 사용되는 피드백 신호를 정의하는 손실 함수
- 학습이 어떻게 진행되는지를 결정하는 옵티마이저
신경망의 전체적인 과정은 그림 1과 같습니다.
그림 1에 나타낸 것과 같은 신경망의 작동은 6단계로 구분할 수 있습니다.
- 입력을 위한 층(layer)을 구성하며 초기 가중치(W)와 편차(b)를 부여합니다.
- 층내에서 변수와 가중치의 연산에 의한 예측값을 산출합니다.
- 예측값과 실측치인 y를 손실함수(loss function)에 입력됩니다.
- 비용(cost)을 계산됩니다.
- 최적화 과정에 의해 가중치는 업데이트 됩니다.
- 업데이트 된 가중치는 다시 2)~5) 과정을 반복하여 최소비용에 수렴되는 가중치를 생성합니다.
대표적인 신경망의 종류
- MLP: Multilayer Perceptron
- CNN: Convolutional Neural Network
- RNN: Recurrent Neural Network
다층 퍼셉트론(MLP) 완전연결(fully connected, FC) 네트워크입니다. MLP는 단순 로지스틱 및 선형 회귀 문제에서 일반적으로 적용됩니다. 그러나 MLP는 순차 및 다차원 데이터 패턴을 처리하는 데 최적이 아닙니다. 설계상 MLP는 순차적 데이터의 패턴을 기억하는 데 어려움을 겪고 다차원 데이터를 처리하기 위해 상당한 수의 매개변수가 필요합니다. 순차적 데이터 입력의 경우 RNN이 널리 사용되는 이유는 내부 설계를 통해 네트워크가 데이터 기록에서 종속성을 발견할 수 있고 이는 예측에 유용하기 때문입니다. 이미지 및 비디오와 같은 다차원 데이터의 경우 CNN은 분류, 세분화, 생성 및 기타 다운스트림 작업을 위한 특징 맵을 추출하는 데 탁월합니다. 어떤 경우에는 1D 컨볼루션 형태의 CNN이 순차적 입력 데이터가 있는 네트워크에도 사용됩니다. 그러나 대부분의 딥 러닝 모델에서는 MLP와 CNN 또는 RNN을 결합하여 각 네트워크를 최대한 활용합니다.
MLP, CNN 및 RNN은 심층 네트워크의 전체 그림을 완성하지 않습니다. 각 네트워크는 각각에 부합하는 목적 함수 또는 손실 함수, 최적화(옵티마이저) 프로그램 및 정규화 프로그램들과 함께 구성되어야 합니다. 목표는 훈련 중 손실 함수 값을 줄이는 것입니다. 이러한 감소는 모델이 학습 중임을 나타내는 좋은 지표이기 때문입니다.
손실함수 값을 최소화하기 위해 모델은 옵티마이저를 사용합니다. 이것은 각 훈련 단계에서 가중치와 편향을 조정하는 방법을 결정하는 알고리즘입니다. 훈련된 모델은 훈련 데이터뿐만 아니라 훈련 환경 외부의 데이터(검정 데이터)에서도 작동해야 합니다. 정규화(regularizer)의 역할은 훈련된 모델이 새로운 데이터로 일반화되도록 하는 것입니다.
다층 퍼셉트론(MLP)
MLP 네트워크로 손으로 쓴 숫자를 기반으로 숫자를 식별하기 위한 신경망을 만든다고 가정합니다. 예를 들어, 네트워크에 대한 입력이 손으로 쓴 숫자 8의 이미지인 경우 해당 예측도 숫자 8이어야 합니다. 이것은 로지스틱 회귀를 사용하여 훈련할 수 있는 분류기 네트워크의 고전적인 작업입니다. 분류기 네트워크를 훈련하고 검증하려면 충분한 수의 수기로 쓴 숫자 데이터 세트가 있어야 합니다. MNIST(Modified National Institute of Standards and Technology)를 사용합니다.
MNIST는 0에서 9 사이의 손글씨 숫자 모음으로 60,000개의 학습과 10,000개의 테스트 이미지가 있습니다. 각 숫자 샘플 이미지는 28 x 28 픽셀 크기이며 회색조로 표시됩니다. Keras에서 MNIST 데이터 세트를 사용하기 위해 이미지와 레이블을 자동으로 다운로드하고 추출하는 API가 제공됩니다.
import numpy as np
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
#load dataset
(xtr, ytr),(xte, yte)=mnist.load_data()
unique, counts=np.unique(ytr, return_counts=True)
print("Train label: ", dict(zip(unique, counts)))
Train label: {0: 5923, 1: 6742, 2: 5958, 3: 6131, 4: 5842, 5: 5421, 6: 5918, 7: 6265, 8: 5851, 9: 5949}
unique1, counts1=np.unique(yte, return_counts=True)
print("Test label: ", dict(zip(unique1, counts1)))
Test label: {0: 980, 1: 1135, 2: 1032, 3: 1010, 4: 982, 5: 892, 6: 958, 7: 1028, 8: 974, 9: 1009}
idx=np.random.randint(0, xtr.shape[0], size=25)
images=xtr[idx]
labels=ytr[idx]
plt.figure(dpi=100)
for i in range(len(idx)):
plt.subplot(5, 5, i+1)
image=images[i]
plt.imshow(image, cmap="gray")
plt.axis('off')
plt.savefig('mnist-samples.png')
plt.show()
plt.close('all')
MLP 분류기 모델을 논의하기 전에 MNIST 데이터가 2차원 텐서로 구성되어 있지만 입력 레이어의 유형에 따라 모양이 변경되어야 함을 명심해야 합니다. 다음 그림 2는 MLP, CNN 및 RNN 입력 레이어에 대해 3×3 그레이스케일 이미지가 어떻게 재구성되는지 보여줍니다.
MLP 분류기 모델
tf.keras를 사용하여 모델을 효율적으로 구축, 훈련 및 검증하는 방법은 다음과 같습니다.
MLP의 분류기 모형은 다음과 같이 구성됩니다.
import numpy as np import matplotlib.pyplot as plt import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Activation, Dropout from tensorflow.keras.utils import to_categorical, plot_model from tensorflow.keras.datasets import mnist
(xtr, ytr),(xte, yte)=mnist.load_data() num_labels=len(np.unique(ytr)) num_labels
10
레이블은 0에서 9까지의 숫자 형식입니다. 레이블의 이러한 희소 스칼라(sparse scalar) 표현은 클래스당 확률을 출력하는 신경망 예측 계층에 적합하지 않습니다. 더 적합한 형식은 숫자 클래스의 인덱스를 제외하고 모든 요소가 0인 10차원 벡터인 원-핫 벡터(one-hot vector)입니다. 예를 들어 레이블이 2인 경우 등가 원-핫 벡터는 [0,0,1,0,0,0,0,0,0,0]입니다. 첫 번째 레이블의 인덱스는 0입니다.
이 원-핫 벡터로 전환은 tf.keras.util.to_categorical()를 적용합니다.
#원-핫 벡터로 전환 ytr=to_categorical(ytr) yte=to_categorical(yte) ytr
array([[0., 0., 0., ..., 0., 0., 0.],
[1., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 1., 0.]], dtype=float32)
xtr.shape
(60000, 28, 28)
다음 코드는 입력차원(feature)과 표준화에 대한 것입니다. 그림 1에서 나타낸 것과 같이 MPL에 입력될 객체는 1차원 벡터입니다. 그러나 위 결과와 같이 xtr은 batch 축을 포함한 3차원 이미지이므로 두 번째와 세 번째 차원만을 고려합니다. 또한 이 자료는 이미지이고 차원수가 동일하므로 이 둘을 곱하여 입력차원으로 설정합니다.
각 샘플의 픽셀 값을 0에서 255까지이므로 이들을 정규화합니다. 즉, 0.0에서 1.0까지 범위로 조정합니다. 원시 픽셀 값을 직접 사용할 수 있지만 훈련을 어렵게 할 수 있는 큰 기울기 값을 피하기 위해 입력 데이터를 정규화하는 것이 좋습니다. 네트워크의 출력도 정규화됩니다. 훈련 후에 출력 텐서에 255를 곱하여 모든 것을 정수 픽셀 값으로 되돌리는 옵션이 있습니다.
#image dimension
imageSize=xtr.shape[1]
inputSize=imageSize*imageSize
#resize and normalize
xtr=np.reshape(xtr, [-1, inputSize])
xtr=xtr.astype("float32")/255
xte=np.reshape(xte, [-1, inputSize])
xte=xte.astype("float32")/255
xtr.shape, xte.shape
((60000, 784), (10000, 784))
MPL과 Keras를 사용하여 모델 구축
Keras의 Sequential API를 사용하여 MLP 분류기 모델을 구축합니다.
다음 코드에서 구축된 모델은 3개의 MLP 계층으로 구성된다. Keras에서 MLP 계층은 Dense라고 하며 이는 Densely Connected Layer를 나타냅니다. 첫 번째 및 두 번째 MLP 레이어는 각각 256개의 유닛으로 본질적으로 동일하며 그 다음에는 ReLU(Rectified Linear Unit) 활성화 및 드롭아웃이 있습니다. 층의 유닛은 128, 512 및 1,024 단위와 같이 지정할 수 있습니다. 이 데이터의 경우 128개 단위에서 네트워크는 빠르게 수렴되지만 테스트 정확도는 더 낮습니다. 512 또는 1,024에 대한 추가 단위 수는 테스트 정확도를 크게 증가시키지 않습니다.
단위 수는 모델 구축과정에서 학습 전에 지정되는 초매개변수(hyperparameter)로서 모델의 용량(capacity)을 제어합니다. 용량은 네트워크가 근사할 수 있는 함수의 복잡성을 측정한 것입니다. 예를 들어, 다항식의 경우 차수는 초매개변수입니다. 차수가 증가함에 따라 함수의 용량도 증가합니다.
다음 코드와 같이 분류기 모델은 Keras의 Sequential API를 사용하여 구현했습니다. 이러한 방식은 모델에 일련의 계층에서 처리되는 입력과 출력이 하나씩 필요한 경우 적합합니다. 그러나 다중 입력 및 출력과 같은 더 복잡한 구조를 필요로 하는 고급 딥 러닝 모델을 구현하기 위해 Keras의 Functional API를 사용합니다.
# network parameters
batSize=128
hiddenUnit=256
dropout=0.45
# model: 3-layer MLP with ReLU and dropout after each layer
model=Sequential()
model.add(Dense(hiddenUnit, input_dim=inputSize))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dense(hiddenUnit))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dense(num_labels))
#출력은 원-핫 벡터
model.add(Activation("softmax"))
model.summary()
Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense (Dense) (None, 256) 200960 _________________________________________________________________ activation (Activation) (None, 256) 0 _________________________________________________________________ dropout (Dropout) (None, 256) 0 _________________________________________________________________ dense_1 (Dense) (None, 256) 65792 _________________________________________________________________ activation_1 (Activation) (None, 256) 0 _________________________________________________________________ dropout_1 (Dropout) (None, 256) 0 _________________________________________________________________ dense_2 (Dense) (None, 10) 2570 _________________________________________________________________ activation_2 (Activation) (None, 10) 0 ================================================================= Total params: 269,322 Trainable params: 269,322 Non-trainable params: 0 _________________________________________________________________
위 결과를 저장하기
plot_model(model, to_file=---, show_shapes=True)함수를 사용합니다.
신경망 모형은 위에서 구성한 레이어를 기본으로 손실함수와 옵티마이저를 포함하여야 합니다. 이는 .compile() 메소드로 실현됩니다.
# loss function for one-hot vector # optimizer : adam # 분류작업 모형의 정확도를 출력 metrics=['accuracy'] model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
구축한 모델을 학습시키기 위해 .fit()를 사용합니다. 이 메소드는 학습을 위한 것으로 forword와 backwardr 과정을 모두 수행합니다. 반면에 생성된 모델의 검증을 위해서는 forward 과정만을 수행해야 합니다. 이는 .evaluate() 메소드에 의해 이루어 집니다.
# 모델 학습
model.fit(xtr, ytr, epochs=20, batch_size=batSize)
# 모델의 일반화를 위해 검정 데이터에 적용
_, acc=model.evaluate(xte, yte, batch_size=batSize, verbose=0)
print('\nTest accuracy: %.1f%%' %(100.0*acc))
Epoch 1/20 469/469 [==============================] - 11s 19ms/step - loss: 0.7237 - accuracy: 0.7667 Epoch 2/20 469/469 [==============================] - 9s 18ms/step - loss: 0.1967 - accuracy: 0.9407 … Epoch 19/20 469/469 [==============================] - 9s 18ms/step - loss: 0.0516 - accuracy: 0.9830 Epoch 20/20 469/469 [==============================] - 8s 18ms/step - loss: 0.0536 - accuracy: 0.9819 Test accuracy: 98.2%
비선형 함수
Dense 레이어는 선형 연산이므로 Dense 레이어 시퀀스는 선형 함수에 근접할 수만 있습니다. 문제는 MNIST 숫자 분류가 본질적으로 비선형 프로세스라는 것입니다. Dense 레이어 사이에 relu 활성화를 삽입하면 MLP 네트워크가 비선형 매핑을 모델링할 수 있습니다. relu 또는 ReLU는 단순한 비선형 함수입니다. 다른 모든 것을 0으로 고정하면서 양수 입력이 변경되지 않은 상태로 통과하도록 하는 필터와 매우 유사합니다. 수학적으로 relu는 식 1과 같이 표현되며 그림 3에 표시됩니다.
$$\begin{equation}\tag{1}\text{ReLU} = \text{max(0, x)}\end{equation}$$x=tf.sort(tf.random.uniform([20], -1,1)) x
<tf.Tensor: shape=(20,), dtype=float32, numpy=
array([-0.9548516 , -0.91288424, -0.900254 , -0.8572755 , -0.45991993,
-0.4379928 , -0.43516183, -0.03852439, -0.03323102, 0.56813025,
0.60745597, 0.615865 , 0.6288991 , 0.6877227 , 0.71364594,
0.7365284 , 0.7775626 , 0.8900726 , 0.9397092 , 0.9840772 ],
dtype=float32)>
relu=tf.keras.layers.ReLU() y=relu(x) y
<tf.Tensor: shape=(20,), dtype=float32, numpy=
array([0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0.56813025,
0.60745597, 0.615865 , 0.6288991 , 0.6877227 , 0.71364594,
0.7365284 , 0.7775626 , 0.8900726 , 0.9397092 , 0.9840772 ],
dtype=float32)>
plt.figure(dpi=100)
plt.plot(x, y, label='ReLU')
plt.xlabel('x', weight='bold')
plt.ylabel('y', weight='bold')
plt.legend(loc="best")
plt.show()
elu, selu, softplus, sigmoid 및 tanh와 같이 사용할 수 있는 다른 비선형 함수가 있습니다. 그러나 relu는 가장 일반적으로 사용되는 함수이며 단순성으로 인해 계산상 효율적입니다. 시그모이드 함수와 tanh 함수는 출력층에서 활성화 함수로 사용됩니다. 표 1은 이러한 활성화 함수 각각에 대한 방정식을 보여줍니다.
| 함수명 | 수식 | tf.keras.activations |
|---|---|---|
| relu | relu(x)=max(0, x) | .relu() |
| softplus | softplus(x)=log(1+ex) | .softplus() |
| selu | sleu(x) = k × elu(x, a) k=1.0507..., a=1.67326... | .selu() |
| sigmoid | $\text{sigmoid(x)}=\frac{1}{1+e^{-x}}$ | .sigmoid() |
| tanh | $\text{tanh(x)}=\frac{e^x-e^{-x}}{e^x+e^{-x}}$ | .tanh() |
정규화(Regulariztion)
일반적으로 특징(feature)별로 데이터의 스케일(scale)이 상이한 자료 즉, 이질적인 데이터(예: 예를 들어 한 특징이 0–1 범위에 있고 다른 특징이 100–200 범위에 있는 데이터) 또는 큰 단위로 구성된 자료는 평균이 0이고 표준편차가 1인 데이터로 표준화합니다. 그렇게 하면 학습시 대규모 그래디언트 업데이트가 안정적으로 작동될 수 있습니다. 네트워크에서 더 쉽게 학습할 수 있도록 데이터에는 다음과 같은 특성이 있어야 합니다.
- 작은 값 사용 - 일반적으로 대부분의 값은 0–1 범위에 있어야 합니다.
- 동질화(Be homogeneous) - 즉, 모든 기능은 거의 동일한 범위의 값을 취해야 합니다.
위의 특성에 부합하기 위해 데이터를 조정하는 과정을 정규화라고하며 정규화 계층 또는 함수를 사용합니다. 일반적인 정규화 레이어는 Dropout입니다. Dropout 비율이 주어지면(여기서는 dropout = 0.45로 설정됨) Dropout 레이어는 다음 레이어에 참여하는 단위의 해당 부분을 무작위로 제거합니다. 예를 들어 첫 번째 레이어에 256개의 유닛이 있는 경우 dropout = 0.45가 적용된 후 레이어 1에서 (1 - 0.45) * 256 유닛 = 140 유닛만 레이어 2에 참여합니다.
일부 단위가 누락된 경우에도 네트워크가 올바르게 예측하도록 훈련되었기 때문에 Dropout 계층은 예측하지 못한 입력 데이터에 대해 신경망을 강력하게 만듭니다. Dropout은 출력 레이어에서 사용되지 않고 훈련 중에만 활성화됩니다.
l1 또는 l2와 같은 dropout 외에 사용할 수 있는 regularizer가 있습니다. Keras에서는 바이어스, 가중치 및 활성화 출력을 레이어별로 정규화할 수 있습니다. l1 및 l2는 패널티 함수를 추가하여 더 작은 매개변수 값을 선호합니다. l1과 l2는 모두 매개변수 값의 절대값(l1) 또는 제곱(l2) 합계의 일부를 사용하여 페널티를 적용합니다. 즉, 패널티 함수는 옵티마이저가 작은 매개변수 값을 찾도록 합니다. 매개변수 값이 작은 신경망은 입력 데이터 내에서 발생하는 노이즈에 더 둔감합니다. 예를 들어 fraction=0.001인 l2-weight regularizer는 다음과 같이 구현할 수 있습니다.
from tensorflow.keras.regularizers import l2
model.add(Dense(hidden_units,
kernel_regularizer=12(0.001),
input_dim=input_size))
l1 또는 l2 정규화가 사용되는 경우 추가 레이어가 추가되지 않습니다. 정규화는 내부적으로 Dense 레이어에 적용됩니다. 제안된 모델의 경우 dropout은 여전히 l2보다 더 나은 성능을 보입니다.
출력활성화와 비용함수
출력 레이어에는 10개의 유닛이 있고 그 뒤에 소프트맥스 활성화 레이어가 있습니다. 10개의 단위는 10개의 가능한 레이블, 클래스 또는 범주에 해당합니다. softmax 활성화는 다음 방정식과 같이 수학적으로 표현할 수 있습니다.
$$\begin{equation}\tag{2}\text{softmax}(x_i)=\frac{e^{x_i}}{\sum^{N-1}_{j=0}e^{x_j}}\end{equation}$$식 2는 모든 N = 10개 출력에 적용되며, i = 0의 경우 xi, 최종 예측의 경우 1 … 9입니다. 이 식은 각 예측을 정규화하여 각 요소의 확률을 출력합니다. 그러므로 각 예측 출력은 인덱스가 주어진 입력 이미지의 올바른 레이블일 확률입니다. 모든 출력에 대한 모든 확률의 합은 1.0입니다. 예를 들어, xtr[10]에 대한 결과는 다음과 같이 softmax 레이어를 통과하므로 10차원 1D 텐서가 됩니다.
위 모델의 레이어에 softmax함수를 지정하는 것 뿐만 아니라 별도의 객체에 대해 td.keras.activations 클래스의 softmax() 함수를 사용하여 계산할 수 있습니다.
re10=model.predict(xtr[10].reshape(1,-1)) re10
array([[1.69197372e-16, 2.23650994e-11, 4.58823908e-12, 9.99998093e-01,
5.07513396e-16, 1.88394466e-07, 7.64167918e-22, 2.96871338e-12,
1.01827005e-10, 1.70528654e-06]], dtype=float32)
np.sum(re10)
1.0
예측 출력 텐서는 인덱스가 가장 높은 확률을 갖는다는 점에서 입력 이미지가 3이 될 것이라고 제안합니다. numpy.argmax() 메서드는 가장 높은 값을 가진 요소의 인덱스를 결정하는 데 사용할 수 있습니다.
linear, sigmoid 또는 tanh와 같은 출력 활성화 계층의 다른 선택이 있습니다. 선형 활성화는 항등 함수입니다. 입력을 출력에 복사합니다. 시그모이드 함수는 보다 구체적으로 로지스틱 시그모이드로 알려져 있습니다. 이것은 예측 텐서의 요소가 0.0과 1.0 사이에서 독립적으로 매핑되는 경우에 사용됩니다. 예측된 텐서의 모든 요소의 합은 softmax와 달리 1.0으로 제한되지 않습니다. 예를 들어, Sigmoid는 감정 예측(0.0에서 1.0까지, 0.0은 나쁨, 1.0은 좋음) 또는 이미지 생성(0.0은 픽셀 수준 0에 매핑되고 1.0은 픽셀 255에 매핑됨)에서 마지막 레이어로 사용됩니다.
np.argmax(re10)
3
tanh 함수는 -1.0에서 1.0 범위의 입력을 매핑합니다. 출력이 양수 값과 음수 값 모두에서 스윙할 수 있는 경우 중요합니다. tanh 함수는 순환 신경망의 내부 계층에서 더 널리 사용되지만 출력 계층 활성화로도 사용되었습니다. tanh가 출력 활성화에서 시그모이드를 대체하는 데 사용되는 경우 사용되는 데이터는 적절하게 확장되어야 합니다. 예를 들어 $\displaystyle x=\frac{x}{255}$를 사용하여 grayscale을 [0, 1]의 범위로 조정하는 대신 $\displaystyle x=\frac{x-127.5}{127.5}$를 사용하여 범위를 [-1, 1]로 조정할 수 있습니다.
다음은 sigmoid와 tanh를 나타낸 것입니다.
x=tf.sort(tf.random.uniform([100], -10, 10))
ySig=tf.keras.activations.sigmoid(x)
ytan=tf.keras.activations.tanh(x)
plt.figure(dpi=100)
plt.plot(x, ySig, label="Sigmoid")
plt.plot(x, ytan, label="tanh")
plt.xlabel("x", weight="bold")
plt.xlabel("y", weight="bold")
plt.legend(loc='best')
plt.show()
예측된 텐서가 관찰치 값(레이블)에서 얼마나 멀리 떨어져 있는지를 손실이라고 합니다. 손실 함수의 한 유형은 대상 또는 레이블과 예측 간의 차이 제곱의 평균인 MSE(Mean Squared Error)입니다. 현재 예에서는 categorical crossentropy를 사용하고 있습니다. 대상 또는 레이블의 곱과 범주별 예측 로그의 합계의 음수입니다. mean absolute error 및 binary crossentropy와 같이 Keras에서 사용할 수 있는 다른 손실 함수가 있습니다. 표 2는 일반적인 손실 함수를 요약합니다.
| 비용함수 | 함수 |
|---|---|
| mean squared error | $\frac{1}{N}\sum^N_{i=1}(y_i-\hat{y_i})^2$ |
| mean absolute error | $\frac{1}{N}\sum^N_{i=1}\vert y_i-\hat{y_i} \vert$ |
| categorical crossentropy | $-\sum^N_{i=1}y_i\log(\hat{y_i})$ |
| mean squared error | $-y_1\log(\hat{y_1})-(1-y_1)\log(1-\hat{y_1})$ |
| N: category # | |
손실 함수(비용함수)는 모델의 유형에 따라 선택됩니다. 범주별 분류의 경우 categorical crossentropy 또는 mean squared error가 softmax 활성화 계층 이후에 좋은 선택입니다. binary crossentropy 손실 함수는 일반적으로 sigmoid 활성화 계층 다음에 사용되는 반면 mean squared error는 tanh 출력에 대한 옵션입니다.
신경망 모형의 옵티마이저로 경사하강법(Descent Gradient)를 기본적으로 사용합니다. 이 방법을 기준으로 개선된 다양한 옵티마이저 알고리즘이 있습니다. 이는 별도의 포스트에서 다룹니다.
댓글
댓글 쓰기