✱ 핸즈온 머신러닝 13장 텐서플로를 사용한 데이터 적재와 전처리 ✱

대용량 데이터셋에서 텐서플로 모델을 훈련할 때는 텐서플로 자체의 데이터 로드 및 전처리 API인 tf.data를 사용하는 것이 더 좋다.

매우 효율적으로 데이터를 로드하고 전처리할 수 있으며, 멀티스레드와 큐를 사용하여 여러 파일에서 동시에 읽고, 샘플을 셔플링하거나 배치로 만드는 등의 작업을 수행할 수 있다.

GPU 또는 TPU가 훈련을 위해 현재 데이터 배치를 바쁘게 처리하는 동안 동시에 여러 CPU 코어에 걸쳐 다음 데이터 배치를 로드하고 전처리할 수 있다.

 

케라스는 모델에 포함시킬 수 있는 전처리 층을 제공하므로, 모델을 제품 환경에 배포할 때 다른 전처리 코드를 추가할 필요 없이 원시 데이터를 직접 주입할 수 있다.

또한 훈련 중에 사용된 전처리 코드와 제품 환경에서 사용되는 전처리 코드가 달라져 훈련/서빙의 차이를 일으키는 위험을 제거할 수 있다.

---

13.1 데이터 API

전체적인 tf.data API의 중심에는 tf.data.Dataset 개념이 있으며, 이는 데이터 항목의 시퀀스를 나타낸다.

일반적으로 디스크에서 데이터를 점진적으로 읽는 데이터셋을 사용한다.

하지만 간단히 tf.data.Dataset.from_tensor_slices()를 사용해 간단한 텐서로 데이터셋을 생성할 수 있다.

import tensorflow as tf
X = tf.range(10) # 임의의 데이터 텐서
dataset = if.data.Dataset.from_tensor_slices(X)
dataset
# <_TensorSliceDataset element_spec=TensorSpec(shape=(), dtype=tf.int32, name=None)>

from_tensor__slices() 함수는 텐서를 받아 첫 번째 차원을 따라 X의 각 원소가 아이템으로 표현되는 tf.data.Dataset을 만든다.

즉, 텐서 0, 1, 2, ..., 9에 해당하는 10개의 아이템을 가진다. tf.data.Dataset.range(10)으로 만든 데이터셋과 동일하다.

dataset = tf.data.Dataset.from_tensor_slices(tf.range(10))
for item in datasets:
... print(item)
...
# tf.Tensor(0, shape=(), dtype=int32)
# tf.Tensor(1, shape=(), dtype=int32)
# [...]
# tf.Tensor(9, shape=(), dtype=int32)

데이터셋의 아이템을 순회할 수 있다.

X_nested = {"a": ([1, 2, 3], [4, 5, 6]), "b": [7, 8, 9]}
dataset = tf.data.dataset.from_tensor_slices(X_nested)
for item in dataset:
... print(item)
...
# {'a': («tf.Tensor: [..J-=1>, <tf. Tensor: [..J-4>), 'b': <tf.Tensor: [..1=7)}
# {'a': (<tf. Tensor: [...]=2>, <tf.Tensor: [...]=5>), 'b': <tf.Tensor: [..]=8>}
# {'a': (<tf.Tensor: [...]=3>, <tf.Tensor: [...]=6>), 'b': <tf.Tensor: [..]=9>}

13.1.1 연쇄 변환

데이터셋이 준비되면 변환 메서드를 호출하여 여러 종류의 변환을 수행할 수 있다.

메서드는 새로운 데이터셋을 반환하므로 변환 메서드를 연결할 수 있다.

dataset = dataset.repeat(3).batch(7)
for item in dataset:
... print(item)
...
# tf. Tensor ([0 1 2 3 4 5 6], shape=(7,), dtype=int32)
# tf. Tensor ([7 8 9 0 1 2 3], shape=(7,), dtype=int32)
# tf. Tensor ([4 5 6 7 8 9 0], shape=(7,), dtype=int32)
# tf. Tensor ([1 2 3 4 5 6 7], shape=(7,), dtype=int32)
# tf. Tensor ([8 9], shape=(2,), dtype=int32)

원본 데이터셋에서 repeat() 메서드를 호출하면 원본 데이터셋의 아이템을 세 차례 반복하는 새로운 데이터셋을 반환한다.

매개변수 없이 메서드를 호출하면 무한반복된다.

새로운 데이터셋에서 batch() 메서드를 호출하면 다시 새로운 데이터셋이 만들어진다.

이전 데이터셋의 아이템을 7개씩 그룹으로 묶는다. 

마지막 데이터셋의 아이템을 순홚나다.

