'2017/07'에 해당되는 글 2건

  1. 2017.07.26 Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras
  2. 2017.07.24 Google cluster-usage trace: format, schema

Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras

Autonomic_Network/Research_ML 2017.07.26 20:31

Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras

원문링크


시계열_예측(Time series prediction) 문제는 예측 모델링 문제의 어려운 유형입니다. 회귀 예측(regression predictive) 모델링과 달리, 시계열은 입력 변수간에 시퀀스 종속성의 복잡성을 추가합니다.

시퀀스 의존성을 처리하도록 설계된 강력한 유형의 신경망을 순환 신경망 (recurrent neural networks)이라고합니다. LSTM 네트워크는 매우 큰 아키텍처를 훈련 할 수 있기 때문에 Deep Learning에 사용되는 일종의 반복 신경 네트워크입니다.

이 글에서는 Keras Deep Learning Library를 사용하여 time-series prediction 문제를 해결하기 위해 Python으로 LSTM 네트워크를 개발하는 방법을 알아 봅니다.

이 튜토리얼을 완료하면 자신의 time-series prediction 문제 및 기타 일반적인 시퀀스 문제에 대한 LSTM 네트워크를 구현하고 개발하는 방법을 알 수 있습니다.

  • 국제선 승객에 관한 시계열 예측 문제.
  • window, time-step 기반 프레이밍 time series prediction 문제를 위한 LSTM 네트워크를 개발하는 방법.
  • 매우 긴 시퀀스에서 상태 (메모리)를 유지하는 LSTM 네트워크를 사용하여 개발하고 예측하는 방법.

이 튜토리얼에서는 standard time series prediction 문제에 대한 여러 가지 LSTM을 개발합니다.

LSTM 네트워크에 대한 문제와 선택한 구성은 데모용으로만 최적화되어 있습니다.

이 예제는 time series predictive 모델링 문제에 대해 서로 다르게 구조화 된 LSTM 네트워크를 개발하는 방법을 정확하게 보여줍니다.

Problem Description

이 글에서 살펴볼 문제는 국제선 여객의 예측 문제입니다.

내용은 1 년 1 개월 후 국제선 승객수를 1,000 명 단위로 예측하는 것이 문제입니다. 자료는 1949 년 1 월부터 1960 년 12 월까지, 12 년 동안 144 회의 관찰을 통해 수집되었습니다.

데이터 세트는 DataMarket 웹 페이지의 CSV 파일, “international-airline-passengers.csv”을 사용합니다.

아래는 파일의 처음 몇 줄의 샘플입니다.

"Month","International airline passengers: monthly totals in thousands. Jan 49 ? Dec 60"
"1949-01",112
"1949-02",118
"1949-03",132
"1949-04",129
"1949-05",121

Pandas 라이브러리를 사용하여이 데이터 세트를 쉽게 로드 할 수 있습니다. 각 내용이 1개월 단위로 분리된다는 것을 알고 있습니다 (날짜는 필요하지 않음). 따라서 데이터 세트를 로드 할 때 첫 번째 열을 제외 할 수 있습니다.

다운로드 한 데이터 세트에는 3 개의 footer lines에 대해 3으로 설정된 pandas.read_csv()에 대한 skipfooter 인수로 제외합니다. 일단 로드되면 전체 데이터 세트를 쉽게 플롯 할 수 있습니다. 데이터 집합을로드하고 플롯하는 코드는 다음과 같습니다.

import pandas
import matplotlib.pyplot as plt
dataset = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
plt.plot(dataset)
plt.show()

시간이 지남에 따라 데이터 세트의 상승 추세를 볼 수 있습니다.

또한 아마도 북반구 휴가 기간에 해당하는 데이터 세트에 대한 일정주기를 볼 수 있습니다.

Plot of the Airline Passengers Dataset[Plot of the Airline Passengers Dataset]

Long Short-Term Memory Network

Long Short-Term Memory 네트워크 또는 LSTM 네트워크는 시간 경과에 따른 Backpropagation을 사용하여 학습된 신경 네트워크이며 시간 경과에 따라 사라지는 그라디언트 문제를 극복합니다.

따라서, 대규모 반복 네트워크를 생성하는데 사용될 수 있으며, 이 네트워크는 machine learning에서 어려운 시퀀스 문제를 해결하고 최첨단 결과를 달성하는 데 사용될 수 있습니다.

뉴런 대신 LSTM 네트워크는 레이어를 통해 연결된 메모리 블록을 가지고 있습니다.

블록은 고전적인 뉴런보다 더 똑똑한 구성 요소와 최근 시퀀스의 메모리가 있습니다. 블록은 블록 상태와 출력을 관리하는 게이트를 포함합니다. 블록은 입력 시퀀스에 따라 작동하고 블록 내의 각 게이트는 sigmoid 활성화 장치를 사용하여 트리거 되었는지 여부를 제어하여 상태 변경 및 블록을 통해 흐르는 정보 추가를 조건부로 만듭니다.

한 유닛에는 세 가지 유형의 게이트가 있습니다.

  • Forget Gate: 블록에서 버릴 정보를 조건부로 결정합니다.
  • Input Gate: 메모리 상태를 업데이트 할 입력 값을 조건부로 결정합니다.
  • Output Gate: 입력 및 블록의 메모리를 기반으로 출력 할 내용을 조건부로 결정합니다.

각 유닛은 유닛의 게이트가 훈련 과정에서 배운 가중치를 갖는 미니 스테이트 머신과 같습니다.

