source

Keras LSTM의 개요

goodcode 2022. 9. 23. 00:14
반응형

Keras LSTM의 개요

나는 LSTM에 대한 나의 이해를 조정하기 위해 노력하고 있으며, Keras에서 구현된 Christopher Olah에 의해투고에서 지적되었다.저는 Keras 튜토리얼을 위해 Jason Brownlee가 쓴 블로그를 팔로우하고 있습니다.내가 주로 헷갈리는 건

  1. 를 이이 into into로 [samples, time steps, features]
  2. 스테이트풀 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" 을 합니다.N-look_back가 a인 look_back길이 시퀀스

시간 단계와 특징이란?

TrainX' 3D "Time_stepes" Feature " 2" ("TrainX" 3D "Time_stepes") 。 말하자면, 이 이미지를 요?many to one케이스, 분홍색 박스의 개수는 3개인가요?또는 말 그대로 체인 길이가 3(녹색 상자 3개만 고려됨)이라는 의미입니까?여기에 이미지 설명 입력

특성 주장이 다변량 시리즈를 고려할 때 관련이 있는가? 예를 들어 두 금융주를 동시에 모델링하는 것과 같은가?

스테이트풀 LSTM

스테이트풀 LSTM은 배치 실행 간에 셀 메모리 값을 저장하는 것을 의미합니까?라면요, 만면면면면.batch_size1은 트레이닝 실행 사이에 메모리가 리셋되어 있기 때문에 스테이트풀하다고 하는 의미가 있습니다.훈련 데이터가 섞이지 않은 것과 관련이 있다고 생각합니다만, 어떻게 해야 할지 모르겠습니다.

무슨 생각 있어?이미지 레퍼런스: http://karpathy.github.io/2015/05/21/rnn-effectiveness/

편집 1:

빨간색 박스와 녹색 박스가 동일하다는 @van의 코멘트에 조금 혼란스러웠습니다.확인차원에서 다음 API 호출이 롤링되지 않은 다이어그램에 대응하고 있습니까? 두 도표도면)에 해 주세요.batch_size 임의로 선택되었습니다.)다음과 같습니다.

편집 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:

여기에서는 LSTM에 대한 제 이해의 대부분을 정리했습니다.https://www.youtube.com/watch?v=ywinX5wgdEU

승인된 답변에 대한 보완책으로 이 답변은 각도의 동작과 각 그림을 얻는 방법을 보여 줍니다.

일반적인 Keras 동작

인 케라스 다음 수대한 그림에서는 '케라스 처리'를 했습니다.features=2 및 : , 력력및및및및예(예: ):

다대다

이 이미지에서는 다른 차원과의 혼동을 피하기 위해 스텝 수를 5로 늘렸습니다.

이 예에서는 다음과 같습니다.

  • 우리는 N개의 오일 탱크를 가지고 있다.
  • 1시간마다 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 레이어는 시퀀스 전체를 처리합니다.창을 나누는 것은 좋은 생각이 아닐 수도 있습니다.레이어에는 시퀀스가 전진하면서 어떻게 진화하는지에 대한 내부 상태가 있습니다.Windows 에서는, 긴 시퀀스를 학습할 가능성이 없어져, 모든 시퀀스가 윈도우 사이즈로 제한됩니다.

윈도에서는 각 창은 긴 원본 시퀀스의 일부이지만 Keras에서는 각각 독립된 시퀀스로 인식됩니다.

        [     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]],
  ....
        ]

이 경우 처음에는 하나의 시퀀스만 있지만 여러 시퀀스로 분할하여 창을 만듭니다.

"순서란 무엇인가"의 개념은 추상적이다.중요한 부분은 다음과 같습니다.

  • 여러 개별 시퀀스를 포함하는 배치를 가질 수 있습니다.
  • 시퀀스를 시퀀스로 만드는 것은 스텝(통상 시간 스텝)으로 진화하는 것이다.

'단일 레이어'로 각 케이스 달성

표준 달성:

표준 Many To Many

한 LSTM의 LSTM 레이어를 할 수 .LSTM 레이어는 LSTM 레이어보다 LSTM 레이어를 사용합니다.return_sequences=True:

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

#output_shape -> (batch_size, steps, units)

다대일 달성:

레이어를 단, keras를 사용하는 ,return_sequences=False 이합니다), 인 (마지막 단계인)의 이전 단계를 자동으로 합니다.

다투원

outputs = LSTM(units)(inputs)

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

1대 다의 달성

이것은 keras LSTM 레이어만으로는 지원되지 않습니다.단계를 여러 번 진행하려면 자신만의 전략을 세워야 합니다.두 가지 접근법이 있습니다.

  • 텐서를 반복하여 일정한 다단계 입력 생성
  • 사용하다stateful=True즉, 다음 단계의 입력으로 제공:output_features == input_features

