[TF]Sequential 모형 만들기

Sequential 모형 만들기

layer를 조합하여 모형을 만듭니다. 이것은 keras API를 적용하는 것으로 tf.keras.Sequential 모형입니다.

from tensorflow.keras imports layers

#시퀀스 모형의 frame을 작성하고 .add 메소드를 사용하여 층을 첨가합니다.

model = tf.keras.Sequential()

#모형에 64개 유닛의 층을 첨가합니다. 활성함수로 relu를 적용합니다.

model.add(layers.Dense(64, activation="relu"))

#동일한 층을 첨가할 수 있습니다.

model.add(layers.Dense(64, activation="relu"))

#10개 유닛을 가진 마지막 층을 첨가하며 활성함수로 softmax를 사용합니다.

model.add(layers.Dense(10, activation="softmax"))

위 함수들의 인수들은 다음을 포함합니다.

activation: 활성함수를 지정합니다. 기본으로 제공되는 함수이름 또는 사용자 정의 함수를 함수나 객체를 지정할 수 있습니다. 기본값은 활성함수를 지정하지 않는 것입니다.
kernel_initializer, bias_initializer: 가중치(weight), 절편 (bias)의 초기화 방법을 지정 내장함수 또는 호출가능한 객체를 지정 glorot_uniform이 기본값
kernel_regularizer, bias-regularizer: L1, L2와 같이 정규화 방법을 지정, 기본값은 지정하지 않는 것입니다.

다음은 다양한 매개변수를 사용하여 층을 만드는 예입니다.

layers.Dense(64, activation="sigmoid")

layers.Dense(64, activation=tf.keras.activations.sigmoid)

layer.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01))

layer.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01))

layers.Dense(64, kernel_regularlizer="orthogonal")

layer.Dense(64, bias_initalizer=td.keras.initalizers.Constant(2.0))

훈련과 평가

훈련준비

여러 층으로 구성된 모형을 생성한 후 훈련과정에서 필요한 옵티마지저, 비용함수, 평가방법등을 지정합니다. 이것은 compile 메서드에 의해 지정됩니다. 다음 코드에서는 .add 메소드 대신 Sequential() 함수에 모든 층을 포함하는 방법입니다.

model=tf.keras.Sequential([
layers.Dense(64, activation="relu", input_shape(32,)),
layers.Dense(64, activation="relu")
leyers.Dense(10, activation="softmax")])

model.compile(optimizer=tf.keras.optimizer.Adam(0.01),
loss="categorical_crossentropy",
metrics=["accuracy"])

optimizer: 훈련과정을 설정하며 tf.keras.optimizer.Adam, tf.keras.optimizer.SGD등의 최적화 함수를 지정합니다. 이 변수는 "adam", "sgd"와 같이 문자열로 지정할 수 있습니다.
loss: 손실함수(loss function)를 지정합니다. mse, categorical_crossentropy, binary_entropy등을 사용하며 tf.keras.losses.mse와 같이 전달할 수 있으며 위 코드 "categorical_crossentropy"와 같이 문자열로 지정할 수 있습니다.
metrics: 훈련을 모니터링하기 위해 사용. 이름의 문자열이나 tf.keras.metrics의 모듈아래 객체의 이름을 추가하여 사용할 수 있습니다. 즉, 위 코드의 "accuracy"=tf.keras.metrics.CategoricalAccuracy()와 같이 사용할 수 있습니다.
run-_eagerly=True: 훈련과 평가를 즉시 실행하기 위해 사용

모델 학습