LSTM 레이어에서 정교한 학습과 기억을 달성하는 방법을 볼 수 있으며 고차원 추상화가 어떻게 여러 계층으로 계층화 될 수 있는지 알 수 있습니다.

LSTM Network for Regression

문제를 회귀(regression) 문제로 표현할 수 있습니다.

즉, 이번 달 승객 수 (천 단위)를 고려하면 다음 달 승객 수는 얼마입니까?

단일 데이터 열을 2 열 데이터 세트로 변환하는 간단한 함수를 작성할 수 있습니다. 이 달의 (t) 승객 수를 포함하는 첫 번째 열과 다음 달 (t + 1) 승객 수를 포함하는 두 번째 열을 예측할 수 있습니다.

시작하기 전에 먼저 사용하려는 모든 함수와 클래스를 가져와 봅시다. 이것은 Keras 심층 학습 라이브러리가 설치된 SciPy 작업 환경을 가정합니다.

import numpy
import matplotlib.pyplot as plt
import pandas
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error

우리가하기 전에, 우리의 결과를 재현 할 수 있도록 난수 시드를 수정하는 것이 좋습니다.

# fix random seed for reproducibility
numpy.random.seed(7)

이전 섹션의 코드를 사용하여 데이터 세트를 Pandas 데이터 프레임으로로드 할 수도 있습니다. 그런 다음 데이터 프레임에서 NumPy 배열을 추출하고 정수 값을 신경망을 사용하여 모델링하는 데 더 적합한 부동 소수점 값으로 변환 할 수 있습니다.

# load the dataset
dataframe = pandas.read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')

LSTM은 특히 Sigmoid (기본값) 또는 tanh 활성화 기능이 사용될 때 입력 데이터의 크기에 민감합니다. 정규화라고도하는 0에서 1의 범위로 데이터의 크기를 다시 조정하는 것이 좋습니다. scikit-learn 라이브러리의 MinMaxScaler 전처리 클래스를 사용하여 데이터 세트를 쉽게 정규화 할 수 있습니다.

# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)

데이터를 모델링하고 training 데이터 세트에서 모델의 기술을 평가 한 후에는 새로운 보이지 않는 데이터에 대한 모델 기술에 대한 아이디어를 얻을 필요가 있습니다. 정상 분류(normal classification) 또는 회귀 문제(regression problem)의 경우 교차 검증을 사용하여이를 수행합니다.

time series 데이터의 경우 값의 순서가 중요합니다. 우리가 사용할 수 있는 간단한 방법은 정렬 된 데이터 세트를 train 및 테스트 데이터 세트로 분할하는 것 입니다. 아래 코드는 스플릿 포인트의 인덱스를 계산하고 모델을 테스트하는 데 사용할 수 있는 관측치의 67%를 사용하여 데이터를 교육 데이터 세트로 분리하고 나머지 33%는 모델 테스트를 위해 남겨 둡니다.

# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
print(len(train), len(test))

이제 위에서 설명한대로 새 데이터 집합을 만드는 함수를 정의할 수 있습니다.

이 함수는 데이터 세트로 변환하려는 NumPy 배열인 데이터 세트와 다음 기간을 예측하기 위해 입력 변수로 사용하는 이전 시간 스텝의 수인 look_back이라는 두 인수를 사용합니다. 이 경우 기본값은 1입니다.

이 기본값은 X가 주어진 시간 (t)에 승객의 수이고 Y가 다음 시간 (t + 1)에 승객의 수인 데이터 세트를 생성합니다.

이를 구성 할 수 있으며, 다음 섹션에서 모양이 다른 데이터 세트를 구성 할 것 입니다.

# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)

데이터 집합의 첫 번째 행에 대한이 함수의 영향을 살펴 보겠습니다 (명확화를 위해 비표준 형식으로 표시).

X       Y
112     118
118     132
132     129
129     121
121     135

첫 번째 5 행을 이전 섹션에 나열된 원본 데이터 세트 샘플과 비교하면 숫자에 X = t 및 Y = t + 1 패턴이 표시됩니다.

이 함수를 사용하여 모델링을위한 열차 및 테스트 데이터 세트를 준비합시다.

# reshape into X=t and Y=t+1
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)

LSTM 네트워크는 입력 데이터 (X)가 [samples, time steps, features]의 형태로 특정 배열 구조와 함께 제공 될 것으로 기대합니다.

현재 우리의 데이터는 [samples, features] 형식으로되어 있으며 각 샘플에 대해 한 번 단계로 문제를 구성하고 있습니다. 다음과 같이 numpy.reshape ()를 사용하여 준비된 train를 변형하고 입력 데이터를 예상되는 구조로 테스트 할 수 있습니다.

# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))

우리는 이제이 문제에 대한 LSTM 네트워크를 설계하고 맞출 준비가되었습니다.

네트워크에는 1 개의 입력이 있는 보이는 레이어, 4 개의 LSTM 블록 또는 뉴런이있는 숨겨진 레이어, 단일 값 예측을하는 출력 레이어가 있습니다. 기본 Sigmoid 활성화 기능은 LSTM 블록에 사용됩니다. 네트워크는 100 개 epochs에 대해 훈련되고 1의 배치 크기가 사용됩니다.

# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)

모델이 적합하면 train 및 테스트 데이터 세트에서 모델의 성능을 예측할 수 있습니다. 이것은 우리에게 새로운 모델에 대한 비교 점을 줄 것입니다.

오류 점수를 계산하기 전에 예측을 반전하여 원래 데이터 (한 달에 수천 명의 승객)와 동일한 단위로 실적을 보고합니다.

# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))

마지막으로 모델의 기술을 시각적으로 표시하기 위해 열차 및 테스트 데이터 세트 모두에 대해 모델을 사용하여 예측을 생성 할 수 있습니다.

데이터 세트가 준비되었으므로, x 축에서 원래 데이터 세트와 정렬되도록 예측을 이동해야합니다. 준비가 완료되면 데이터가 그려져 원본 데이터 세트가 파란색으로 표시되고 교육 데이터 세트의 녹색 예측이 표시되며 보이지 않는 테스트 데이터 세트의 예측은 빨간색으로 표시됩니다.

# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

이 모델은 train 데이터 세트와 테스트 데이터 세트 모두에 적합한 훌륭한 작업을 수행했다는 것을 알 수 있습니다.

LSTM Trained on Regression Formulation of Passenger Prediction Problem[LSTM Trained on Regression Formulation of Passenger Prediction Problem]

전체 코드 예제는 다음과 같습니다.

# LSTM for international airline passengers problem with regression framing
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# reshape into X=t and Y=t+1
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

예제를 실행하면 다음과 같은 출력이 생성됩니다.

...
Epoch 95/100
0s - loss: 0.0020
Epoch 96/100
0s - loss: 0.0020
Epoch 97/100
0s - loss: 0.0020
Epoch 98/100
0s - loss: 0.0020
Epoch 99/100
0s - loss: 0.0020
Epoch 100/100
0s - loss: 0.0020
Train Score: 22.93 RMSE
Test Score: 47.53 RMSE

이 모델에는 훈련 데이터 세트에 약 23 명의 승객 (수천)의 평균 오류가 있고 테스트 데이터 세트에 약 52 명의 승객 (수천)이 있다는 것을 알 수 있습니다.

LSTM for Regression Using the Window Method

우리는 또한 다음의 단계에 대한 예측을 하기 위해 여러 개의 최근 time steps가 사용될 수 있도록 문제를 구별 할 수 있습니다.

이를 window라고하며 window의 크기는 각 문제에 대해 조정할 수 있는 매개 변수입니다.

예를 들어, 시퀀스 (t + 1)에서 다음 번에 값을 예측하고자하는 현재 시간 (t)이 주어진다면, 현재 시간 (t)뿐만 아니라 이전 시간 (t-1 및 t-2)을 입력 변수로 갖는다.

회귀(regression) 문제로 표현하면 입력 변수는 t-2, t-1, t이고 출력 변수는 t + 1입니다.

이전 섹션에서 작성한 create_dataset() 함수를 사용하면 look_back 인수를 1에서 3으로 늘림으로써 시계열 문제의 공식을 생성 할 수 있습니다.

이 공식을 사용하는 데이터 세트의 샘플은 다음과 같습니다.

X1  X2  X3  Y
112 118 132 129
118 132 129 121
132 129 121 135
129 121 135 148
121 135 148 148

이전 섹션의 예제를 큰 window 크기로 다시 실행할 수 있습니다. 완전성을 위해 window 크기가 변경된 전체 코드 목록이 아래에 나열되어 있습니다.

# LSTM for international airline passengers problem with window regression framing
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

예제를 실행하면 다음과 같은 결과가 출력됩니다.

...
Epoch 95/100
0s - loss: 0.0021
Epoch 96/100
0s - loss: 0.0021
Epoch 97/100
0s - loss: 0.0021
Epoch 98/100
0s - loss: 0.0021
Epoch 99/100
0s - loss: 0.0022
Epoch 100/100
0s - loss: 0.0020
Train Score: 24.19 RMSE
Test Score: 58.03 RMSE

오류는 이전 섹션과 비교하여 약간 증가한 것을 볼 수 있습니다. window 크기와 네트워크 아키텍처는 조정되지 않았습니다. 이것은 예측 문제를 프레임하는 방법을 보여주는 데 불과합니다.

LSTM Trained on Window Method Formulation of Passenger Prediction Problem[LSTM Trained on Window Method Formulation of Passenger Prediction Problem]

LSTM for Regression with Time Steps

LSTM 네트워크를 위한 데이터 준비에는 시간 단계가 포함되어 있습니다.

일부 시퀀스 문제의 경우 샘플 당 시간 단계가 다양 할 수 있습니다. 예를 들어 물리적인 기계를 측정하여 장애가 발생하거나 surge가 발생하는 경우가 있습니다. 각각의 사건은 사건이 될 관측치가 시간 단계가되는 표본이 될 것이며 관측 된 변수는 특징이 될 것입니다.

time steps는 time series 문제를 표현하는 또 다른 방법을 제공합니다. 위의 window 예와 같이, 다음 시간 단계에서 출력을 예측하기 위해 입력으로 time series에서 이전 시간 단계를 취할 수 있습니다.

과거의 관측치를 별도의 입력 피쳐로 표현하는 대신, 이를 한 입력 피처의 time step로 사용할 수 있습니다. 이는 실제로 문제보다 정확한 프레이밍입니다.

이전 window 기반 예제와 동일한 데이터 표현을 사용하여 이를 수행 할 수 있습니다. 데이터를 재구성 할 때를 제외하고 열을 시간 단계 차원으로 설정하고 형상 차원을 다시 1로 변경합니다.

# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))

전체 코드 목록은 다음과 같습니다.

# LSTM for international airline passengers problem with time step regression framing
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(look_back, 1)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

예제를 실행하면 다음과 같은 결과가 출력됩니다.

