Keras LSTMs의 이해

저는 LSTMs의 개념과 Keras에서 구현된 것을 조화롭게 이해하려고 노력하고 있습니다. 저는 Keras 튜토리얼의 지침을 따르고 있습니다. 가장 혼란스런 부분은 다음과 같습니다.

데이터 시리즈를 [samples, time steps, features] 형태로 재구성하면,

상태 유지 LSTM

아래에 붙여 넣은 코드를 참조하여 위의 두 가지 질문에 집중해 봅시다.

# 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], look_back, 1))

testX = numpy.reshape(testX, (testX.shape[0], look_back, 1))

########################

# The IMPORTANT BIT

##########################

# 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, nb_epoch=1, batch_size=batch_size, verbose=2, shuffle=False)

model.reset_states()

참고: create_dataset은 길이 N의 시퀀스를 취하고, 각 요소가 길이 $*$!$%^ 일인 배열을 반환합니다.

시간 단계와 특징이란 무엇인가요?

다변량 시리즈를 고려할 때 특징 인수가 관련이 생기나요? 예를 들어, 두 가지 금융 주식을 동시에 모델링하는 경우?

Stateful LSTMs

상태 유지 LSTM

상태유지 LSTM은 배치 실행 간 셀 메모리 값을 저장한다는 것을 의미합니까? 그렇다면, batch_size이 하나이며, 메모리는 훈련 실행 간에 재설정되므로 상태유지라고 말한 의미가 무엇인가요? 이것은 훈련 데이터가 섞이지 않는 사실과 관련이 있다고 추측하지만, 어떻게 관련이 있는지 확실하지 않습니다.

어떤 생각이 있나요?

이미지 참조 : http://karpathy.github.io/2015/05/21/rnn-effectiveness/

편집 1:

편집 2:

Udacity의 딥 러닝 강좌를 수강하면서 time_step 인수에 대해 여전히 혼란스러운 사람들은 다음 토론을 참조하십시오: https://discussions.udacity.com/t/rnn-lstm-use-implementation/163169

업데이트:

결과적으로 제가 찾던 건 model.add(TimeDistributed(Dense(vocab_len))) 였습니다. 예시를 드리겠습니다: https://github.com/sachinruk/ShakespeareBot

업데이트2:

저는 LSTMs에 대한 이해를 대부분 요약해봤습니다: https://www.youtube.com/watch?v=ywinX5wgdEU

답변 1

수락된 답변을 보완하여, 이 답변은 케라스의 동작 방식과 각 이미지를 어떻게 얻을 수 있는지 보여줍니다.

일반적인 케라스 행동

표준 keras 내부 처리는 항상 많은 수의 데이터가 주어지며 다음 그림과 같이 많은 데이터에서 많은 결과를 도출합니다 (이 예시에서는 악성 문자열, 압력 및 온도를 사용하였습니다).

이 그림에서, 다른 차원들과의 혼란을 피하기 위해 단계 수를 5로 늘렸습니다.

이 예시에 대해:

우리는 N개의 석유 탱크가 있습니다.

우리는 5시간 동안 시간 단위로 측정을 취했습니다.

우리는 두 가지 특징을 측정했습니다.

압력 P

온도 T

우리의 입력 배열은 그 다음과 같은 모양을 가지고 있어야 합니다. (N,5,2):

[ Step1 Step2 Step3 Step4 Step5

Tank A: [[Pa1,Ta1], [Pa2,Ta2], [Pa3,Ta3], [Pa4,Ta4], [Pa5,Ta5]],

Tank B: [[Pb1,Tb1], [Pb2,Tb2], [Pb3,Tb3], [Pb4,Tb4], [Pb5,Tb5]],

....

Tank N: [[Pn1,Tn1], [Pn2,Tn2], [Pn3,Tn3], [Pn4,Tn4], [Pn5,Tn5]],

]

슬라이딩 윈도우에 대한 입력값들

자주, LSTM 레이어는 전체 시퀀스를 처리해야 합니다. 창을 나누는 것이 가장 좋은 아이디어가 아닐 수도 있습니다. 레이어에는 시퀀스가 어떻게 진행되는지에 대한 내부 상태가 있습니다. 창을 사용하면 긴 시퀀스를 학습하는 것이 불가능하며, 모든 시퀀스가 창 크기로 제한됩니다.