batch() 메서드를 drop_remainder=True로 호출하면 길이가 모자란 마지막 배치를 버리고 모든 배치를 동일한 크기로 맞춘다.

 

dataset = dataset.map(lambda x: x * 2) # x는 하나의 배치이다
for item in dataset:
... print(item)
...
# tf. Tensor ([ 0 2 4 6 8 10 12], shape=(7,), dtype=int32)
# tf. Tensor ([14 16 18 0 2 4 6], shape=(7,), dtype=int32)
# [...]

map() 메서드를 호출하여 아이템을 변환할 수도 있으며 어떠한 전처리 작업도 적용할 수 있다.

이미지 크기 변환이나 회전 같은 복잡한 계산을 포함하기에 여러 스레드로 나누어 속도를 높이는 것이 좋은데, 이를 위해 num_parallel_calss 매개변수에 실행할 스레드 개수나 tf.data.AUTOTUNE을 지정할 수 있다.

map() 메서드에 전달하는 함수는 텐서플로 함수로 변환 가능해야 한다.

dataset = dataset.filter(lambda x: tf.reduce_sum(x) > 50)
for item in dataset:
... print(item)
...
# tf. Tensor ([14 16 18 0 2 4 6], shape=(7,), dtype=int32)
# tf. Tensor([ 8 10 12 14 16 18 0], shape=(7,), dtype=int32)
# tf. Tensor ([ 2 4 6 8 10 12 14], shape=(7,), dtype=int32)

filter() 메서드를 사용하여 데이터셋을 필터링할 수 있다.

for item in dataset.take(2):
... print(item)
...
# tf. Tensor([14 16 18 0 2 4 6], shape=(7,), dtype=int32)
# tf. Tensor ([ 8 10 12 14 16 18 0], shape=(7,), dtype=int32)

take() 메서드를 사용해 데이터셋의 몇 개의 아이템만 확인할 수도 있다.

13.1.2 데이터 셔플링

shuffle() 메서드는 먼저 원본 데이터셋의 처음 아이템을 buffer_size 개수만큼 추출하여 버퍼에 채운다.

그다음 새로운 아이템이 요청되면 이 버퍼에서 랜덤하게 하나를 꺼내 반홚나다.

그리고 원본 데이터셋에서 새로운 아이템을 추출하여 비워진 버퍼를 채운다.

원본 데이터셋의 모든 아이템이 사용될 때까지 반복한다. 

그다음엔 버퍼가 비워질 때까지 계속하여 랜덤하게 아이템을 반환한다.

 

이 메서드를 사용하려면 버퍼 크기를 지정해야 하며 셔플링 효과 감소를 막기 위해 충분히 크게 해야 한다.

다만 보유한 메모리 크기를 넘지 않아야 하며, 충분한 메모리가 있더라도 버퍼 크기가 데이터셋 크기보다 클 필요는 없다.

프로그램을 실행할 때마다 셔플링되는 순서를 동일하게 만들려면 랜덤 시드를 부여한다.

dataset = tf.data.Dataset.range(10).repeat(2)
dataset = dataset.shuffle(buffer_size=4, seed=42).batch(7)
for item in dataset:
... print(item)
...
# tf. Tensor ([1 4 2 3 5 0 6], shape=(7,), dtype=int64)
# tf. Tensor([9 8 2 0 3 1 4], shape=(7,), dtype=int64)
# tf. Tensor ([5 7 9 6 7 8], shape=(6,), dtype=int64)

 

메모리 용량보다 큰 대규모 데이터셋은 버퍼가 데이터셋에 비해 작기 때문에 간단한 셔플링 버퍼 방식으로 충분하지 않으며, 원본 데이터 자체를 서꺼어야 한다.

원본 데이터가 섞여 있더라도 에포크마다 한 번 더 섞어, 동일 순서가 반복되어 모델에 편향이 추가되는 것을 막는다.

원본 데이터를 여러 파일로 나눈 다음 훈련하는 동안 랜덤으로 읽는 방법도 있다. 

파일 여러 개를 랜덤으로 선택하고 파일에서 동시에 읽은 레코드를 돌아가면서 반환한다.

그런 다음 shuffle() 메서드를 사용해 그 위해 셔플링 버퍼를 추가한다.

13.1.3 여러 파일에서 한 줄씩 번갈아 읽기

filepath_dataset = tf.data.Dataset.list_files(train_filepaths, seed=42)

파일 경로가 담긴 데이터셋을 만든다.

기본적으로 list_files() 함수는 파일 경로를 섞은 데이터셋을 반환한다. (shuffle=False로 지정해 막을 수 있다)

