케라스 코어 시작하기 (Getting started with Keras Core)#

저자: fchollet
역자: 조용은
생성 날짜: 2023/07/10
마지막 수정: 2023/07/10
번역 일자: 2023/10/15
설명: 새로운 멀티 백엔드 케라스와의 첫 만남.

소개 (Introduction)#

케라스 코어는 TensorFlow, JAX, 그리고 PyTorch와 상호교환할 수 있게 작동하는 Keras API의 완전한 구현입니다. 이 노트북은 여러분에게 케라스 코어의 주요 작업 흐름을 안내할 것입니다.

먼저, 케라스 코어를 설치해봅시다:

!pip install -q keras-core

설정 (Setup)#

우리는 여기에서 JAX 백엔드를 사용할 것입니다 – 하지만 아래의 문자열을 "tensorflow" 또는 "torch"로 수정하고 “Restart runtime”을 누르면, 전체 노트북은 동일하게 실행될 것입니다! 이 전체 가이드는 백엔드에 구애받지 않습니다.

import numpy as np
import os

os.environ["KERAS_BACKEND"] = "jax"

# 백엔드가 구성된 후에만 keras_core를 가져와야 합니다.
# 패키지를 가져온 후에는 백엔드를 변경할 수 없습니다.

import keras_core as keras

첫 번째 예제: MNIST 컨볼루션 네트워크 (A first example: A MNIST convnet)#

ML의 Hello World부터 시작해보겠습니다: 컨볼루션 네트워크을 훈련시켜 MNIST 숫자를 분류합니다.

다음은 데이터입니다:

# 데이터를 로드하고 훈련 세트와 테스트 세트로 나눕니다
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 이미지를 [0, 1] 범위로 스케일링합니다
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# 이미지가 (28, 28, 1)의 형태를 가지고 있는지 확인합니다
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print("y_train shape:", y_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")

다음은 우리의 모델입니다.

케라스가 제공하는 다양한 모델 빌드 옵션은 다음과 같습니다:

The Sequential API (아래에서 사용하는 방법)
The Functional API (가장 일반적으로 사용)
Writing your own models yourself via subclassing (고급 사용 사례를 위한)

# 모델 매개변수들
num_classes = 10
input_shape = (28, 28, 1)

model = keras.Sequential(
    [
        keras.layers.Input(shape=input_shape),
        keras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        keras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        keras.layers.MaxPooling2D(pool_size=(2, 2)),
        keras.layers.Conv2D(128, kernel_size=(3, 3), activation="relu"),
        keras.layers.Conv2D(128, kernel_size=(3, 3), activation="relu"),
        keras.layers.GlobalAveragePooling2D(),
        keras.layers.Dropout(0.5),
        keras.layers.Dense(num_classes, activation="softmax"),
    ]
)

다음은 우리 모델의 요약입니다:

model.summary()

compile() 메서드를 사용하여 옵티마이저, 손실 함수 및 모니터링할 평가지표들을 지정합니다. JAX 및 TensorFlow 백엔드에서 XLA 컴파일이 기본적으로 활성화되어 있음을 주의하세요.

model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(),
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    metrics=[
        keras.metrics.SparseCategoricalAccuracy(name="acc"),
    ],
)

모델을 학습하고 평가해 봅시다. 훈련 중에 보지 않은 데이터에 대한 일반화를 모니터링하기 위해 데이터의 15%를 검증 분할로 따로 떼어 놓겠습니다.

batch_size = 128
epochs = 20

callbacks = [
    keras.callbacks.ModelCheckpoint(filepath="model_at_epoch_{epoch}.keras"),
    keras.callbacks.EarlyStopping(monitor="val_loss", patience=2),
]

model.fit(
    x_train,
    y_train,
    batch_size=batch_size,
    epochs=epochs,
    validation_split=0.15,
    callbacks=callbacks,
)
score = model.evaluate(x_test, y_test, verbose=0)