...
Epoch 95/100
1s - loss: 0.0021
Epoch 96/100
1s - loss: 0.0021
Epoch 97/100
1s - loss: 0.0021
Epoch 98/100
1s - loss: 0.0020
Epoch 99/100
1s - loss: 0.0021
Epoch 100/100
1s - loss: 0.0020
Train Score: 23.69 RMSE
Test Score: 58.88 RMSE

입력 데이터의 구조가 훨씬 더 의미가 있지만 결과가 이전 예제보다 약간 더 나은 것을 알 수 있습니다.

LSTM Trained on Time Step Formulation of Passenger Prediction Problem[LSTM Trained on Time Step Formulation of Passenger Prediction Problem]

LSTM with Memory Between Batches

LSTM 네트워크에는 긴 시퀀스에서 기억할 수있는 메모리가 있습니다.

일반적으로 model을 수용 할 때 각 training batch 후에 model.predict() 또는 model.evaluate()를 호출 할 때마다 네트워크 내의 상태가 재설정됩니다.

LSTM 계층을 “stateful” 함으로써 Keras에서 LSTM 네트워크의 내부 상태가 지워지는 경우를 보다 세밀하게 제어 할 수 있습니다. 즉, 전체 교육 과정에 걸쳐 상태를 구축 할 수 있으며 예측이 필요한 경우 상태를 유지할 수도 있습니다.

네트워크에 연결될 때 교육 데이터가 섞이지 않아야 합니다. 또한 model.reset_states()에 대한 호출을 통해 train 데이터 (epoch)에 노출 될 때마다 네트워크 상태를 명시적으로 재설정해야 합니다. 이것은 우리가 epoch의 외부 루프를 만들고 각 epoch 호출 model.fit() 및 model.reset_states() 내에서 만들어야 함을 의미합니다.

for i in range(100):
    model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
    model.reset_states()

마지막으로, LSTM 계층이 구성 될 때 상태 기반 매개 변수를 True로 설정해야하며 입력 차원을 지정하는 대신 number of samples in a batch, 샘플의 number of time steps 및 number of features를 하드 코딩하여야 하며 batch_input_shape 매개 변수를 설정하여 단계를 완료하십시오.

model.add(LSTM(4, batch_input_shape=(batch_size, time_steps, features), stateful=True))

이 같은 batch size는 나중에 모델을 평가하고 예측을 할 때 사용해야합니다.

model.predict(trainX, batch_size=batch_size)

이전의 시간 단계 예제를 적용하여 상태 기반 LSTM을 사용할 수 있습니다. 전체 코드 목록은 아래에 제공됩니다.

# LSTM for international airline passengers problem with memory
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
batch_size = 1
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
for i in range(100):
    model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
    model.reset_states()
# make predictions
trainPredict = model.predict(trainX, batch_size=batch_size)
model.reset_states()
testPredict = model.predict(testX, batch_size=batch_size)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

예제를 실행하면 다음과 같은 결과가 출력됩니다.

...
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0016
Train Score: 20.74 RMSE
Test Score: 52.23 RMSE

결과가 더 나 빠졌다는 것을 알 수 있습니다. 모델에는 더 많은 모듈이 필요할 수 있으며 문제의 구조를 내부화하기 위해 더 많은 epoch을 train 받아야 할 수 있습니다.

Stateful LSTM Trained on Regression Formulation of Passenger Prediction Problem[Stateful LSTM Trained on Regression Formulation of Passenger Prediction Problem]

Stacked LSTMs with Memory Between Batches

마지막으로, 우리는 LSTM의 큰 장점 중 하나 인 deep network 아키텍처를 활용하여 train 받을 수 있다는 사실을 살펴볼 것입니다.

LSTM 네트워크는 다른 레이어 유형을 쌓을 수 있는 것과 같은 방법으로 Keras에 쌓을 수 있습니다. 필요한 구성에 한 가지 추가 사항은 각 후속 LSTM 레이어 이전의 LSTM 레이어가 시퀀스를 반환해야 한다는 것입니다. 이 작업은 레이어의 return_sequences 매개 변수를 True로 설정하여 수행 할 수 있습니다.

이전 섹션의 stateful LSTM을 확장하여 다음과 같이 두 개의 레이어를 만들 수 있습니다.

model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))

전체 코드 목록은 완전성을 위해 아래에 제공됩니다.

# Stacked LSTM for international airline passengers problem with memory
import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
# convert an array of values into a dataset matrix
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return numpy.array(dataX), numpy.array(dataY)
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], 1))
# create and fit the LSTM network
batch_size = 1
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
for i in range(100):
    model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
    model.reset_states()
# make predictions
trainPredict = model.predict(trainX, batch_size=batch_size)
model.reset_states()
testPredict = model.predict(testX, batch_size=batch_size)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])
# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()

예제를 실행하면 다음과 같은 출력이 생성됩니다.

...
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0017
Epoch 1/1
1s - loss: 0.0016
Train Score: 20.49 RMSE
Test Score: 56.35 RMSE

테스트 데이터 세트에 대한 예측은 다시 악화됩니다. 이것은 추가적인 train 시기에 대한 필요성을 암시하는 증거입니다.

Stacked Stateful LSTMs Trained on Regression Formulation of Passenger Prediction Problem[Stacked Stateful LSTMs Trained on Regression Formulation of Passenger Prediction Problem]

Summary

이 글에서는 Keras 심층 학습 네트워크를 사용하여 파이썬에서 time series prediction을 위한 LSTM 반복적인 신경망을 개발하는 방법을 발견했습니다.