n_readers = 5
dataset = filepath_dataset.interleave(
    lambda filepath: tf.data.TextLineDataset(filepath).skip(1),
    cycle_length=n_readers)

interleave() 메서드를 호출하여 한 번에 다섯 개의 파일을 한 줄식 번갈아 읽는다.

각 파일의 첫 번째 줄은 열 이름이므로 skip() 메서드를 사용해 건너뛴다.

 

interleave() 메서드는 filepath_dataset에 있는 다섯 개의 파일 경로에서 데이터를 읽는 데이터셋을 만든다.

전달한 함수를 각 파일에 대해 호출하여 새로운 데이터셋을 만든다.

이 단계에는 파일 경로 데이터셋, 인터리브 데이터셋, 인터리브 데이터셋에 의해 내부적으로 생성된 5개의 textLineDataset이 있다.

인터리브 데이터셋을 반복문에 사용하면 다섯 개의 TextLineDataset을 순회한다. 모든 데이터셋이 아이템이 소진될 때까지 한 번에 한 줄씩 읽는다.

그러고 나서 filepath_dataset에서 다음 다섯 개의 파일 경로를 가져오고 동일한 방식으로 한 줄씩 읽는다. 모든 파일 경로가 소진될 때까지 계속한다.

인터리빙이 잘 작동하려면 파일의 길이가 동일한 것이 좋다.

 

기본적으로 interleave() 메서드는 병렬화를 사용하지 않아 각 파일에서 한 번에 한 줄씩 순서대로 읽는다. 

여러 파일에서 병렬로 읽고 싶다면 interleave() 메서드의 num_parallel_callls 매개변수에 원하는 스레드 개수를 지정한다.

이 매개변수를 tf.data.AUTOTUNE으로 지정하면 텐서플로가 가용한 CPU를 기반으로 동적으로 적절한 스레드 개수를 선택할 수 있다.

for line in dataset.take(5):
... print(line)
...
# tf.Tensor(b' 4.5909,16.0, [...],33.63,-117.71,2.418', shape=(), dtype=string)
# tf.Tensor(b'2.4792,24.0, [..],34. 18,-118.38,2.0',, shape=(), dtype=string)
# tf.Tensor(b'4.2708,45.0, [...],37.48, -122.19,2.67'., shape=(), dtype=string)
# tf.Tensor(b'2.1856,41.0, [...1,32.76,-117.12,1.205*, shape=(), dtype=string)
# tf.Tensor(b'4. 1812,52.0, [..1,33.73, -118.31,3.215'., shape=(), dtype=string)

13.1.4 데이터 전처리

X_mean, X_std = [...]
n_inputs = 8

def parse_csv_line(line):
    defs = [0.] * n_inputs + [tf.constant([], dtype=tf.float32)]
    fields = tf.io.decode_csv(line, recod_defaults=def)
    return tf.stack(fields[:-1]), tf.stack(fields[-1:])
    
def preprocess(line):
    x, y = parse_csv_line(line)
    return (x - X_mean) / X_std, y

parse_csv_line() 함수는 CSV 한 라인을 받아 파싱한다. 

tf.io.decode_csv() 함수는 열마다 한 개씩 스칼라 텐서의 리스트를 반환한다. 1D 텐서 배열을 반환해야 하므로 마지막 열(타깃)을 제외하고 모든 텐서에 대해 tf.stack() 함수를 호출한다. 이 함수는 모든 텐서를 쌓아 1D 배열을 만든다. 그다음 타깃값에도 동일하게 적용하면 스칼라 텐서가 아니라 하나의 값을 가진 1D 텐서가 된다. 

따라서 parse_csv_line() 함수가 완료되면 입력 특성과 타깃이 반환된다.

preprocess() 함수는 parse_csv_line() 함수를 호출하고, 입력 특성에서 평균을 빼고 표준 편차로 나누어 스케일을 조정한다. 그다음 스케일이 조정된 특성과 타깃을 담은 튜플을 반환한다.

preprocess(b' 4.2083,44.0,5.3232,0.9171,846.0,2.3370,37.47,-122.2,2.782')
# (<tf. Tensor: shape=(8,), dtype=float32, numpy=
# array([ 0.16579159, 1.216324, -0.05204564, -0.39215982, -0.5277444 ,
#        -0.2633488, 0.8543046 , -1.3072058 ], dtype=float32)>,
# ‹tf. Tensor: shape=(1,), dtype=float32, numpy=array([2.782], dtype=float32)>)

13.1.5 데이터 적재와 전처리 합치기