훈련 중에 매 에폭의 끝에서 모델을 저장했습니다. 다음과 같이 모델을 가장 최근 상태로도 저장할 수 있습니다:

model.save("final_model.keras")

그리고 다음과 같이 다시 불러올 수 있습니다.

model = keras.saving.load_model("final_model.keras")

다음으로, predict()를 사용하여 클래스 확률의 예측을 조회할 수 있습니다:

predictions = model.predict(x_test)

기본 사항은 이것으로 끝입니다!

크로스-프레임워크 커스텀 컴포넌트 작성(Writing cross-framework custom components)#

케라스 코어는 동일한 코드베이스로 TensorFlow, JAX, PyTorch에서 작동하는 커스텀 레이어, 모델, 평가지표, 손실함수, 옵티마이저를 작성할 수 있게 해줍니다. 먼저 커스텀 레이어를 살펴봅시다.

tf.keras에서 커스텀 레이어를 작성하는 방법을 이미 알고 있다면 — 좋습니다, 아무것도 수정할 필요 없습니다. 하나만 제외하고: tf 네임스페이스에서 함수를 사용하는 대신 keras.ops.*에서 함수를 사용해야 합니다.

keras.ops 네임스페이스는 다음을 포함합니다.:

NumPy API의 구현, 예를 들어 keras.ops.stack 또는 keras.ops.matmul.
NumPy에 없는 신경망 특정 작업의 집합, 예를 들어 keras.ops.conv 또는 keras.ops.binary_crossentropy.

모든 백엔드에서 작동하는 커스텀 Dense 레이어를 만들어 봅시다:

class MyDense(keras.layers.Layer):
    def __init__(self, units, activation=None, name=None):
        super().__init__(name=name)
        self.units = units
        self.activation = keras.activations.get(activation)

    def build(self, input_shape):
        input_dim = input_shape[-1]
        self.w = self.add_weight(
            shape=(input_dim, self.units),
            initializer=keras.initializers.GlorotNormal(),
            name="kernel",
            trainable=True,
        )

        self.b = self.add_weight(
            shape=(self.units,),
            initializer=keras.initializers.Zeros(),
            name="bias",
            trainable=True,
        )

    def call(self, inputs):
        # 케라스 연산을 사용하여 백엔드에 구애받지 않는 레이어/평가지표/등을 생성합니다.
        x = keras.ops.matmul(inputs, self.w) + self.b
        return self.activation(x)

다음으로, keras.random 네임스페이스에 의존하는 커스텀 Dropout 레이어를 만들어 봅시다:

class MyDropout(keras.layers.Layer):
    def __init__(self, rate, name=None):
        super().__init__(name=name)
        self.rate = rate
        # RNG 상태 관리를 위해 seed_generator를 사용합니다.
        # 이것은 상태 요소이며 seed 변수는
        # `layer.variables`의 일부로 추적됩니다.
        self.seed_generator = keras.random.SeedGenerator(1337)

    def call(self, inputs):
        # 랜덤 연산을 위해 keras_core.random을 사용합니다.
        return keras.random.dropout(inputs, self.rate, seed=self.seed_generator)

다음으로, 두 커스텀 레이어를 사용하는 커스텀 서브클래스 모델을 작성해봅시다:

class MyModel(keras.Model):
    def __init__(self, num_classes):
        super().__init__()
        self.conv_base = keras.Sequential(
            [
                keras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
                keras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
                keras.layers.MaxPooling2D(pool_size=(2, 2)),
                keras.layers.Conv2D(128, kernel_size=(3, 3), activation="relu"),
                keras.layers.Conv2D(128, kernel_size=(3, 3), activation="relu"),
                keras.layers.GlobalAveragePooling2D(),
            ]
        )
        self.dp = MyDropout(0.5)
        self.dense = MyDense(num_classes, activation="softmax")

    def call(self, x):
        x = self.conv_base(x)
        x = self.dp(x)
        return self.dense(x)