fit메소드로 학습합니다. 다음 코드는 random수로 작성된 데이터의 학습을 나타냅니다.

		import numpy as np        
		import tensorflow as tf
		from tensorflow import keras
		from tensorflow.keras import layers
		
		#모델 생성
		model = tf.keras.Sequential()
		model.add(layers.Dense(64, activation='relu', input_shape=(32,)))
		model.add(layers.Dense(64, activation='relu'))
		model.add(layers.Dense(10, activation='softmax'))
		
		# 최적화, 비용함수, 평가 방법 결과 
		model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
		             loss="categorical_crossentropy",
		             metrics=['accuracy'])
		
		#데이터             	
		data=np.random.random((1000, 32))
		label=np.random.random((1000, 10))
		data[0,:]
		array([0.44726098, 0.76259496, 0.20532904, 0.86646925, 0.43548832,
		       0.9792873 , 0.60414022, 0.7749146 , 0.17789568, 0.61527241,
		       0.09933313, 0.67637411, 0.09937704, 0.08363647, 0.20458706,
		       0.98128849, 0.86461741, 0.21130626, 0.2840409 , 0.75642522,
		       0.80991198, 0.45846335, 0.84860646, 0.01821211, 0.38048572,
		       0.93606663, 0.17688986, 0.53832843, 0.93186857, 0.77561153,
		       0.21245154, 0.01323744])

		# 모델 훈련        
		model.fit(data, label, epochs=10, batch_size=32)
		Train on 1000 samples
		Epoch 1/10
		1000/1000 [==============================] - 2s 2ms/sample - loss: 11.6432 - accuracy: 0.0930
		Epoch 2/10
		1000/1000 [==============================] - 0s 69us/sample - loss: 14.4173 - accuracy: 0.1060
		Epoch 3/10
		1000/1000 [==============================] - 0s 72us/sample - loss: 29.1142 - accuracy: 0.1080
		Epoch 4/10
		1000/1000 [==============================] - 0s 69us/sample - loss: 60.0033 - accuracy: 0.1050
		Epoch 5/10
		1000/1000 [==============================] - 0s 72us/sample - loss: 112.2787 - accuracy: 0.1110
		Epoch 6/10
		1000/1000 [==============================] - 0s 63us/sample - loss: 177.9676 - accuracy: 0.1120
		Epoch 7/10
		1000/1000 [==============================] - 0s 78us/sample - loss: 257.9487 - accuracy: 0.0900
		Epoch 8/10
		1000/1000 [==============================] - 0s 67us/sample - loss: 340.8721 - accuracy: 0.0930
		Epoch 9/10
		1000/1000 [==============================] - 0s 73us/sample - loss: 410.7415 - accuracy: 0.0890
		Epoch 10/10
		1000/1000 [==============================] - 0s 74us/sample - loss: 463.7994 - accuracy: 0.0910
		<tensorflow.python.keras.callbacks.History at 0x7fe178156bd0>

위 코드와 같이 모델 학습은 tf.keras.Model.fit() 메소드를 사용합니다. 이 메소드에는 세개의 중요한 매개변수를 포함합니다.

epochs: 1 epoch는 전체 입력데이터를 한번 순회하는 것입니다.
batch_size: 데이터를 작은 규모로 나누어 훈련합니다. 즉, 위 코드의 경우는 1000개의 샘플을 32개의 단위로 구분하여 실행합니다. 전체 샘플의 개수가 배치의 크기로 나누어 떨어지지 않으면 마지막 매치의 크기는 더 작을 수 있습니다.
validation_data: 생성된 모형을 검증하기 위한 데이터를 지정합니다. 모형이 1epoch가 끝나면 그 모형을 검증데이터에 적용하여 지정된 평가결과를 반환합니다.

배치에 대한 예를 봅니다.

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a는 numpy 형이고 이를 tensor에서 사용할 데이터셋 즉, batch 등을 적용할 수 있는 데이터 셋으로 만들기 위해서 아래와 같이 처리합니다. 또한 map을 사용하여 데이터의 모든 값들을 제곱하는 함수를 적용하고 이를 20번 섞은 후 2개씩을 하나의 배치로 구분합니다.