def csv_reader_dataset(filepaths, n_readers=5, n_read_threads=None,
                       n_parse_threads=5, shuffle_buffer_size=10_000, seed=42,
                       batch_size=32):
    dataset = tf.data.Dataset.list_files(filepaths, seed=seed)
    dataset = dataset.interleave(
        lambda filepath: tf.data.TextLineDataset(filepath).skip(1),
        cycle_legnth=n_readers, num_parallel_calls=n_read_threads)
    dataset = dataset.map(preprocess, num_parallel_calls=n_parse_threads)
    dataset = dataset.shuffle(shuffle_buffer_size, seed=seed)
    return dataset.batch(batch_size).prefetch(1)

13.1.6 프리페치

csv_reader_dataset() 함수 마지막에 prefetch(1)을 호출하면 데이터셋은 항상 한 배치가 미리 준비되도록 최선을 다한다.

훈련 알고리즘이 한 배치로 작업을 하는 동안 이 데이터셋이 동시에 다음 배치를 준비한다.

interleave()와 map() 메서드를 호출할 때 num_parallel_calls 매개변수를 지정하여 멀티스레드로 데이터를 적재하고 전처리하면, 여러 개의 CPU 코어를 활용해서 GPU에서 훈련 스텝을 수행하는 것보다 짧은 시간 안에 하나의 배치 데이터를 준비할 수 있을 것이다. 

13.1.7 케라스와 데이터셋 사용하기

train_set = csv_reader_dataset(train_filepaths)
valid_set = csv_reader_dataset(valid_filepaths)
test_set = csv_reader_dataset(test_filepathhs)

훈련 세트는 각 에포크마다 셔플된다.

model = tf.keras.Sequential([...])
model.compile(loss="mse", optimizer="sgd")
model.fit(train_set, validation_data=valid_set, epochs=5)

케라스 모델으 만들고 이 데이터셋으로 훈련할 수 있다.

모델의 fit() 메서드를 호출할 때 X_train, y_train 대신에 train_set을 전달하고, validation_data=(X_valid, y_valid) 대신에 validation_data=valid_set을 전달한다.

fit() 메서드가 에포크마다 랜덤한 순서로 훈련 데이터셋을 한 번씩 반복한다.

test_mse = model.evaluate(test_set)
new_set = test_set.take(3) # 새로운 샘플이 3개 있다고 가정한다.
y_pred = model.predict(new_set) # 또는 넘파이 배열을 전달할 수 있다.

evaluate()와 predict() 메서드에 데이터셋을 전달할 수 있다. 

다른 세트와 달리 new_set은 레이블을 가지고 있지 않다. 포함되어 있더라도 케라스가 무시한다. 이런 모든 경우에 데이터셋 대신 넘파이 배열을 사용할 수 있다.

n_epochs = 5
for epoch in range(n_epochs):
    for X_batch, y_batch in train_set:
        [...] # 경사 하강법 단계를 수행한다

