TensorFlow - Regression 실습 (1) 선형회귀

코랩 실습파일)

regression.ipynb

 

깃허브 소스)

GitHub - tensorflow/docs-l10n: Translations of TensorFlow documentation

 

 

 

 

 1. 기본 회귀; 연비 예측

  회귀 문제에서 목표는 가격이나 확률과 같은 연속된 값의 출력을 예측하는 것입니다. 

  이 예에서는 Keras API를 사용합니다.

# Use seaborn for pairplot.
!pip install -q seaborn



import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

# Make NumPy printouts easier to read.
np.set_printoptions(precision=3, suppress=True)



import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers

print(tf.__version__)
>> 2.12.0

 

 

 2. Auto MPG 데이터셋 로드

url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
                'Acceleration', 'Model Year', 'Origin']

raw_dataset = pd.read_csv(url, names=column_names,
                          na_values='?', comment='\t',
                          sep=' ', skipinitialspace=True)
                          

dataset = raw_dataset.copy()
dataset.tail()

 

 

 3. 데이터 정제하기

dataset.isna().sum()
>> 	MPG             0
	Cylinders       0
	Displacement    0
	Horsepower      6
	Weight          0
	Acceleration    0
	Model Year      0
	Origin          0
	dtype: int64

이 초기 튜토리얼을 간단하게 유지하려면 해당 행을 삭제하세요.

dataset = dataset.dropna()

"Origin" 열은 숫자가 아닌 범주형입니다.

따라서 다음 단계는 pd.get_dummies를 사용하여 열의 값을 원-핫 인코딩하는 것입니다.

dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})

dataset = pd.get_dummies(dataset, columns=['Origin'], prefix='', prefix_sep='')
dataset.tail()

 

 

 4. 데이터를 훈련 세트와 테스트 세트로 분할

train_dataset = dataset.sample(frac=0.8, random_state=0)
test_dataset = dataset.drop(train_dataset.index)

 

 

 5. 데이터 조사하기

훈련 세트에서 몇 쌍의 열에 대한 공동 분포를 검토합니다.

맨 위 행은 연비(MPG)가 다른 모든 매개변수의 함수임을 나타냅니다. 다른 행은 각각이 서로 간의 함수임을 나타냅니다.

sns.pairplot(train_dataset[['MPG', 'Cylinders', 'Displacement', 'Weight']], diag_kind='kde')

전체 통계도 확인해보겠습니다. 각 특성이 매우 다른 범위를 포괄하고 있는 것에 주목하세요.

train_dataset.describe().transpose()

 

 

 6. 특성과 레이블 분리하기

특성에서 대상 값("레이블")을 분리합니다. 이 레이블은 예측하도록 모델을 훈련할 값입니다.

train_features = train_dataset.copy()
test_features = test_dataset.copy()

train_labels = train_features.pop('MPG')
test_labels = test_features.pop('MPG')

 

 

 7. 정규화 레이어

통계 표에서 각 특성의 범위가 얼마나 다른지 쉽게 알 수 있습니다.

train_dataset.describe().transpose()[['mean', 'std']]

특성의 스케일과 범위가 다르면 정규화(normalization)하는 것이 권장됩니다.

특성을 정규화하지 않아도 모델이 수렴할 수 있지만, 훈련시키기 어렵고 입력 단위에 의존적인 모델이 만들어집니다.

이것이 중요한 한 가지 이유는 특성에 모델 가중치가 곱해지기 때문입니다.

따라서 출력의 스케일과 그래디언트의 스케일은 입력 스케일의 영향을 받습니다.

모델은 특성 정규화 없이 수렴할 수도 있지만 정규화는 훈련을 훨씬 더 안정적으로 만듭니다.

 

tf.keras.layers.Normalization은 모델에 특성 정규화를 추가하는 깔끔하고 간단한 방법입니다.

첫 번째 단계는 레이어를 만드는 것입니다.

normalizer = tf.keras.layers.Normalization(axis=-1)

그런 다음 Normalization.adapt를 호출하여 전처리 레이어의 상태를 데이터에 맞춥니다.