위에서 생성한 데이터 셋을 출력하기 위해 반복문을 사용합니다. 안쪽 반복은 각 배치를 출력하기 위한 것이고 바깥의 for 문은 epoch을 위한 것입니다. epoch은 데이터 셋을 구성하는 모든 배치를 반환하는 것을 의미하는 것으로 아래의 3은 3번의 epoch을 실행하는 것입니다.

print(x)

Elements of ds_tensors:

tf.Tensor([25 9], shape=(2,), dtype=int64)

tf.Tensor([81 0], shape=(2,), dtype=int64)

tf.Tensor([ 1 64], shape=(2,), dtype=int64)

tf.Tensor([ 4 49], shape=(2,), dtype=int64)

tf.Tensor([36 16], shape=(2,), dtype=int64)

# 1 epoch

tf.Tensor([16 81], shape=(2,), dtype=int64)

tf.Tensor([ 0 49], shape=(2,), dtype=int64)

tf.Tensor([ 9 64], shape=(2,), dtype=int64)

tf.Tensor([ 1 25], shape=(2,), dtype=int64)

tf.Tensor([36 4], shape=(2,), dtype=int64)

# 2 epoch

tf.Tensor([0 9], shape=(2,), dtype=int64)

tf.Tensor([49 25], shape=(2,), dtype=int64)

tf.Tensor([ 4 64], shape=(2,), dtype=int64)

tf.Tensor([ 1 16], shape=(2,), dtype=int64)

tf.Tensor([36 81], shape=(2,), dtype=int64)

# 2 epoch

위 결과는 batch를 2개씩으로 지정한 결과입니다. 즉, 1 epoch는 5개의 배치로 구성되어 있습니다. 이러한 반복중에 1 epoch를 2개로 구성하고자 한다면 .taken() 메서드를 사용합니다.

print(x)

Elements of ds_tensors:

tf.Tensor([9 0], shape=(2,), dtype=int64)

tf.Tensor([36 25], shape=(2,), dtype=int64)

# 1 epoch

tf.Tensor([ 4 25], shape=(2,), dtype=int64)

tf.Tensor([49 0], shape=(2,), dtype=int64)

# 2 epoch

tf.Tensor([64 16], shape=(2,), dtype=int64)

tf.Tensor([49 9], shape=(2,), dtype=int64)

# 3 epoch

모형에 검증 데이터를 사용한 경우는 다음과 같습니다.

Epoch 1/5 32/32 [==============================] - 0s 2ms/step - loss: 518.8963 - accuracy: 0.1030 - val_loss: 706.1051 - val_accuracy: 0.1100

Epoch 2/5 32/32 [==============================] - 0s 2ms/step - loss: 760.4556 - accuracy: 0.1010 - val_loss: 1000.0045 - val_accuracy: 0.0900

Epoch 3/5 32/32 [==============================] - 0s 2ms/step - loss: 912.7241 - accuracy: 0.1010 - val_loss: 766.6218 - val_accuracy: 0.0700

Epoch 4/5 32/32 [==============================] - 0s 2ms/step - loss: 715.8406 - accuracy: 0.1070 - val_loss: 784.7622 - val_accuracy: 0.0600

Epoch 5/5 32/32 [==============================] - 0s 2ms/step - loss: 914.2879 - accuracy: 0.0930 - val_loss: 889.3065 - val_accuracy: 0.0700

<tensorflow.python.keras.callbacks.History at 0x7ff4845ae198 >

tf.data 데이터 셋을 사용한 학습