@tf.function
def train_one_epoch(model, optimizer, loss_fn, train_set):
    for X_batch, y_batch in train_set:
        with tf.GradientTape() as tape:
            y_pred = model(X_batch)
            main_loss = tf.reduce_mean(loss_fn(y_batch, y_pred))
            loss = tf.add_n([main_loss] + model.losses)
        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))
        
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
loss_fn = tf.keras.losses.mean_squared_error
for epoch in range(n_epochs):
    print("\rEpoch {}/{}.format(epoch + 1, n_epochs), end="")
    train_one_epoch(model, optimizer, loss_fn, train_set)

케라스에서 compile() 메서드의 steps_per_execution 매개변수를 사용하면 훈련에 사용하는 tf.function을 호출할 때마다 fit() 메서드가 처리할 배치의 수를 정의할 수 있다. 

---

13.2 케라스의 전처리 층

신경망에 사용할 데이터를 준비하려면 일반적으로 수치 특성 정규화, 범주형 특성이나 텍스트 인코딩, 이미지 자르기와 크기 조정 등의 작업이 필요하다.

훈련 데이터 파일을 준비할 때 넘파이, 판다스, 사이킷런과 같은 도구를 사용하여 미리 전처리를 수행할 수 있다.

데이터셋의 map() 메서드를 사용하여 데이터셋의 모든 원소에 전처리 함수를 적용하여 tf.data로 데이터를 로드하는 동안 바로 전처리할 수 있다.

모델 내부에 전처리 층을 직접 포함시켜 훈련 중에 즉시 모든 입력 데이터를 전처리한다. 그런 다음 제품 환경에서 동일한 전처리 층을 사용한다.

13.2.1 Normalization 층

norm_layer = tf.keras.layers.Normalization()
model = tf.keras.models.Sequential([
    norm_layer,
    tf.keras.layers.Dense(1)
])
model.compile(loss="mse", optimizer=tf.keras.optimizers.SGD(learning_rate=2e-3))
norm_layer.adapt(X_train)
model.fit(X_train, y_train, validation_data=(X_valid, y_valid), epochs=5)

 

전처리가 훈련되는 동안 즉시 적용되기 때문에 에포크마다 매번 수행된다 -> 훈련 속도를 느리게 한다.

훈련 전에 전체 훈련 세트를 한 번 전처리하는 것이 낫다. 이를 위해서는 사이킷런의 StandardScaler처럼 Normalization 층을 독립저긍로 사용할 수 있다.

norm_layer = tf.keras.layers.Normalization()
norm_layer.adapt(X_train)
X_train_scaled = norm_layer(X_train)
X_valid_scaled = norm_layer(X_valid)

model = tf.keras.models.Sequential([tf.keras.layers.Dense(1)])
model.compile(loss="mse", optimizer=tf.keras.optimizers.SGD(learning_rate=2e-3))
model.fit(X_train_scaled, y_train, epochs=5,
          validation_data=(X_valid_scaled, y_valid))

이 방식은 모델을 제품에 배포했을 때 입력을 전처리하지 못한다.

따라서 adapt() 메서드를 호출한 Normalization 층과 훈련된 모델을 포함하는 새로운 모델을 만들고 이 최종 모델을 제품에 배포한다.

final_model = tf.keras.Sequential([norm_layer, model])
X_new = X_test[:3] # 스케일을 조정하지 않은 새로운 샘플
y_pred = final_model(X_new) # 데이터를 전처리하고 예측을 만든다

케라스 전처리 층은 tf.data API와 함께 쓸 수 있다.

dataset = dataset.map(lambda X, y: (norm_layer(X), y))

케라스 전처리 층이 제공하는 것보다 더 많은 기능이 필요하다면 사용자 정의 층을 만들면 된다. 

import numpy as np

class MyNormalization(tf.keras.layers.Layer): 
    def adapt(self, X):
        self.mean_ = np.mean(X, axis=0, keepdims=True)
        self.std_ = np.std(X, axis=0, keepdims=True)
    
    def call(self, inputs):
        eps = tf.keras.backend.epsilon()
        return (inputs - self.mean_) / (self.std_ + eps)

13.2.2 Discretization 층

구간이라고 불리는 값 범위를 범주로 매핑하여 수치 특성을 범주형 특성으로 변환한다.

다중모드 분포를 가진 특성이나 타깃과의 관계가 매우 비선형적인 특성에 유용할 때가 있다.

age = tf.constant([[10.], [93.], [57.], [18.], [37.], [5.]])
discretize_layer = tf.keras.layers.Discretization(bin_boundaries=[18., 50.])
age_categories = discretize_layer(age)
age_categories
# ‹tf.Tensor:shape=(6, 1), dtype=int64, numpy=array([[0],[2],[2],[1],[1],[0]])>

discretize_layer = tf.keras.layers.Diescretization(num_bins=3)
discretize_layer.adapt(age)
age_categories = discretize_layer(age)
age_categories
# ‹tf.Tensor:shape=(6, 1), dtype=int64, numpy=array([[1],[2],[2],[1],[2],[0]])>

13.2.3 CategoryEncoding 층

범주의 개수가 적다면 원-핫 인코딩이 좋은 옵션이다.

onehot_layer = tf.keras.layers.CategoryEngoding(num_tokens=3)
onehot_layer(age_categories)
# <tf. Tensor: shape=(6, 3), dtype=float32, numpy=
# array([[0., 1., 0.1,
#        [0., 0., 1.],
         [0., 0., 1.],
         [0., 1., 0.],
         [0., 0., 1.],
         [1., 0., 0.]], dtype=float32)>

 

two_age_categories  = np.array([[1, 0], [2, 2], [2, 0]])
onehot_layer(two_age_categories)
# <tf.Tensor: shape=(3, 3), dtype=float32, numpy=
# array([[1., 1., 0.],
         [0., 0., 1.],
         [1., 0., 1.]], dtype=float32)>

동시에 한 개 이상의 범주형 특성을 인코딩하면 멀티-핫 인코딩을 수행한다.

각 범주가 얼마나 많이 등장하는지 알고 싶다면 CategoryEncoding 층을 만들 떄 output_mode="count"를 추가한다.

이렇게 하면 출력 텐서에 각 범주의 등장 횟수가 포함된다. 

 

멀티-핫 인코딩과 카운트 인코딩은 범주를 활성화한 특성이 어떤 것인지 알 수 없기 때문에 정보에 손실이 있다.

