গৃহীত উত্তরের পরিপূরক হিসাবে, এই উত্তরটি কেরাস আচরণ এবং প্রতিটি চিত্র কীভাবে অর্জন করবে তা দেখায়।
জেনারেল কেরাসের আচরণ
স্ট্যান্ডার্ড কেরাস অভ্যন্তরীণ প্রক্রিয়াজাতকরণ নীচের চিত্রের মতো অনেকের কাছে সর্বদা অনেকগুলি (যেখানে আমি ব্যবহার করেছি features=2, চাপ এবং তাপমাত্রা কেবল উদাহরণ হিসাবে):
অন্যান্য চিত্রের সাথে বিভ্রান্তি এড়াতে এই চিত্রটিতে, আমি পদক্ষেপের সংখ্যা 5-এ বাড়িয়েছি।
এই উদাহরণের জন্য:
- আমাদের কাছে তেলের ট্যাঙ্ক রয়েছে
- আমরা প্রতি ঘন্টা 5 ঘন্টা ব্যয় করেছি (সময় পদক্ষেপ)
- আমরা দুটি বৈশিষ্ট্য পরিমাপ করেছি:
আমাদের ইনপুট অ্যারেটি তখন এর আকারযুক্ত কিছু হওয়া উচিত (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]],
]
উইন্ডো সহচরী জন্য ইনপুট
প্রায়শই, এলএসটিএম স্তরগুলি সম্পূর্ণ সিকোয়েন্সগুলি প্রক্রিয়া করে। উইন্ডোজ বিভাজন সেরা ধারণা নাও হতে পারে। স্তরটি অভ্যন্তরীণ অবস্থাগুলি নিয়ে চলেছে যে এটি এগিয়ে যাওয়ার সাথে সাথে ক্রম কীভাবে বিকশিত হচ্ছে। উইন্ডোগুলি সমস্ত সিকোয়েন্সগুলি উইন্ডোর আকারের মধ্যে সীমাবদ্ধ করে দীর্ঘ সিকোয়েন্সগুলি শেখার সম্ভাবনা দূর করে।
উইন্ডোজগুলিতে প্রতিটি উইন্ডো দীর্ঘ মূল ক্রমের অংশ, তবে কেরাস দ্বারা এগুলি প্রতিটিকে একটি স্বতন্ত্র ক্রম হিসাবে দেখা হবে:
[ 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:
outputs = LSTM(units, return_sequences=True)(inputs)
#output_shape -> (batch_size, steps, units)
একের কাছে অনেকের অর্জন:
ঠিক একই স্তরটি ব্যবহার করে কেরারা সঠিক একই অভ্যন্তরীণ প্রিপ্রোসেসিং করবে তবে আপনি যখন ব্যবহার করবেন return_sequences=False(বা কেবল এই যুক্তি উপেক্ষা করবেন) তখন কেরাস স্বয়ংক্রিয়ভাবে শেষের পূর্বের পদক্ষেপগুলি বাতিল করে দেবে:
outputs = LSTM(units)(inputs)
#output_shape -> (batch_size, units) --> steps were discarded, only the last was returned
অনেকের কাছে একটি অর্জন করা
এখন, এটি কেবল কেরাস এলএসটিএম স্তর দ্বারা সমর্থিত নয়। পদক্ষেপগুলিকে গুণ করার জন্য আপনাকে নিজের কৌশল তৈরি করতে হবে। দুটি ভাল পন্থা রয়েছে:
- টেনসর পুনরাবৃত্তি করে একটি ধ্রুবক মাল্টি-স্টেপ ইনপুট তৈরি করুন
stateful=Trueবারবার এক ধাপের আউটপুট নিতে এবং এটি পরবর্তী পদক্ষেপের ইনপুট হিসাবে পরিবেশন করতে একটি ব্যবহার করুন (প্রয়োজন output_features == input_features)
রিপিট ভেক্টর সহ অনেকের কাছে
কেরাস স্ট্যান্ডার্ড আচরণের সাথে মানিয়ে নিতে, আমাদের পদক্ষেপগুলিতে ইনপুট দরকার, সুতরাং আমরা যে দৈর্ঘ্যটি চাই তার জন্য সহজভাবে ইনপুটগুলি পুনরাবৃত্তি করি:
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=False, দ্বিতীয় ব্যাচে সম্পূর্ণ নতুন সিকোয়েন্স রয়েছে, প্রথম ব্যাচ থেকে পৃথক
- ইন
stateful=True, দ্বিতীয় ব্যাচ একই ক্রমগুলি প্রসারিত করে প্রথম ব্যাচটি চালিয়ে যায়।
এটি দুটি মূল পার্থক্য সহ উইন্ডোতেও ক্রমগুলি ভাগ করার মতো:
- এই উইন্ডোজ সুপারপোজ না !!
stateful=True এই উইন্ডোগুলিকে একক দীর্ঘ ক্রম হিসাবে সংযুক্ত দেখতে পাবেন
ইন stateful=True, প্রতিটি নতুন ব্যাচ পূর্ববর্তী ব্যাচটি চালিয়ে যাওয়া হিসাবে ব্যাখ্যা করা হবে (যতক্ষণ না আপনি কল করবেন model.reset_states())।
- ব্যাচ 2-এ সিকোয়েন্স 1 ব্যাচ 1-এ 1 ক্রম 1 চালিয়ে যাবে।
- ব্যাচ 2 এর সিকোয়েন্স 2 ব্যাচ 1 এ 2 ক্রম 2 চালিয়ে যাবে।
- ব্যাচ 2 এ সিকোয়েন্স এন ব্যাচ 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)।
এক সাথে অনেকের সাথে রাষ্ট্রীয় = সত্য
আমাদের ক্ষেত্রে এখানে, আমরা প্রতি ব্যাচ প্রতি 1 টি পদক্ষেপ ব্যবহার করতে যাচ্ছি, কারণ আমরা একটি আউটপুট পদক্ষেপ পেতে এবং এটি একটি ইনপুট হতে চাই be
যে লক্ষ্য করুন ছবিতে আচরণ নয় "দ্বারা সৃষ্ট" হয় 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()
অনেকের কাছে অনেকের সাথে রাষ্ট্রীয় = সত্য
এখন, এখানে, আমরা একটি খুব সুন্দর অ্যাপ্লিকেশন পেয়েছি: একটি ইনপুট ক্রম দিলে এর ভবিষ্যতের অজানা পদক্ষেপের পূর্বাভাস দেওয়ার চেষ্টা করুন।
আমরা উপরের "এক থেকে অনেকের" মতো একই পদ্ধতি ব্যবহার করছি, পার্থক্যটি সহ:
- আমরা ক্রমটি নিজেই লক্ষ্য তথ্য হিসাবে ব্যবহার করব, একধাপ এগিয়ে
- আমরা ক্রমটির কিছু অংশ জানি (তাই আমরা ফলাফলের এই অংশটি বাতিল করি)।
স্তর (উপরের মতো):
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()
এই পদ্ধতির এই উত্তর এবং ফাইলটিতে ব্যবহৃত হয়েছিল:
জটিল কনফিগারেশন অর্জন
উপরের সমস্ত উদাহরণগুলিতে আমি "একটি স্তর" এর আচরণ দেখিয়েছি।
আপনি অবশ্যই একে অপরের শীর্ষে অনেকগুলি স্তর স্তুপ করতে পারেন, অগত্যা সবগুলি একই প্যাটার্ন অনুসরণ করে নয় এবং আপনার নিজের মডেল তৈরি করতে পারেন।
একটি আকর্ষণীয় উদাহরণ যা প্রদর্শিত হচ্ছে তা হ'ল "অটোরকোডার" যার "বহু থেকে এক এনকোডার" থাকে তার পরে "এক থেকে অনেকগুলি" ডিকোডার থাকে:
এনকোডার:
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)
অতিরিক্ত ব্যাখ্যা
এলএসটিএম-এ কীভাবে পদক্ষেপ গণনা করা হয় বা stateful=Trueউপরের মামলাগুলি সম্পর্কে বিশদ জানতে চান , আপনি এই উত্তরে আরও পড়তে পারেন: Ke কেরাস এলএসটিএম বোঝার বিষয়ে সন্দেহ