윈도우에서 각 창은 긴 원래 시퀀스의 일부입니다. 그러나 케라스에서는 각각 독립된 시퀀스로 볼 수 있습니다.

[ Step1 Step2 Step3 Step4 Step5

Window A: [[P1,T1], [P2,T2], [P3,T3], [P4,T4], [P5,T5]],

Window B: [[P2,T2], [P3,T3], [P4,T4], [P5,T5], [P6,T6]],

Window C: [[P3,T3], [P4,T4], [P5,T5], [P6,T6], [P7,T7]],

....

]

이 경우에는 처음에 하나의 시퀀스만 있지만, 창을 만들기 위해 여러 시퀀스로 나누는 것에 주목하세요.

시퀀스란 무엇인지?라는 개념은 추상적입니다. 중요한 부분은 다음과 같습니다:

당신은 많은 개별 시퀀스가 포함 된 일괄 처리를 가질 수 있습니다.

수열을 수열로 만드는 것은 단계적으로 진화한다는 것입니다 (일반적으로 시간 단위로).

단일 층으로 각 경우를 달성하기

많은 수의 표준 달성하기:

return_sequences=True 을 사용하여 간단한 LSTM 레이어로 많은-많은(many-to-many)을 달성할 수 있습니다.

outputs = LSTM(units, return_sequences=True)(inputs)

#output_shape -> (batch_size, steps, units)

하나에 많은 것을 이루는 것:

같은 레이어를 사용하면 Keras는 정확히 동일한 내부 전처리를 수행하지만 return_sequences=False (또는 이 인자를 무시하는)를 사용하면 Keras는 자동으로 마지막 이전의 단계를 삭제합니다.

outputs = LSTM(units)(inputs)

#output_shape -> (batch_size, units) --> steps were discarded, only the last was returned

하나에서 많은 것을 달성하기

지금, 이것은 keras LSTM 레이어에 의해 지원되지 않습니다. 당신은 단계를 곱하는 자신의 전략을 만들어야 할 것입니다. 두 가지 좋은 방법이 있습니다:

텐서를 반복하여 일정한 다단계 입력을 만드세요.

다음 단계의 입력으로 이전 단계의 출력을 재반영하기 위해 output_features == input_features 필요한 stateful=True 을 사용하십시오.

반복 벡터를 사용한 일대다

케라스 표준 동작에 맞게 입력이 필요하기 때문에, 단순히 원하는 길이만큼 입력을 반복합니다.

outputs = RepeatVector(steps)(inputs) #where inputs is (batch,features)

outputs = LSTM(units,return_sequences=True)(outputs)

#output_shape -> (batch_size, steps, units)

상태 유지 = 참

이제는 컴퓨터 메모리에 한 번에 들어갈 수 없는 데이터를 로드하지 않는 것 외에도 stateful=True 의 가능한 사용 방법 중 하나가 나옵니다.

Stateful는 우리가 일부 시퀀스를 단계적으로 입력할 수 있게 해줍니다. 그 차이점은 :

stateful=False에서, 두 번째 일꾼은 첫 번째 일꾼에서 독립된 완전히 새로운 시퀀스를 포함합니다.

stateful=True에서, 두 번째 배치는 첫 번째 배치를 이어서 동일한 시퀀스를 확장합니다.

이것은 두 가지 주요 차이점이 있는 윈도우에서 시퀀스를 분할하는 것과 같습니다.

이 창문들은 서로 겹치지 않습니다!!

stateful=True 이 윈도우들이 하나의 긴 시퀀스로 연결된 것을 볼 것입니다.

stateful=True에서는 모든 새로운 배치가 이전 배치를 계속 진행한다는 것으로 해석됩니다 (model.reset_states()를 호출할 때까지).

배치 2의 시퀀스 1은 배치 1의 시퀀스 1을 계속합니다.

배치 2의 시퀀스 2는 배치 1의 시퀀스 2를 계속합니다.

배치 2의 시퀀스 n은 배치 1의 시퀀스 n을 계속합니다.

입력 예시, 배치 1은 단계 1과 2를 포함하고, 배치 2는 단계 3에서 5까지를 포함합니다.

BATCH 1 BATCH 2