이를 피하려면 특성마다 별도로 원-핫 인코딩을 한 다음 출력을 합쳐야 한다.

범주 식별자가 겹치지 않도록 조정하면 동일한 결과를 얻을 수 있다.

onehot_layer = tf.keras.layers.CategoryEncoding(num_tokens=3 + 3)
onehot_layer(two_age_categories + [0, 3]) # 두 번째 특성에 3을 더한다
# <tf.Tensor: shape=(3, 6), dtype=float32, numpy=
# array([[0., 1., 0., 1., 0., 0.],
         [0., 0., 1., 0., 0., 1.],
         [0., 0., 1., 1., 0., 0.]], dtype=float32)>

처음 세 개의 열은 첫 번쨰 특성에 해당하고 마지막 세 개의 열은 두 번째 특성에 해당한다.

모델에 주입할 특성의 개수를 증가시키기 떄문에 모델 파라미터가 더 필요해진다.

13.2.4 StringLookup 층

cities = ["Auckland", "Paris", "Paris", "San Francisco"]
str_lookup_layer = tf.keras.layers.StringLookup()
str_lookup_layer.adapt(cities)
str_lookup_layer([["Paris"], ["Auckland"], ["Auckland"], ["Montreal"]])
# <tf.Tensor: shape=(4, 1), dtype=int64, numpy=array([[1], [3], [3], [0]])>

만저 StringLookup층을 만들고 adapt() 메서드에 데이터를 전달하여 세 개의 고유한 범주를 찾는다.

그런 다음 이 층을 사용해 몇 개의 도시를 인코딩하며 기본적으로 정수로 인코딩된다. 알 수 없는 범주는 0으로 매핑된다.

이미 알고 있는 범주는 가장 자주 등장하는 범주에서 드물게 등장하는 범주순으로 1부터 매핑된다.

 

str_lookup_layer = tf.keras.layers.StringLookup(output_mode="one-hot")
str_lookup_layer.adapt(cities)
str_lookup_layer([["Paris"], ["Auckland"], ["Auckland"], ["Montreal"]])
# <tf.Tensor: shape=(4, 4), dtype=float32, numpy=
# array([[0., 1., 0., 0.],
         [0., 0., 0., 1.],
         [0., 0., 0., 1.],
         [1., 0., 0., 0.]], dtype=float32)>

StringLookup 층을 만들 때 output_mode="one_hot"으로 지정하면 정수 대신 범주마다 원-핫 벡터를 출력한다.

 

훈련 세트가 매우 크면 훈련 세트에서 랜덤하게 일부를 추출하여 adapt() 메서드에 전달하는 것이 편리할 수 있다. 이런 경우 일부 드문 범주를 놓칠 수 있는데 이를 피하기 위해 num_odd_indices를 1보다 큰 정수로 지정할 수 있다. 이 값은 OOV 버킷 개수이다.

알 수 없는 범주는 해시 함수를 사용해 OOV 버킷 중 하나로 랜덤하게 매핑될 것이다.

이렇게 함녀 적어도 드문 범주 중 일부를 구별할 수 있을 것이다. 

str_lookup_layer = tf.keras.layers.StringLookup(num_oov_indices=5)
str_lookup_layer.adapt(cities)
str_lookup_layer([["Paris"], ["Auckland"], ["Foo"], ["Bar"], ["Baz"]])
# <tf.Tensor: shape=(4, 10>, dtype=int64, numpy=array([[5], [7], [4], [3], [4]])>

알 수 없는 범주가 OOV 버킷 중 하나에 매핑될 때 다른 범주가 같은 버킷에 매핑되어 모델이 둘을 구분할 수 없는 해싱 충돌이 발생할 수 있다.  -> OOV 버킷의 수를 늘려 위험을 줄인다.

 

범주르 ㄹ랜덤하게 버킷에 매핑하는 아이디어를 해싱 트릭이라 한다. 

13.2.5 Hashing 층

범주마다 해시를 계산하고 버킷(또는 구간) 개수로 나눈 나머지를 구한다. 이 매핑은 재현 가능한 랜덤이므로 안정적이다.

구간의 개수가 바뀌지 않는다면 동일한 범주는 항상 같은 정수로 매핑된다.

hashing_layer = tf.keras.layers.Hashing(num_bins=10)
hashing_layer([["Paris"], ["Tokyo"], ["Auckland"], ["Montreal"]])
# <tf.Tensor: shape=(4, 1), dtype=int64, numpy=array([[0], [1], [9], [1]])>

13.2.6 임베딩을 사용해 범주형 특성 인코딩하기

