[패스트캠퍼스 수강 후기] 인공지능강의 100% 환급 챌린지 5회차 미션

Optimizer 및 Training (keras)

Loss Function

cross entropy
클레스가 2개인경우 binary_crossentropy 3개 이상인 경우 categorical_crossentropy

# one-hot encoding을 하지 않았을때 
tf.keras.losses.sparse_categorical_crossentropy
# on-hot encoding을 했을 떄
tf.keras.losses.categorical_crossentropy
# 클래스가 2개일때
tf.keras.losses.binary_crossentropy

Metrics

모델을 평가하는 방법
Accuracy 사용 정확도를 측정

optimizer

sdg, adam, rmsprop 등

사용한 모델

loss = tf.keras.losses.sparse_categorical_crossentropy
metrics = ['accuracy']
optm = tf.keras.optimizers.Adam()

model.compile(optimizer=optm, 
              loss = loss, 
              metrics = [metrics]) #리스트로 여러개의 metric을 담을 수 있음

데이터준비

 # 차원확장 (그레이스케일임에도 불구하고 층이 없음)
train_x = train_x[..., tf.newaxis]
test_x = test_x[..., tf.newaxis]
 # rescalling (학습이 튀지 않게끔 0~1사이로)
train_x = train_x /255
test_x = test_x /255

Training

num_epoches = 1 # 몇번 완주할 것인지
batch_size = 32 # 한번에 들어갈 데이터개수
 #shuffle train 할때는 셔플할것. 
model.fit(train_x,train_y,
         batch_size = batch_size, 
          shuffle= True, 
          epochs=num_epoches)

Expert 버젼

데이터셋에 담아서 하는 방법
솔직히... 이게 더 어려워보이고 왜 이게 좋은지 모르겠다

train_ds = tf.data.Dataset.from_tensor_slices((train_x, train_y))
train_ds = train_ds.shuffle(1000) #버퍼사이즈 1000이 적절하다고 한다
train_ds = train_ds.batch(32) #배치사이즈 설정

test_ds = tf.data.Dataset.from_tensor_slices((test_x, test_y))
test_ds = test_ds.batch(32) #배치사이즈 설정

시각화

for image, label in train_ds.take(2): #take(2) 전체 데이터셋에서 2개만가져옴
    plt.title(label[0])
    plt.imshow(image[0, :, :,0],'gray')
    plt.show()

Training

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

 # loss를 평균값을 계산해서 보여줌, loss를 그대로 프린트하면 너무 널뛰기 때문에
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

 #train모드와 test모드를 별개로 작성 
@tf.function
def train_step(images, labels):
    with tf.GradientTape() as tape:
        predictions = model(images)
        loss = loss_object(labels, predictions)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

    train_loss(loss)
    train_accuracy(labels,predictions)

@tf.function
def test_step(images, labels):
    predictions = model(images)
    t_loss = loss_object(labels, predictions)

    train_loss(t_loss)
    train_accuracy(labels,predictions)

 #이전에 했던것처럼 출력 결과가 나오지 않으므로 직접 넣어줘야함 
for epoch in range(2):
    print('Start Training')
    for images, labels in train_ds:
        train_step(images, labels)

    for test_images, test_labels in test_ds:
        test_step(test_images, test_labels)

    template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss {}, Test Accuracy: {}'
    print(template.format(epoch+1, 
                          train_loss.result(),
                          train_accuracy.result() * 100, 
                          test_loss.result(), 
                          test_accuracy.result() * 100)) 

후기

expert 방법의 장점이 뭔지 알려주시면 좋을거 같은데 없어서 아쉬움
그냥 더 복잡한 방법으로정도밖에 모르겠음

딥러닝/인공지능 올인원 패키지 Online