이를 컴파일하고 학습시켜봅시다:

model = MyModel(num_classes=10)
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(),
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    metrics=[
        keras.metrics.SparseCategoricalAccuracy(name="acc"),
    ],
)

model.fit(
    x_train,
    y_train,
    batch_size=batch_size,
    epochs=1,  # 빠르게 처리하기 위해
    validation_split=0.15,
)

임의의 데이터 소스에서 모델 학습#

하기 (Training models on arbitrary data sources) 모든 케라스 모델은 사용하는 백엔드에 상관없이 다양한 데이터 소스에서 훈련 및 평가할 수 있습니다. 이에는 다음이 포함됩니다:

NumPy 배열
Pandas 데이터프레임
TensorFlow tf.data.Dataset 객체
PyTorch DataLoader 객체
Keras PyDataset 객체

이들은 TensorFlow, JAX, 또는 PyTorch를 케라스 백엔드로 사용하든 상관없이 모두 작동합니다.

PyTorch DataLoaders로 시도해봅시다:

import torch

# TensorDataset 생성
train_torch_dataset = torch.utils.data.TensorDataset(
    torch.from_numpy(x_train), torch.from_numpy(y_train)
)
val_torch_dataset = torch.utils.data.TensorDataset(
    torch.from_numpy(x_test), torch.from_numpy(y_test)
)

# DataLoader 생성
train_dataloader = torch.utils.data.DataLoader(
    train_torch_dataset, batch_size=batch_size, shuffle=True
)
val_dataloader = torch.utils.data.DataLoader(
    val_torch_dataset, batch_size=batch_size, shuffle=False
)

model = MyModel(num_classes=10)
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(),
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    metrics=[
        keras.metrics.SparseCategoricalAccuracy(name="acc"),
    ],
)
model.fit(train_dataloader, epochs=1, validation_data=val_dataloader)

이제 tf.data로도 시도해 봅시다:

import tensorflow as tf

train_dataset = (
    tf.data.Dataset.from_tensor_slices((x_train, y_train))
    .batch(batch_size)
    .prefetch(tf.data.AUTOTUNE)
)
test_dataset = (
    tf.data.Dataset.from_tensor_slices((x_test, y_test))
    .batch(batch_size)
    .prefetch(tf.data.AUTOTUNE)
)

model = MyModel(num_classes=10)
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(),
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    metrics=[
        keras.metrics.SparseCategoricalAccuracy(name="acc"),
    ],
)
model.fit(train_dataset, epochs=1, validation_data=test_dataset)

추가 학습 자료 (Further reading)#

이것으로 케라스 코어의 새로운 멀티 백엔드 기능에 대한 짧은 개요를 마칩니다. 다음으로 이것들을 배울 수 있을 것입니다 :

`fit()`에서 일어나는 것을 어떻게 커스터마이징할까요?#

비표준 훈련 알고리즘을 직접 구현하려고 하지만 (예: GAN 훈련 루틴) 여전히 fit()의 힘과 사용성을 누리고 싶다면, fit()을 임의의 사용 사례를 지원하도록 커스터마이징하는 것이 정말 쉽습니다.

TensorFlow에서 fit()에서 일어나는 것을 커스터마이징하는 방법 -JAX에서 fit()에서 일어나는 것을 커스터마이징하는 방법 -PyTorch에서 fit()에서 일어나는 것을 커스터마이징하는 방법

커스텀 훈련 루프 작성 방법 (How to write custom training loops)#

TensorFlow에서 처음부터 훈련 루프 작성하는 방법 -JAX에서 처음부터 훈련 루프 작성하는 방법 -PyTorch에서 처음부터 훈련 루프 작성하는 방법

훈련 분배 방법 (How to distribute training)#

이 라이브러리를 즐기세요! 🚀

케라스 코어 시작하기 (Getting started with Keras Core)

내용