임베딩은 범주나 어휘 사전의 단어와 같은 고차원 데이터의 밀집 표현이다.

딥러닝에서 임베딩은 일반적으로 랜덤하게 초기화되고 다른 모델 파라미터와 함께 경사 하강법으로 훈련된다.

임베딩을 훈련할 수 있기 때문에 훈련 도중에 점차 향상된다. 비슷한 범주들은 경사 하강법이 더 가깝게 만들 것이다.

표현 학습 : 표현이 좋을수록 신경망이 정확한 예측을 만들기 쉽다. 범주가 유용하게 표현되도록 임베딩이 훈련되는 경향이 있다. 

 

케라스는 임베딩 행렬을 감싼 Embedding 층을 제공한다.

범주마다 하나의 행을, 임베딩 차원마다 하나의 열을 가진다.

기본적으로 랜덤하게 초기화된다.

범주 ID를 임베딩으로 변환하기 위해 Embedding 층이 범주에 해당하는 행을 찾아 반환한다.

tf.random.set_seed(42)
embedding_layer = tf.keras.layers.Embedding(input_dim=5, output_dim=2)
embedding_layer(np.array([2, 4, 2]))
# <tf.Tensor: shape=(3, 2), dtype=float32, numpy=
# array([[-0.04663396, 0.01846724],
         [-0.02736737, -0.02768031],
         [-0.04663396, 0.01846724]], dtype=float32)>

 

범주형 텍스트 특성을 임베딩하기 위해 StringLookup 층과 Embedding 층을 다음과 같이 연결할 수 있다.

tf.random.set_seed(42)
ocean_prox =  ["<1H OCEAN", "INLAND", "NEAR OCEAN", "NEAR BAY", "ISLAND"]
str_lookup_layer = tf.keras. layers.StringLookup()
str_lookup_layer .adapt(ocean_prox)
lookup_and _embed = tf.keras. Sequential([
... tf.keras. layers.InputLayer(input_shape=[], dtype=tf.string),
... str_lookup_layer
... tf.keras. layers.Embedding(input_dim=str_lookup_layer.vocabulary_size),
...                            output_dim=2)
...
...])
...
lookup_and_embed(np.array([["«1H OCEAN"], ["ISLAND"], ["<1H OCEAN"]]))
# <tf. Tensor: shape=(3, 2), dtype=float32, numpy=
# array([[-0.01896119, 0.02223358],
#        [ 0.02401174, 0.03724445],
#        [-0.01896119, 0.02223358]], dtype=float32)>

임베딩 행렬의 행 개수는 어휘 사전의 크기와 같아야 한다. 알려진 범주와 OOV 버킷 개수를 포함한 총 범주 개수이다.

vocabulary_size() 메서드가 이 숫자를 반환한다.

 

이를 모두 연결하면 일반적인 수치 특성과 함꼐 범주형 텍스트 특성을 처리하고 각 범주를 위한 임베딩을 학습하는 모델을 만들 수 있다. 

X_train_num, X_train_cat, y_train = [...]
X_valid_num, X_valid_cat, y_valid = [...]

num_input = tf.keras.layers.Input(shape=[8], name="num")
cat_input = tf.keras.layers.Input(shape=[], dtype=tf.string, name="cat")
cat_embeddings = lookup_and_embed(cat_input)
encoded_inputs = tf.keras.layers.concatenate([num_input, cat_enbeddings])
outputs = tf.keras.layers.Dense(1)(encoded_inputs)
model = tf.keras.models.Model(inputs=[num_input, cat_input], outputs=[outputs])
model.compile(loss="mse", optimizer="sgd")
history = model.fit((X_train_num, X_train_cat, y_train, epochs=5,
                     validation_data=((X_valid_nun, X_valid_cat), y_valid))

이 모델은 두 개의 입력을 받는다.

num_input은 샘플마다 8개의 수치 특성을 담고 있고, cat_input은 샘플마다 하나의 범주형 텍스트 특성을 담고 있다.

concatenate() 함수를 사용해 수치 입력과 임베딩을 연결하여 완전하게 인코딩된 입력을 만들어 신경망에 주입할 준비를 마친다.

이후엔 어떤 종류의 신경망이든 추가 가능하다.

앞서 정의한 입력과 출력으로 케라스 모델을 만든다.

이 모델을 컴파일하고 수치 입력과 범주형 입력을 모두 전달해 훈련한다. 

13.2.7 텍스트 전처리

StringLookup 층과 매우 비슷하게 층을 만들 때 vocabulary 매개변수로 어휘 사전을 전달하거나 adapt() 메서드를 사용해 훈련 데이터로부터 어휘 사전을 학습할 수 있다.

train_data = ["to be", "!(to be)", "That's the question", "Be, be, be."]
text_vec_layer = tf.keras.layers.TextVectorization()
text_vec_layer.adapt(train_data)
text_vec_layer(["Be good!", "Question: be or be?"])
# <tf.Tensor: shape=(2, 4), dtype=int64, numpy=
# array([[2, 1, 0, 0],
         [6, 2, 1, 2]])>