특히, 다음을 배웠습니다.

  • 국제선 승객의 시계열 예측 문제에 대해.
  • time series 문제의 회귀(regression) 및 window를 위한 LSTM을 작성하는 방법.
  • time series 문제의 time step 공식을 사용하여 LSTM을 만드는 법.
  • LSTM을 상태 및 스택 된 LSTM과 함께 생성하여 긴 시퀀스를 배우는 방법.
Trackbacks 0 : Comments 0

Google cluster-usage trace: format, schema

Autonomic_Network/Machine_Learning 2017.07.24 15:21

Google cluster-usage trace: format, schema

Introduction

Google 클러스터는 고대역폭 클러스터 네트워크로 연결된 머신으로, 랙으로 구성되어 있습니다.
셀은 일반적으로 모든 클러스터가 하나인 컴퓨터 세트로, 공통 클러스터 관리 시스템을 공유하여 작업을 컴퓨터에 할당합니다.
작업은 하나 이상의 테스크로 구성되며 각 작업에는 테스크를 컴퓨터에 예약 (포장)하는 데 사용되는 리소스 요구 사항 집합이 수반됩니다.
각 작업은 하나의 컴퓨터에서 실행될 수있는 여러 프로세스로 구성된 Linux 프로그램을 나타냅니다.
작업 및 작업은 아래에 설명 된 수명주기에 따라 시스템에 예약됩니다.
자원 요구 사항 및 작업 사용 데이터는 셀의 관리 시스템과 셀의 개별 시스템에서 제공하는 정보에서 파생됩니다.

단일 사용 현황 추적은 일반적으로 이러한 계산 셀 중 하나에서 몇 일 간의 작업량을 나타냅니다.
추적은 여러 데이터 세트로 구성됩니다.
데이터 집합에는 일반적으로 타임 스탬프가 포함 된 기본 키로 인덱싱 된 단일 테이블이 포함됩니다.
각 데이터 세트는 압축 된 CSV 형식으로 제공되는 하나 이상의 파일 세트로 패키지됩니다. (자세한 내용은 아래를 참조하십시오.)


다운로드 및 원문은 첨부파일을 참조바랍니다.

Google cluster-usage traces format schema 2014-11-17 external.pd


Common techniques and fields

여러 테이블에서 발생하는 필드의 표현과 의미를 설명합니다.

Obfuscation techniques

대부분의 데이터 형식에 사용되는 변환내용

  • unchanged: 난독화 하지 않은 값
  • hashed: 각 값은 암호화 된 해시가 갖는 포인트 값으로 변환
  • rescaled: 각 값은 최소 측정값에 의해 변형되어 트레이스에 표기함, 예를 들어 모든 시스템에서 관찰된 최대 메모리 용량은 모든 메모리 요청 및 사용 값을 다시 조정하는 데 사용, 이 값은 max (1.0 / 210, max_value / 220) 단위로 반올림
  • special: 몇 가지 값은 특별한 방법으로 취급

Time and timestamps

각 레코드는 트레이스 기간의 시작 전 600 초부터 마이크로 초 단위의 타임 스탬프를 가지며, 64 비트 정수로 기록 (즉, 트레이스 시작 후 20 초 후에 timestamp = 620s)

Unique identifiers

모든 작업과 모든 시스템에는 고유 한 64 비트 식별자가 지정됩니다.
이 ID는 재사용되지 않습니다. 그러나 시스템이 클러스터에서 제거되어 리턴 될 때 동일하게 유지 될 수 있습니다.
매우 드물게 동일한 작업이 중지, 재구성 및 재시작 될 때 작업 ID가 동일하게 유지 될 수 있습니다.

테스크는 작업의 작업 ID와 작업 내 0-based 색인으로 식별됩니다.

User and job names

사용자 및 작업 이름은 hash 값으로 변경되어 테스트 할 수있는 opaque 한 base64 인코딩 문자열로 제공됩니다.

User name은 Google 엔지니어 및 서비스를 나타냅니다. 동일한 User name으로 실행되는 생산 작업은 동일한 외부 또는 내부 서비스의 일부일 수 있습니다. 단일 프로그램이 여러 작업을 실행할 때마다 (예 : MapReduce 프로그램이 마스터 작업과 작업자 작업을 생성 함) 이러한 작업은 거의 항상 동일한 사용자로 실행됩니다.

Resource units

대부분의 리소스 사용량 측정 및 요청은 다음을 포함하여 표준화되었습니다.

  • CPU (core count or core-seconds/second)
  • memory (bytes)
  • disk space (bytes)
  • disk time fraction (I/O seconds/second)

각각에 대해 별도의 정규화를 계산합니다.
정규화는 트레이스의 모든 시스템에서 리소스의 최대 용량 (1.0)과 관련된 비율 조정입니다.


Data tables

아래에서는 제공될 테이블을 설명합니다.
테이블 키는 기울임 꼴입니다. 일부 키는 여러 필드로 구성됩니다.
주의 사항 : 여기에 설명된 모든 유형의 데이터가 모두 포함되는 것은 아닙니다.
열은 다른 순서로 표시되거나 여기에 표시된 것과 다른 이름을 가질 수 있습니다. 이러한 세부 정보의 최종 사양은 schema.csv 파일에서 찾을 수 있습니다.

Machines

machine events tablemachine attributes table로 구성됩니다.

Machine events

각 machine은 machine events table의 하나 이상의 레코드로 설명됩니다.
대다수의 레코드는 추적 시작시 존재했던 시스템을 설명합니다.

  • machine events table:
    • timestamp
    • machineID
    • eventtype
    • platformID
    • capacity: CPU
    • capacity: memory