normalizer.adapt(np.array(train_features))

평균과 분산을 계산하고 레이어에 저장합니다.

print(normalizer.mean.numpy())
>> [[   5.478  195.318  104.869 2990.252   15.559   75.898    0.178    0.197
     0.624]]

레이어가 호출되면 각 특성이 독립적으로 정규화된 입력 데이터를 반환합니다.

first = np.array(train_features[:1])

with np.printoptions(precision=2, suppress=True):
  print('First example:', first)
  print()
  print('Normalized:', normalizer(first).numpy())

>> First example: [[   4.    90.    75.  2125.    14.5   74.     0.     0.     1. ]]
   Normalized: [[-0.87 -1.01 -0.79 -1.03 -0.38 -0.52 -0.47 -0.5   0.78]]

 

 

 (1-1) 하나의 변수를 사용한 선형회귀

심층 신경망 모델을 구축하기 전에 하나 및 여러 변수를 사용하는 선형 회귀부터 시작합니다.

 

단일 변수 선형 회귀로 시작하여 'Horsepower'에서 'MPG'를 예측합니다.

tf.keras를 사용하여 모델을 교육할 때는 일반적으로 모델 아키텍처를 정의하는 것으로 시작합니다. 

일련의 단계를 나타내는 tf.keras.Sequential 모델을 사용합니다.

단일 변수 선형 회귀 모델에는 두 단계가 있습니다.

• tf.keras.layers.Normalization 전처리 레이어를 사용하여 'Horsepower' 입력 특성을 정규화합니다.
• 선형 변환(y=mx+b)을 적용하여 선형 레이어(tf.keras.layers.Dense)로 1개의 출력을 생성합니다.

입력의 수는 input_shape 인수로 설정하거나 모델이 처음 실행될 때 자동으로 설정할 수 있습니다.

 

먼저 'Horsepower' 특성으로 구성된 NumPy 배열을 만듭니다.

그런 다음 tf.keras.layers.Normalization을 인스턴스화하고 상태를 horsepower 데이터에 맞춥니다.

horsepower = np.array(train_features['Horsepower'])

horsepower_normalizer = layers.Normalization(input_shape=[1,], axis=None)
horsepower_normalizer.adapt(horsepower)

Keras 순차 모델 빌드

horsepower_model = tf.keras.Sequential([
    horsepower_normalizer,
    layers.Dense(units=1)
])

horsepower_model.summary()
>> Model: "sequential"
   _________________________________________________________________
    Layer (type)                Output Shape              Param #   
   =================================================================
    normalization_1 (Normalizat  (None, 1)                3         
    ion)                                                            
                                                                 
    dense (Dense)               (None, 1)                 2         
                                                                 
   =================================================================
   Total params: 5
   Trainable params: 2
   Non-trainable params: 3
   _________________________________________________________________

이 모델은 'Horsepower'로부터 'MPG'를 예측합니다.

처음 10개의 'Horsepower' 값에 대해 훈련되지 않은 모델을 실행합니다.

결과는 좋지 않지만 예상되는 모양 (10, 1)을 가지고 있습니다.

horsepower_model.predict(horsepower[:10])
>> 1/1 [==============================] - 0s 227ms/step
array([[-0.491],
       [-0.277],
       [ 0.906],
       [-0.688],
       [-0.622],
       [-0.244],
       [-0.737],
       [-0.622],
       [-0.162],
       [-0.277]], dtype=float32)

모델이 빌드되면 Model.compile 메서드를 사용하여 훈련 절차를 구성합니다.

컴파일에 가장 중요한 인수는 loss 및 optimizer입니다.

이들이 최적화 대상(mean_absolute_error)과 방식(tf.keras.optimizers.Adam 사용)을 정의하기 때문입니다.

horsepower_model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
    loss='mean_absolute_error')

Keras Model.fit을 사용하여 100 epoch에 대한 훈련을 실행합니다.