반복 벡터를 사용하는 1대 다

케라 표준 동작에 맞추기 위해서는 스텝의 입력이 필요하기 때문에 원하는 길이로 입력을 반복하기만 하면 됩니다.

일대다 반복

outputs = RepeatVector(steps)(inputs) #where inputs is (batch,features)
outputs = LSTM(units,return_sequences=True)(outputs)

#output_shape -> (batch_size, steps, units)

스테이트풀에 대해서= True

.stateful=True수 ( 로딩 회피)

스테이트풀을 사용하면 시퀀스의 "부분"을 단계별로 입력할 수 있습니다.차이점은 다음과 같습니다.

  • »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의 탱크 정렬에 주목하십시오!는 래우 that that가 필요하다.shuffle=False(물론 1개의 시퀀스만 사용하는 경우는 제외).

할 수 있습니다배치에 , 「」를 합니다).input_shape=(None,features)

스테이트풀=을 사용한 일대다진실의

여기에서는 1개의 출력 스텝을 입력으로 하고 싶기 때문에 1배치당 1스텝만 사용합니다.

속은 「이 되어 있지 않다」, 「원인이 되어 있지 않다」라고 점에 주의해 주세요.stateful=True아래의 수동 루프에서 동작을 강제합니다.예에서는 " " 입니다.stateful=True우리가 그 시퀀스를 멈추고, 원하는 것을 조작하고, 멈춘 곳부터 계속하도록 유도하는 것입니다.

일대다 스테이트풀

솔직히 이 경우 반복 접근 방식이 더 나은 선택일 수 있습니다. 지금stateful=True이것을 사용하는 최선의 방법은, 다음의 「다대다」의 경우입니다.

레이어:

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()

스테이트풀=로 다수 대 다수진실의

여기 아주 좋은 어플리케이션이 있습니다.입력 시퀀스를 지정하면, 장래의 미지의 스텝을 예측해 주세요.

위의 "1대 다"와 동일한 방법을 사용하고 있지만 다음과 같은 차이가 있습니다.

  • 우리는 한 단계 앞서 시퀀스 자체를 타깃 데이터로 사용할 것이다.
  • 우리는 시퀀스의 일부를 알고 있다(따라서 결과의 이 부분은 폐기합니다.

Many To Many 스테이트풀

레이어(상기와 동일):

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

이제 1대 다의 경우와 마찬가지로 루프로 이동합니다.하지만 여기서 상태를 재설정하지 마십시오.모델이 시퀀스의 어느 단계에 있는지 알고 싶다(앞서 예측한 결과 첫 번째 새로운 단계임을 알 수 있다).

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()

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

복잡한 구성을 달성하는 것은

모든 예들 위에서, 나는"한겹"의 행동을 보였다.

물론, 당신은, 서로의 위에서 necessarly 모두 같은 패턴을 따르지 않아, 그리고 당신 자신의 모델을 만들어 많은 층들 필터링 할 수 있다.

는" 많은 사람들에게 한 부호기"는"하나에 많은"디코더에 의해 그 뒤를 따르고 있는 나타나고 있는 흥미로운 예는"autoencoder":.

Encoder:

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)

Autoencoder:

inputs = Input((steps,features))
outputs = encoder(inputs)
outputs = decoder(outputs)

autoencoder = Model(inputs,outputs)

기로로 fit(X,X)

추가 설명

LSTM에 대한 내용은 LSTM을 참조하십시오.stateful=True사례가:이 대답에 더 많은 의혹이 다시 `Understanding Keras LSTMs`에 대한 읽을 수 있다.

우선, 여러분 시작할 수 있다면 멋지tutorials(1,2)을 선택한다.

Time-step 무엇을 의미하Time-steps==3쉐이프를 하는 것)에서는, 것을 의미합니다.X.shape(X.shape).Keras에서는 각 스텝에 입력이 필요하기 때문에 보통 녹색 상자의 수는 빨간색 상자의 수와 같아야 합니다.구조를 해킹하지 않는 한 말이야

다수다수 다수 대 1:케라에는return_sequencesLSTM ★★★★★★★★★★★★★★★★★」GRU ★★★★★★★★★★★★★★★★★」SimpleRNN★★★★★★★★★★★★★★★★★.return_sequencesFalse(디폴트로는) 그림과 같이 1대 1입니다.그것의 반환 모양은(batch_size, hidden_unit_length)마지막 상태를 나타냅니다.return_sequencesTrue, 그렇다면 그것은 매우 많다.그것의 반환 모양은(batch_size, time_step, hidden_unit_length)

features 인수가 관련성이 있습니까?기능 인수는 "빨간 상자의 크기" 또는 각 단계의 입력 치수를 나타냅니다.예를 들어 8종류의 시장 정보를 예측하려면 다음 방법으로 데이터를 생성할 수 있습니다.feature==8.