machine events 에는 세 가지 유형이 있습니다.

  • ADD (0): 머신이 클러스터에서 사용 가능하게 됨 - 트레이스의 모든 머신은 ADD 이벤트가 있습니다.
  • REMOVE (1): 시스템이 클러스터에서 삭제되었습니다. 제거 또는 실패로 인해 삭제가 발생할 수 있습니다.
  • UPDATE (2): 클러스터에 사용 가능한 시스템의 사용 가능한 자원이 변경되었습니다.

machine capacities는 각 치수에 따른 각 기계의 표준화 된 물리적 용량을 반영합니다.
각 치수 (CPU 코어, RAM 크기)은 독립적으로 정규화됩니다.

platform ID는 컴퓨터의 마이크로 아키텍처 및 칩셋 버전을 나타내는 opaque 한 문자열입니다.
마이크로 아키텍처 (예 : Nehalem 또는 Bulldozer와 같은 공급 업체 칩 코드 이름)와 메모리 기술 (예 : DDR2 대 DDR)의 서로 다른 조합은 플랫폼 ID가 서로 다릅니다.
동일한 플랫폼 ID를 가진 두 대의 기계는 실질적으로 서로 다른 클럭 속도, 메모리 속도, 코어 수 등을 가질 수 있습니다.

Machine attributes

  • Machine attributes 테이블
    • timestamp
    • machine ID
    • attribute name: an opaque string
    • attribute value: either an opaque string or an integer
    • attribute delete: a boolean indicating whether the attribute was deleted

machine attributes은 커널 버전, 클럭 속도, 외부 IP 주소의 존재 여부와 같은 machine properties를 나타내는 key - value 쌍입니다.
테스크는 machine attribues에 대한 제한 조건을 지정할 수 있습니다.

Jobs and tasks

  • Jobs and tasks 는 다음과 같이 구성됩니다:
    • Job events table
    • Task events table
    • Task constraints table

두 이벤트 테이블은 작업 / 태스크 및 해당 라이프 사이클을 설명합니다.
constraints (제약 조건) 테이블은 작업을 예약 할 수있는 컴퓨터를 제한하는 작업 배치 제약 조건을 설명합니다.

일반적으로 작업 내의 모든 작업은 동일한 옵션과 자원 요청을 사용하여 정확하게 동일한 바이너리를 실행합니다.
서로 다른 자원 요구 사항에 대한 여러 유형의 테스크를 실행해야하는 프로그램은 적으로 여러 작업으로 실행됩니다.
예를 들어, MapReduce는 별도의 작업으로 마스터와 작업자를 실행합니다.

Job and task life cycles and event types

각 작업 및 테스크 이벤트에는 이벤트 유형을 나타내는 값이 있습니다. 이벤트 이후의 작업 또는 테스크 상태는이 이벤트 유형에서 항상 판별 될 수 있습니다. 이벤트 (전환) 코드는 다음과 같습니다.

  • SUBMIT (0) : 테스크 또는 작업이 스케줄링에 적합하게 되었습니다.
  • SCHEDULE (1) : 테스크 또는 작업이 시스템에서 예약되었습니다.
  • EVICT (2) : 우선 순위가 높은 테스크 또는 작업으로 인해 테스크 또는 작업이 일정을 보류했으나, 스케줄러가 과도하게 커밋되어 실제 시스템이 실행중인 시스템을 사용할 수 없게되거나 (예 : 복구를 위해 오프라인으로 전환) 또는 테스크 데이터를 보유한 디스크가 손실 되었기 때문에 실제 수요가 시스템 용량을 초과했기 때문입니다.
  • FAIL (3) : 테스크 실패로 인해 테스크 또는 작업이 예정 취소되었습니다 (드물 긴하지만 대기중인 동안 예약 할 자격이 없어짐).
  • FINISH (4) : 테스크 또는 작업이 정상적으로 완료되었습니다.
  • KILL (5) : 테스크 또는 작업이 사용자 또는 드라이버 프로그램에 의해 취소되었거나 이 작업이 종속 된 다른 테스크 또는 작업이 사망했습니다.
  • LOST (6) : 테스크 또는 작업이 아마도 종료되었지만 그 테스크 또는 작업을 나타내는 기록 종료 데이터가 소스 데이터에서 누락되었습니다.
  • UPDATE_PENDING (7) : 테스크 또는 작업의 스케줄링 클래스, 자원 요구 사항 또는 제약 조건이 업데이트되기를 기다리는 동안 업데이트 되었습니다.
  • UPDATE_RUNNING (8) : 테스크 또는 작업의 스케줄링 클래스, 자원 요구 사항 또는 제약 조건은 예정된 동안 업데이트 되었습니다.

Missing event records