fit 메서드에 tf.data.Dataset 객체를 전달합니다.
tf.data에 의해 data와 label을 튜플로 구성합니다. 그러므로 fit() 메서드에 data 와 label을 구분하지 않습니다. 데이터의 전환과정에서 batch를 실시했으으로 별도의 인수를 전달하지 않아도 됩니다.
fit()메서드의 인수중 steps_per_per_epoch를 지정할 수 있습니다. 이 인수는 1 에포크에서 모형이 수행할 학습의 반복수 입니다. 예를들어 위 데이터의 경우 sample가 1000개이고 batch는 32입니다. 그러므로 1 에포크는 1000/32로 약 32번의 계산이 이루어집니다. 이것은 steps_per_per_epoch=1 또는 None과 동일합니다.
즉, $\text{steps_per_per_epoch=1}=\frac{\text{# of sample}}{{\text{# of batch}}$ 기본값은 None입니다. 이 값을 결정할 수 없을 경우는 None을 적용합니다. 또한 이 인수는 numpy 배열 데이터에는 적용되지 않습니다.

Epoch 1/10 30/30 [==============================] - 0s 1ms/step - loss: 312.5134 - accuracy: 0.0969

Epoch 2/10 1/30 [>.............................] - ETA: 0s - loss: 350.3676 - accuracy: 0.0938WARNING:tensorflow:Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches (in this case, 300 batches). You may need to use the repeat() function when building your dataset. 2/30 [=>............................] - 0s 4ms/step - loss: 320.8142 - accuracy: 0.1250

<tensorflow.python.keras.callbacks.History at 0x7ff484a4e278>

검증데이터 사용

Epoch 1/5 32/32 [==============================] - 0s 5ms/step - loss: 799.6232 - accuracy: 0.0910 - val_loss: 974.4749 - val_accuracy: 0.0700

Epoch 2/5 32/32 [==============================] - 0s 2ms/step - loss: 928.9986 - accuracy: 0.0950 - val_loss: 874.6193 - val_accuracy: 0.0900

Epoch 3/5 32/32 [==============================] - 0s 2ms/step - loss: 886.2599 - accuracy: 0.1010 - val_loss: 807.2249 - val_accuracy: 0.0900

Epoch 4/5 32/32 [==============================] - 0s 2ms/step - loss: 779.3281 - accuracy: 0.1120 - val_loss: 599.2501 - val_accuracy: 0.0900

Epoch 5/5 32/32 [==============================] - 0s 2ms/step - loss: 1077.1622 - accuracy: 0.0810 - val_loss: 1235.4340 - val_accuracy: 0.0900

< tensorflow.python.keras.callbacks.History at 0x7ff48252ef98 >

[Linear Algebra] 유사변환(Similarity transformation)

유사변환(Similarity transformation) n×n 차원의 정방 행렬 A, B 그리고 가역 행렬 P 사이에 식 1의 관계가 성립하면 행렬 A와 B는 유사행렬(similarity matrix)이 되며 행렬 A를 가역행렬 P와 B로 분해하는 것을 유사 변환(similarity transformation) 이라고 합니다. $$\tag{1} A = PBP^{-1} \Leftrightarrow P^{-1}AP = B $$ 식 2는 식 1의 양변에 B의 고유값을 고려한 것입니다. \begin{align}\tag{식 2} B - \lambda I &= P^{-1}AP – \lambda P^{-1}P\\ &= P^{-1}(AP – \lambda P)\\ &= P^{-1}(A - \lambda I)P \end{align} 식 2의 행렬식은 식 3과 같이 정리됩니다. \begin{align} &\begin{aligned}\textsf{det}(B - \lambda I ) & = \textsf{det}(P^{-1}(AP – \lambda P))\\ &= \textsf{det}(P^{-1}) \textsf{det}((A – \lambda I)) \textsf{det}(P)\\ &= \textsf{det}(P^{-1}) \textsf{det}(P) \textsf{det}((A – \lambda I))\\ &= \textsf{det}(A – \lambda I)\end{aligned}\\ &\begin{aligned}\because \; \textsf{det}(P^{-1}) \textsf{det}(P) &= \textsf{det}(P^{-1}P)\\ &= \textsf{det}(I)\end{aligned}\end{align} 유사행렬의 특성 유사행렬인 두 정방행렬 A와 B는 'A ~ B' 와 같

sons dataStory

이 블로그 검색

[ML] 결정트리(Decision Tree) 모델