[ Step1 Step2 | [ Step3 Step4 Step5

Tank A: [[Pa1,Ta1], [Pa2,Ta2], | [Pa3,Ta3], [Pa4,Ta4], [Pa5,Ta5]],

Tank B: [[Pb1,Tb1], [Pb2,Tb2], | [Pb3,Tb3], [Pb4,Tb4], [Pb5,Tb5]],

.... |

Tank N: [[Pn1,Tn1], [Pn2,Tn2], | [Pn3,Tn3], [Pn4,Tn4], [Pn5,Tn5]],

] ]

배치 1과 배치 2의 탱크 정렬에 주의하세요! 그래서 우리는 shuffle=False가 필요합니다 (물론 하나의 시퀀스만 사용하는 경우가 아닌 경우).

당신은 무기한으로 어떤 수의 배치도 가질 수 있습니다. (각 배치마다 가변적인 길이가 필요한 경우 input_shape=(None,features) 를 사용하세요.)

상태 보존=True으로 일대다

우리는 이 경우에 배치 당 단 한 단계만 사용할 것이며, 출력 단계 하나를 얻고 입력으로 만들기를 원하기 때문입니다.

이 사진에서의 행동이 stateful=True 으로 인해 발생된 것은 아님을 주목해 주세요. 우리는 아래의 수동 루프에서 그러한 행동을 강제할 것입니다. 이 예시에서, stateful=True 는 우리가 순서를 중지하고 원하는 대로 조작하고 중지한 곳부터 계속하는 것을 허용해줍니다.

솔직히, 이 경우 반복 접근법이 더 나은 선택일 것입니다. 그러나 우리가 stateful=True에 대해 살펴보고 있기 때문에, 이것은 좋은 예입니다. 이를 사용하는 가장 좋은 방법은 다음 다대다 경우입니다.

층(layer)

outputs = LSTM(units=features,

stateful=True,

return_sequences=True, #just to keep a nice output shape even with length 1

input_shape=(None,features))(inputs)

#units = features because we want to use the outputs as inputs

#None because we want variable length

#output_shape -> (batch_size, steps, units)

이제 예측을 위한 수동 루프가 필요합니다.

input_data = someDataWithShape((batch, 1, features))

#important, we're starting new sequences, not continuing old ones:

model.reset_states()

output_sequence = []

last_step = input_data

for i in steps_to_predict:

new_step = model.predict(last_step)

output_sequence.append(new_step)

last_step = new_step

#end of the sequences

model.reset_states()

상태 유지(True)로 많은 대 다수

이제 여기에 우리는 매우 좋은 응용 프로그램을 얻습니다: 입력 시퀀스가 주어지면 미래의 알 수없는 단계를 예측하십시오.

우리는 하나를 많이와 같은 방법을 사용하지만 차이점은 다음과 같습니다.

우리는 시퀀스 자체를 목표 데이터로 사용할 것이며, 한 단계 앞으로 이동합니다.

우리는 일부 시퀀스를 알고 있습니다 (그래서 이 결과의 일부를 버립니다).

레이어 (위와 동일):

outputs = LSTM(units=features,

stateful=True,

return_sequences=True,

input_shape=(None,features))(inputs)

#units = features because we want to use the outputs as inputs

#None because we want variable length

#output_shape -> (batch_size, steps, units)

훈련:

우리는 시퀀스의 다음 단계를 예측하는 모델을 훈련시킬 예정입니다.

totalSequences = someSequencesShaped((batch, steps, features))

#batch size is usually 1 in these cases (often you have only one Tank in the example)

X = totalSequences[:,:-1] #the entire known sequence, except the last step

Y = totalSequences[:,1:] #one step ahead of X

#loop for resetting states at the start/end of the sequences:

for epoch in range(epochs):

model.reset_states()

model.train_on_batch(X,Y)

예측하기:

우리 예측의 첫 단계는 상태 조정입니다. 따라서 우리는 이미 이 부분을 알고 있더라도 전체 시퀀스를 다시 예측할 것입니다.

model.reset_states() #starting a new sequence

predicted = model.predict(totalSequences)

firstNewStep = predicted[:,-1:] #the last step of the predictions is the first future step

이제 우리는 일대다 케이스처럼 루프로 이동합니다. 그러나 여기서 상태를 재설정하지 마세요! 모델이 시퀀스의 어떤 단계인지 알고 있기를 원합니다 (그리고 방금 전에 한 예측으로 첫 번째 새 단계에 있다는 것을 알고 있습니다).