우리의 데이터 소스에는 작업 및 작업 변경의 time-series과 테스크 및 작업 상태의 주기적인 스냅 샷이 모두 포함되어 있으므로 이들 간의 일관성을 확인할 수 있습니다. 이벤트 기록이 누락 된 것으로 보이는 경우 대체품을 합성합니다. 마찬가지로 추적 time-window 끝 부분에서 활성화 된 모든 테스크 또는 작업의 레코드를 찾고 찾지 못한 경우 누락 된 레코드를 합성합니다.

  • SNAPSHOT_BUT_NO_TRANSITION (0) : 주어진 이벤트를 나타내는 레코드를 찾지 못했지만 작업 또는 태스크 상태의 이후 스냅 샷이 전환이 발생했음을 나타냅니다. 합성 이벤트의 시간 소인은 스냅 샷의 timestamp 입니다.
  • NO_SNAPSHOT_OR_TRANSITION (1) : 주어진 종료 이벤트를 나타내는 레코드를 찾지 못했지만 작업 또는 테스크가 클러스터 상태의 최신 스냅 샷에서 사라져서 종료되어야 합니다. 합성 이벤트의 timestamp는 하나의 스냅 샷에서 누락되었다고 가정 할 때 실제 종료 시간에 대한 상한선입니다.
  • EXISTS_BUT_NO_CREATION (2) : 주어진 테스크 또는 작업의 생성을 나타내는 레코드를 찾지 못했습니다. 이 경우 테스크 또는 작업에 대한 메타 데이터 (작업 이름, 자원 요청 등)가 누락되었을 수 있으며 실제로 SCHEDULE 또는 SUBMIT 이벤트를 실제로 배치 한 것보다 나중에 처리 할 수 있습니다.

Job events table

  • timestamp
  • missing info
  • job ID
  • event type
  • user name
  • scheduling class
  • job name
  • logical job name

작업 / 테스크 이벤트 테이블에는 활성 (RUNNING) 또는 실행 자격이 있지만 트레이스의 어느 지점에서나 스케줄링 대기 중 (PENDING)하는 모든 작업이 포함됩니다. 트레이스의 모든 작업에 대해 모든 작업에 대해 적어도 하나의 레코드가 포함됩니다. 여기에는 스케줄링 제약 조건이 포함됩니다.

스케줄링 클래스는 하나의 숫자로 표현되며 3은 대기 시간에 민감한 작업 (예 : 수익 창출 사용자 요청 제공)을 나타내며 0은 비 생산 작업 (예 : 개발, 비 핵심 업무 분석 등)을 나타냅니다. )

Task events table

  • timestamp
  • missing info
  • job ID
  • task index -with in the job
  • machine ID
  • event type
  • user name
  • scheduling class
  • priority
  • resource request for CPU cores
  • resource request for RAM
  • resource request for local disk space
  • different-machine constraint

각 작업에는 우선 순위가 가장 낮은 (중요도가 가장 낮은) 값이 0 인 정렬 된 값 집합으로 여기에 매핑되는 작은 정수가 포함됩니다. 우선 순위 번호가 큰 작업은 우선 순위 번호가 작은 작업보다 리소스 우선 순위가 높습니다.

특별한 우선 순위 범위가 있습니다 :
* “free”우선 순위 : 가장 낮은 우선 순위입니다. 이러한 우선 순위에서 요청 된 리소스는 내부 요금이 거의 청구되지 않습니다.
* “production”우선 순위 : 우선 순위가 가장 높습니다. 클러스터 스케줄러는 이러한 우선 순위의 대기 시간에 민감한 작업이 시스템 자원의 과도한 할당으로 인해 제거되지 않도록 시도합니다.
* “monitoring”우선 순위 :이 우선 순위는 다른 우선 순위가 낮은 작업의 상태를 모니터링하는 작업을 대상으로합니다

different-machine constraint 필드가 있고 true 이면 작업에서 현재 실행중인 다른 작업과 다른 시스템에서 실행되도록 작업을 예약해야 함을 나타냅니다. 특수한 제약 조건입니다.

resource request 는 테스크가 사용할 수있는 CPU, 메모리 또는 디스크 공간의 최대 크기를 나타냅니다 (limit). 제한을 초과하여 사용하는 작업은 CPU와 같은 리소스에 대해 제한되거나 메모리와 같은 리소스에 대해 제한 될 수 있습니다. 스케줄러는 시스템의 리소스를 지나치게 커밋 할 수 있습니다. 결과적으로, 각 테스크가 제한보다 적게 사용하더라도 테스크의 모든 런타임 요청을 충족시킬 수있는 자원이 충분하지 않을 수 있습니다. 이 경우 하나 이상의 우선 순위가 낮은 작업이 중지 될 수 있습니다.

또한 런타임 환경에서 태스크가 요청보다 많은 것을 사용하는 경우도 있습니다. 예를 들어 작업은 시스템에서 사용 가능한 CPU 용량을 사용할 수 있으므로 대기 시간이 중요하지 않은 CPU 버스트가있는 작업은 요청 된 CPU 할당이 0 일 때 유용하게 실행될 수 있습니다.

Task constraints

테스크는 0 개 이상의 테스크 배치 제약 조건이 있어 테스크를 실행할 수있는 컴퓨터를 제한합니다. 각 제한 조건 레코드는 정확히 하나의 테스크 이벤트 레코드에 해당합니다.

  • timestamp
  • job ID
  • task index
  • attribute name - corresponds to machine attribute table
  • attribute value - either an opaque string or an integer or the empty string
  • comparison operator

비교 연산자는 다음과 같습니다.

  • LESS THAN (2), GREATER THAN (3) : machine attribute 를 정수 (또는 속성이없는 경우 0)로 표시 한 다음 제공된 속성 값과 비교하십시오. 이러한 비교는 엄격합니다.
  • EQUAL (0), NOT EQUAL (1) : machine attribute 를 문자열 (또는 존재하지 않으면 빈 문자열)로 표시 한 다음 제공된 속성 값과 비교하십시오.

Task usage

우리 클러스터는 리소스 격리 및 사용 통계를 위해 Linux 컨테이너를 사용합니다. 각 테스크는 자체 컨테이너 내에서 실행되며 해당 컨테이너에 여러 프로세스를 만들 수 있습니다.

