온도 예측

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import keras
from keras import layers
assert tf.config.list_physical_devices('GPU'), 'No GPU available'

weather = pd.read_csv(
    '../data/jena_climate_2009_2016.csv', 
    parse_dates=['Date Time'], index_col='Date Time',
    date_format=r'%d.%m.%Y %H:%M:%S')
# 중복 행 제거
weather.drop_duplicates(inplace=True)
weather.info()

# 1. 날짜 정렬?
if not weather.index.is_monotonic_increasing:
    weather = weather.sort_index()
assert weather.index.is_monotonic_increasing
# 2. 결측치 여부?
date_diff = weather.index.to_series().diff().dropna()
# 10 분 간격으로 측정되므로 10분 이상이면 결측치
결측치여부 = date_diff != pd.Timedelta(minutes=10)
결측치여부.sum()

assert isinstance(weather.index, pd.DatetimeIndex)
# 1 시간 간격으로 리샘플링. 다운샘플링 시, 평균값 계산
weather_hourly = weather.resample('h').mean()
# 결측치 제거
weather_hourly.dropna(inplace=True)

from sklearn.model_selection import train_test_split

train, test = train_test_split(
    weather_hourly, test_size=0.5, shuffle=False)
val, test = train_test_split(
    test, test_size=0.5, shuffle=False)

len(train), len(val), len(test)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(train)
X_train = scaler.transform(train)
X_val = scaler.transform(val)
X_test = scaler.transform(test)
print(type(train), '->'  ,type(X_train))

from keras.utils import timeseries_dataset_from_array

특성차원 = X_train.shape[1]
시퀀스_길이 = 24 * 5 # 5일
offset = 24 # +24 시간
delay = 시퀀스_길이 + offset
batch_size = 256

train_dataset = timeseries_dataset_from_array(
    data=X_train[:-offset],
    targets=train['T (degC)'][delay:],
    sequence_length=시퀀스_길이,
    batch_size=None, shuffle=True)

val_dataset = timeseries_dataset_from_array(
    data=X_val[:-offset],
    targets=val['T (degC)'][delay:],
    sequence_length=시퀀스_길이,
    batch_size=None, shuffle=True)

test_dataset = timeseries_dataset_from_array(
    data=X_test[:-offset],
    targets=test['T (degC)'][delay:],
    sequence_length=시퀀스_길이,
    batch_size=None, shuffle=True)

for X_batch, y_batch in train_dataset.batch(batch_size, drop_remainder=True):
    assert X_batch.shape == (batch_size, 시퀀스_길이, 특성차원), X_batch.shape

train_dataset = train_dataset.batch(batch_size, drop_remainder=True)
val_dataset = val_dataset.batch(batch_size, drop_remainder=True)
test_dataset = test_dataset.batch(batch_size, drop_remainder=True)

def baseline_model(dataset):
    """24시간 뒤의 온도는 시퀀스의 마지막 시점 온도와 동일하다고 가정"""
    target, y_pred = [], []
    for X_batch, y_batch in dataset:
        # 시퀀스의 마지막 데이터 포인트 선택
        last_datapoints = X_batch[:, -1]
        # 원래 스케일로 복원
        last_datapoints = scaler.inverse_transform(last_datapoints)
        온도 = last_datapoints[:, 1]
        target.extend(y_batch)
        y_pred.extend(온도)
    return np.array(target), np.array(y_pred)

from sklearn.metrics import mean_absolute_error

y, y_pred = baseline_model(val_dataset)
print(f'MAE[검증]: {mean_absolute_error(y, y_pred):.3f}')
y, y_pred = baseline_model(test_dataset)
print(f'MAE[테스트]: {mean_absolute_error(y, y_pred):.3f}')

inputs = keras.Input(shape=(시퀀스_길이, 특성차원))

def MLP(inputs):
    x = layers.Flatten()(inputs)
    x = layers.Dense(16, activation='relu')(x)
    outputs = layers.Dense(1)(x)
    return keras.Model(inputs, outputs)

keras.backend.clear_session()
model = MLP(inputs)
model.summary()
model.compile(
    optimizer='rmsprop', 
    loss='mse',
    metrics=['mae'])

# outputs = model(X_batch)
# train_loss, *metrics = model.evaluate(train_dataset)
history = model.fit(
    train_dataset, epochs=10, validation_data=val_dataset)

def RNN(inputs):
    x = layers.LSTM(32)(inputs)
    outputs = layers.Dense(1)(x)
    return keras.Model(inputs, outputs)

keras.backend.clear_session()
model = RNN(inputs)
model.summary()
model.compile(
    optimizer='rmsprop', 
    loss='mse',
    metrics=['mae'])

# outputs = model(X_batch)
# train_loss, *metrics = model.evaluate(train_dataset)
history = model.fit(
    train_dataset, epochs=50, validation_data=val_dataset,
    callbacks=[
        keras.callbacks.ModelCheckpoint(
            'rnn_1.keras', save_best_only=True),
        keras.callbacks.EarlyStopping(
            patience=5, restore_best_weights=True,
            monitor='val_loss')
    ]
)

print('valiation')
model.evaluate(val_dataset)
print('test')
model.evaluate(test_dataset)