%%time
history = horsepower_model.fit(
    train_features['Horsepower'],
    train_labels,
    epochs=100,
    # Suppress logging.
    verbose=0,
    # Calculate validation results on 20% of the training data.
    validation_split = 0.2)

>> CPU times: user 7.13 s, sys: 209 ms, total: 7.34 s
   Wall time: 13.1 s

history 객체에 저장된 통계를 사용하여 모델의 훈련 진행 상황을 시각화합니다.

hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
hist.tail()

def plot_loss(history):
  plt.plot(history.history['loss'], label='loss')
  plt.plot(history.history['val_loss'], label='val_loss')
  plt.ylim([0, 10])
  plt.xlabel('Epoch')
  plt.ylabel('Error [MPG]')
  plt.legend()
  plt.grid(True)
  
plot_loss(history)

나중을 위해 테스트 세트에서 결과를 수집합니다.

test_results = {}

test_results['horsepower_model'] = horsepower_model.evaluate(
    test_features['Horsepower'],
    test_labels, verbose=0)

이것은 단일 변수 회귀이므로 모델의 예측을 입력의 함수로 쉽게 볼 수 있습니다.

x = tf.linspace(0.0, 250, 251)
y = horsepower_model.predict(x)
>> 8/8 [==============================] - 0s 3ms/step

def plot_horsepower(x, y):
  plt.scatter(train_features['Horsepower'], train_labels, label='Data')
  plt.plot(x, y, color='k', label='Predictions')
  plt.xlabel('Horsepower')
  plt.ylabel('MPG')
  plt.legend()
  
  plot_horsepower(x, y)

 

 

 

 

 (1-2) 다중 입력이 있는 선형회귀

거의 동일한 설정을 사용하여 여러 입력을 기반으로 예측할 수 있습니다.

이 모델은 m가 행렬이고 b가 벡터라는 점을 제외하고 여전히 동일한 y=mx+b를 수행합니다.

이전에 정의하고 전체 데이터세트에 적용한 normalizer(tf.keras.layers.Normalization(axis=-1))의 첫 레이어를 사용하여

2단계 Keras Sequential 모델을 다시 생성합니다.

linear_model = tf.keras.Sequential([
    normalizer,
    layers.Dense(units=1)
])

입력 배치에 대해 Model.predict를 호출하면 각 예제에 대해 units=1 출력이 생성됩니다.

linear_model.predict(train_features[:10])
>> 1/1 [==============================] - 0s 64ms/step
array([[-0.128],
       [-1.413],
       [-0.285],
       [-1.591],
       [ 1.584],
       [-1.2  ],
       [ 1.534],
       [-0.357],
       [-0.413],
       [ 2.599]], dtype=float32)

모델을 호출하면 가중치 행렬이 만들어집니다. kernel 가중치(y=mx+b의 m)가 (9, 1) 모양인지 확인합니다.

linear_model.layers[1].kernel
>> <tf.Variable 'dense_1/kernel:0' shape=(9, 1) dtype=float32, numpy=
array([[-0.057],
       [-0.032],
       [-0.62 ],
       [ 0.331],
       [-0.338],
       [-0.748],
       [-0.027],
       [ 0.728],
       [-0.675]], dtype=float32)>

Model.compile을 사용하여 모델을 구성하고 Model.fit을 사용하여 100 epoch 동안 훈련합니다.

linear_model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
    loss='mean_absolute_error')
    
%%time
history = linear_model.fit(
    train_features,
    train_labels,
    epochs=100,
    # Suppress logging.
    verbose=0,
    # Calculate validation results on 20% of the training data.
    validation_split = 0.2)
>> CPU times: user 5.36 s, sys: 212 ms, total: 5.58 s
   Wall time: 10.7 s

이 회귀 모델의 모든 입력을 사용하면

하나의 입력이 있는 horsepower_model보다 훨씬 더 낮은 훈련 및 검증 오류를 달성할 수 있습니다.

plot_loss(history)

나중을 위해 테스트 세트에서 결과를 수집합니다.

test_results['linear_model'] = linear_model.evaluate(
    test_features, test_labels, verbose=0)