일반적으로 5 분 (300 초) 인 각 측정 기간의 사용 값을 보고 합니다. 단, 일부 측정 레코드의 기간이 짧아 지는데, 일반적으로 작업이 해당 기간 내에 업데이트 되기 때문입니다. 작업이 종료되면 작업이 종료 된 후 측정 시간이 최대 수십 초까지 연장되고 작업이 종료 된 후 몇 분의 측정 기록이 연장됩니다.

시스템 부하로 인해 리소스 정보가 원하는 속도로 샘플링되지 못하는 경우가 있기는하지만 각 측정 기간 내에서 측정은 일반적으로 1 초 간격으로 수행되므로 측정 시간이 1 초를 넘을 수 있습니다. 이러한 사례를 확인하는 데 도움이되도록 우리는 예상 샘플 수 (예 : 300 초 측정 윈도우 300 개)와 관찰 샘플 수 사이의 비율 인 충분한 부분 (즉, 증폭률)을 제공합니다.

1 초 샘플은 각 측정 기간의 길이에 걸쳐 집계되어 측정 기간의 평균값과 해당 기간의 1 초 샘플에서 볼 수있는 최대 값을 제공합니다.
경우에 따라 컨테이너의 총 가치는 여러 하위 컨테이너에서 얻은 측정 값으로 구성됩니다. 각 하위 컨테이너의 최대 사용량을 알고 있지만 측정 시스템에서 외부 컨테이너의 실제 최대 값을보고하지 못할 수 있습니다. 이 경우보고하는 최대 값은 하위 컨테이너의 최대 값 합계이며이 방식으로 최대 사용량 집계 된 레코드는 집계 유형 마커 1로 표시됩니다. 다른 모든 레코드의 집계 유형은 0입니다. 또한 평균 사용 측정에 사용량이 포함되어 있어도 모든 하위 컨테이너에 대해 최대 값을 가질 수 없습니다

측정 기록이 누락되었을 수 있습니다. 누락 된 레코드가 반드시 작업이 실행 중이 아님을 나타내지는 않습니다.
태스크에 속한 프로세스가 태스크 컨테이너에서 실행 중이 지 않은 기간에 대한 일부 태스크 사용 측정이 있습니다. 예를 들어, 바이너리가 시스템에 복사되는 동안 이러한 측정이 발생할 수 있습니다. 이 경우 작업의 메모리, CPU 및 디스크 사용량은 합법적으로 0 일 수 있습니다. 경우에 따라 작업이 오랜 기간 동안 프로세스없이 실행될 수 있습니다.

  • start time of the measurement period
  • end time of the measurement period
  • job ID
  • task index
  • machine ID
  • mean CPU usage rate
  • canonical memory usage
  • assigned memory usage
  • unmapped page cache memory usage
  • total page cache memory usage
  • maximum memory usage
  • mean disk I/O time
  • mean local disk space used
  • maximum CPU usage
  • maximum disk IO time
  • cycles per instruction (CPI)
  • memory accesses per instruction (MAI)
  • sample portion
  • aggregation type (1 if maximums from subcontainers were summed)
  • sampled CPU usage: mean CPU usage during a random 1s sample in the
    measurement period (only in v2.1 and later)

CPU 사용률 (CPU 속도라고도 함)은 초당 CPU 코어 초 단위로 측정됩니다. 작업이 항상 두 개의 코어를 사용하는 경우 2.0 코어 -s / s의 사용으로 반영됩니다.

메모리 격리는 Linux 컨테이너를 통해 이루어지기 때문에 작업 대신 커널 메모리 사용이 고려됩니다. 작업은 그러한 할당을 포함 할만큼 충분한 메모리를 요청해야합니다. 다음과 같은 메모리 사용 데이터가 포함되어 있습니다.

  • memory usage : 정식 메모리 사용량 측정; 페이지 캐시를 포함하여 사용자가 액세스 할 수있는 페이지의 수는 부실 페이지로 표시됩니다.
  • unmapped page cache memory : 사용자 공간 프로세스에 매핑되지 않은 Linux 페이지 캐시 (파일 기반 메모리).
  • page cache memory : 총 Linux 페이지 캐시 (파일 기반 메모리)
  • assigned memory : 컨테이너에 실제로 할당 된 메모리를 기반으로 한 메모리 사용량 (반드시 사용해야하는 것은 아님)
  • maximum memory usage : 측정 간격 동안 관찰 된 표준 메모리 사용량 측정의 최대 값. 일부 작업에서는이 값을 사용할 수 없습니다.

디스크 I / O 시간은 Linux 컨테이너의 blkio 서브 시스템을 사용하여 측정됩니다. 사용량 측정은 초당 디스크 시간 초의 단위로 시스템의 모든 디스크에 걸친 합계입니다.

이 추적에 기록 된 디스크 공간은 런타임 로컬 디스크 용량 사용을 나타냅니다. 바이너리 및 기타 읽기 전용 사전 스테이지 런타임 파일에 필요한 디스크 사용량은 포함되지 않습니다. 또한 분산 된 영구 저장소 (예 : GFS, 거상)가 사용하는 대부분의 디스크 공간은이 추적에서 차지하지 않습니다.

CPI 및 MAI 통계는 프로세서 성능 카운터에서 수집됩니다. 메모리 액세스는 마지막 레벨 캐시 미스의 측정을 기반으로합니다.

'Autonomic_Network > Machine_Learning' 카테고리의 다른 글

Google cluster-usage trace: format, schema  (0) 2017.07.24
Trackbacks 0 : Comments 0