어휘 사전을 구성하기 위해 adapt() 메서드는 먼저 훈련 텍스트를 소문자로 바꾸고 구두점을 삭제한다.

문장을 공백으로 나누고 만들어진 단어를 빈도에 따라 정렬하여 최종 어휘 사전을 만든다.

문장을 인코딩할 때 알 수 없는 단어는 1로 인코딩된다.

첫 번째 문장이 두 번째 문장보다 짧기 때문에 0으로 패딩된다.

 

단어 ID는 인코딩되어야 하며 일반적으로 Embedding 층을 사용한다.

또는 TextVectorization 층의 output_mode 매개변수를 "multi_hot" 또는 "count"로 지정하여 멀티-핫 인코딩이나 카운트 인코딩을 얻을 수 있다.

하지만 단순한 단어 카운팅은 일반적으로 이상적이지 않다.

자주 등장하는 단어는 중요성이 떨어지지만 드물게 나타나는 단어는 훨씬 많은 정보를 가진다. 

따라서 output_mode를 "multi_hot"이나 "count"로 지정하는 것보다 TF X IDF를 의미하는 "tf_idf"로 설정하는 것이 낫다.

카운트 인코딩과 비슷하짐나 훈련 데이터에 자주 등장하는 단어의 가중치를 줄이고 드물게 등장하는 단어의 가중치를 높인다.

text_vec_layer = tf.keras.layers.TextVectorization(output_mode="tf_idf")
text_vec_layer.adapt(train_data)
text_vec_layer(["Be good!"m "Question: be or be?"])
# <tf.Tensor: shape=(2, 6), dtype=float32, numpy=
# array([[0.96725637, 0.6931472 , 0. , 0. , 0. , 0.        ],
#        [0.96725637, 1.3862944 , 0. , 0. , 0. , 1.0986123 ]], dtype=float32)>

TextVectorization 층은 단어 카운트에 log(1+d/(f+1))를 가중치로 곱한다.

d는 훈련 데이터에 있는 전체 문장(문서)의 개수이고 f는 주어진 단어가 포함된 문장의 개수이다.

13.2.8 사전 훈련된 언어 모델 구성 요소 사용하기

사전 훈련된 모델의 구성 요소 모듈은 일반적으로 전처리 코드와 사전 훈련된 가중치를 모두 가지며 추가 훈련이 필요 없다.

import tensorflow_hub as hub
hub_layer = hub.KerasLayer("https://tfhub.dev/google/nnlm-en-dim50/2")
sentence_embeddings = hub_layer(tf.constant(["To be", "Not to be"]))
sentence_embeddings.numpy).round(2)
# array([[-0.25, 0.28, 0.01, 0.1, [...] , 0.05, 0.31],
# [-0.2, 0.2, -0.08, 0.02, [...], -0.04, 0.1511, dtype=float32)

hub.KerasLayer 층은 주어진 URL에서 모듈을 다운로드한다.

13.2.9 이미지 전처리 층

tf.keras.layers.Resizing은 입력 이미지를 원하는 크기로 바꾼다. crop_to_aspect_radio=True로 설정하면 왜곡을 피하기 위해 목표 이미지 비율에 맞게 이미지를 자른다.

tf.keras.layers.Rescaling은 픽셀값의 스케일을 조정한다.

tf.keras.layers.CenterCrop은 원하는 높이와 너비의 중간 부분만 유지하면서 이미지를 자른다.

 

from sklearn.datasets import load_sample_images

images = load_sample_images()["images"]
crop_image_layer = tf.keras.layers.CenterCrop(height=100, width=100)
cropped_images = crop_image_layer(images)

 

케라스는 RandomCrop, RandomFli[, RandomTranslation, RandomRotation, RandomZoom, RandomHeight, RandomWidth, RandomCotrast와 같은 데이터 증식에 관한 층도 포함하고 있다. 

이런 층들은 훈련 중에만 활성화되며 입력 이미ㅣㅈ에 랜덤한 변형을 적용한다.

데이터 증식은 인공적으로 훈련 세트의 크기를 증가시켜 변형된 이미지가 실제 (증식되지 않은) 이미지처럼 보이는 한 종종 성능을 증가시킨다.