output_sequence = [firstNewStep]

last_step = firstNewStep

for i in steps_to_predict:

new_step = model.predict(last_step)

output_sequence.append(new_step)

last_step = new_step

#end of the sequences

model.reset_states()

이 접근 방식은 이 답변과 파일에서 사용되었습니다.

Predicting a multiple forward time step of a time series using LSTM

번역할 수 없습니다. 이유는 이 문자열은 이상한 문자들로 이루어져 있기 때문입니다.

https://github.com/danmoller/TestRepo/blob/master/TestBookLSTM.ipynb

복잡한 구성 요소 달성하기

모든 위 예시에서, 하나의 층(layer)의 동작을 보여주었습니다.

당연히, 당신은 서로 다른 패턴을 따르지 않을 수도 있지만 다양한 층을 서로 쌓아서 자신만의 모델을 만들 수 있습니다.

출현하고 있는 흥미로운 예 중 하나는 오토인코더입니다. 이것은 다수 대 일 인코더가 뒤따르는 일 대 다 디코더가 있습니다.

인코더:

inputs = Input((steps,features))

#a few many to many layers:

outputs = LSTM(hidden1,return_sequences=True)(inputs)

outputs = LSTM(hidden2,return_sequences=True)(outputs)

#many to one layer:

outputs = LSTM(hidden3)(outputs)

encoder = Model(inputs,outputs)

복호기:

반복 방법을 사용하여;

inputs = Input((hidden3,))

#repeat to make one to many:

outputs = RepeatVector(steps)(inputs)

#a few many to many layers:

outputs = LSTM(hidden4,return_sequences=True)(outputs)

#last layer

outputs = LSTM(features,return_sequences=True)(outputs)

decoder = Model(inputs,outputs)

오토인코더:

inputs = Input((steps,features))

outputs = encoder(inputs)

outputs = decoder(outputs)

autoencoder = Model(inputs,outputs)

fit(X,X)과 함께 훈련하세요.

추가 설명 사항

만약 LSTMs에서 단계가 계산되는 방법에 대한 자세한 사항이나 위의 stateful=True 경우에 대한 자세한 사항을 원한다면, 이 답변에서 더 읽을 수 있습니다: Doubts regarding `Understanding Keras LSTMs`

답변 2

Keras LSTM 이해하기

Keras LSTM은 장기 의존성 문제를 해결하기 위한 딥러닝 레이어 중 하나입니다. 이 레이어는 시계열 데이터에서 패턴을 찾아내는 데 도움을 주며, 다양한 분야에서 활용됩니다. 그럼 Keras LSTM에 대해 자세히 알아보겠습니다.

Keras LSTM 작동 원리

Keras LSTM은 일련의 순차적인 데이터를 입력 받아, 이전 시점의 상태를 기억하면서 다음 상태를 예측하는 방식으로 작동합니다. 이를 위해 LSTM은 기본적으로 셀, 입력 게이트, 출력 게이트, 망각 게이트로 구성됩니다.

입력 게이트는 현재 입력과 이전 상태를 계산해, 얼마나 많은 정보를 다음 계산에 반영할지를 결정합니다. 출력 게이트는 셀의 현재 값을 계산하는 반면, 망각 게이트는 이전 상태를 얼마나 기억할지를 결정합니다. 이러한 방식으로 LSTM은 시계열 데이터의 패턴을 파악하고 예측력을 강화하는 데에 능합니다.

Keras LSTM 활용 분야

Keras LSTM은 시계열 예측, 자연어 처리, 음성 인식 등 다양한 분야에서 활용됩니다. 예를 들어, 시계열 예측에서는 일정 기간 동안의 데이터를 기반으로 미래의 값을 예측하는 데에 LSTM이 사용됩니다. 자연어 처리에서는 LSTM을 활용해 문장 내의 단어 순서에 따른 의미를 추적하고, 이를 바탕으로 감성 분석, 문장 생성 등의 작업을 수행할 수 있습니다.

결론적으로, Keras LSTM은 딥러닝에서 뛰어난 예측력을 보이며, 시계열 데이터 및 자연어 처리 분야에서 다양한 활용 가능성을 가지고 있습니다. 이를 통해 새로운 분야에서의 머신러닝 적용 가능성이 확대될 것으로 기대됩니다.