스테이트풀:소스코드를 조회할 수 있습니다.상태를 초기화할 때,stateful==True이전 훈련의 상태가 초기 상태로 사용됩니다.그렇지 않으면 새로운 상태가 생성됩니다.★★★★를.stateful는 그것에 하지 않습니다. 「 」, 「 」batch_size을 1로 할 경우 할 수 있어요stateful==True

현재 수집된 데이터로 데이터를 생성합니다.모든 순차적 정보를 수집하는 날을 기다리지 않고 주식 정보가 스트림으로 전달되는 이미지를 생성하십시오. 네트워크를 통해 교육/예측하면서 온라인으로 입력 데이터를 생성할 수 있습니다.동일한 네트워크를 공유하는 400개의 주식이 있는 경우 다음을 설정할 수 있습니다.batch_size==400

RNN의 마지막 레이어에 return_sequences가 있는 경우 단순 Dense 레이어를 대신 TimeDistributed를 사용할 수 없습니다.

다음은 다른 사용자에게 도움이 될 수 있는 코드 예입니다.

words = keras.displaces.입력(batch_shape=(없음, self.maxSequenceLength), 이름 = "input")

    # Build a matrix of size vocabularySize x EmbeddingDimension 
    # where each row corresponds to a "word embedding" vector.
    # This layer will convert replace each word-id with a word-vector of size Embedding Dimension.
    embeddings = keras.layers.embeddings.Embedding(self.vocabularySize, self.EmbeddingDimension,
        name = "embeddings")(words)
    # Pass the word-vectors to the LSTM layer.
    # We are setting the hidden-state size to 512.
    # The output will be batchSize x maxSequenceLength x hiddenStateSize
    hiddenStates = keras.layers.GRU(512, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength,
                                        self.EmbeddingDimension),
                                        name = "rnn")(embeddings)
    hiddenStates2 = keras.layers.GRU(128, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength, self.EmbeddingDimension),
                                        name = "rnn2")(hiddenStates)

    denseOutput = TimeDistributed(keras.layers.Dense(self.vocabularySize), 
        name = "linear")(hiddenStates2)
    predictions = TimeDistributed(keras.layers.Activation("softmax"), 
        name = "softmax")(denseOutput)  

    # Build the computational graph by specifying the input, and output of the network.
    model = keras.models.Model(input = words, output = predictions)
    # model.compile(loss='kullback_leibler_divergence', \
    model.compile(loss='sparse_categorical_crossentropy', \
        optimizer = keras.optimizers.Adam(lr=0.009, \
            beta_1=0.9,\
            beta_2=0.999, \
            epsilon=None, \
            decay=0.01, \
            amsgrad=False))

RNN, LSTM 및 GRU 애니메이션에 대한 자세한 내용은 이 블로그를 참조하십시오.

LSTM을 사용하다LSTM이 되다. 이 그림

에는 3이 .features( 원)즉, 이 상태는 2(은닉 상태)로 있습니다units 원)즉, 이 셀 상태 (빨간색 원)은 2의 벡터입니다.

다음 그림에 3개의 타임 스텝(3개의 LSTM 셀)을 가진1개의 LSTM 레이어의 예를 나타냅니다.

이 이미지

** 모델에는 여러 개의 LSTM 레이어를 포함할 수 있습니다.

이제 Daniel Möler의 예를 다시 한 번 사용해 보겠습니다.우리는 10개의 기름 탱크를 가지고 있다.각각 온도, 압력, 5회 1시간마다의 2가지 특징을 측정합니다.파라미터는 다음과 같습니다.

  • batch_size = 1개의 순방향/순방향 경로에서 사용되는 샘플의 수(기본값=32) --> 예를 들어, 1000개의 샘플이 있고 batch_size를 100으로 설정한 경우 모델은 모든 샘플을 한 번 네트워크(1에폭)를 통과시키기 위해 10회 반복합니다.배치 사이즈가 클수록 메모리 용량이 증가합니다.이 예제에서는 표본 수가 적기 때문에 batch_size는 모든 표본 = 10과 같다고 간주합니다.
  • timesteps = 5
  • 특징 = 2
  • 단위 = 양의 정수이며 숨겨진 상태와 셀 상태의 차원, 즉 다음 LSTM 셀에 전달되는 파라미터의 수를 결정합니다.특징과 시간 단계에 따라 임의 또는 경험적으로 선택할 수 있습니다.더 많은 단위를 사용하면 정확성과 계산 시간이 향상됩니다.하지만 과피팅의 원인이 될 수 있습니다.
  • input_shape = (module_size, timeeps, features) = (10,5,2)
  • output_shape:
    • (return_size, timeseps, units) return_size=인 경우맞다
    • (return_sequences=False인 경우)

언급URL : https://stackoverflow.com/questions/38714959/understanding-keras-lstms

반응형