AI "මොළය" ගොඩනැගීම 🧠
සුභ පැතුම්! ඔබ අපේ ව්යාපෘතියේ වඩාත්ම සිත්ගන්නා සුළු කොටසට පැමිණ සිටිනවා. 6 වන ඒකකයේදී, අපි අපේ දත්ත (`X` සහ `y` ලෙස) ස්නායුක ජාලයකට ලබා දීමට හැකි වන පරිදි සකස් කළා. දැන්, එම දත්ත වලින් ඉගෙන ගත හැකි "මොළය" හෙවත් **ස්නායුක ජාල ආකෘතිය (Neural Network Model)** ගොඩනැගීමට කාලයයි.
අපි භාවිතා කරන්නේ **LSTM (Long Short-Term Memory)** නම් විශේෂ ස්නායුක ජාල වර්ගයක්. దీనికి "මතකයක්" තිබෙන නිසා, අනුක්රමික දත්ත (sequential data) විශ්ලේෂණයට මෙය ඉතාම දක්ෂයි. එයට අතීත දිනුම් ඇදීම් වල රටා මතක තබාගෙන, අනාගතය ගැන අනුමාන කිරීමට එම මතකය භාවිතා කළ හැකියි. මේ සියල්ල අපි කරන්නේ **Keras** නම් ඉතා පහසු library එකක් භාවිතයෙන්. Keras වලින් ආකෘතියක් හදන එක හරියට ලේගෝ (Lego) වලින් මොඩලයක් හදනවා වගේ සරලයි!
[attachment_0](attachment)පියවර 1: Keras ආකෘතිය නිර්මාණය කිරීම (Building the Model)
අපේ ආකෘතිය ස්ථර (layers) කිහිපයක් එකිනෙක මත ගොඩනැගීමෙන් නිර්මාණය වේ. සෑම ස්ථරයක්ම දත්ත වල විවිධ දේවල් ඉගෙන ගනී.
- LSTM Layers: මේවා තමයි අපේ ආකෘතියේ හදවත. අනුක්රමික දත්ත වල ඇති රටා ඉගෙන ගන්නේ මෙම ස්ථර මගිනි.
- Dense Layers: LSTM ස්ථර වලින් ඉගෙන ගත් දේවල් එකතු කර, අවසාන නිගමනයකට ඒමට මෙම ස්ථර උදව් වේ.
- Output Layer: අවසාන ප්රතිදානය, එනම් අපේ අනාවැකිය ලබා දෙන ස්ථරය මෙයයි.
Jupyter Notebook එකේ, අපේ `X` සහ `y` දත්ත සකස් කළාට පසුව, පහත කේතය ක්රියාත්මක කර ආකෘතිය ගොඩනගමු.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
# ආකෘතිය නිර්මාණය කිරීම ආරම්භ කරමු
model = Sequential()
# පළමු LSTM ස්ථරය. input_shape එක ලබා දිය යුත්තේ පළමු ස්ථරයට පමණි.
# return_sequences=True යනු ඊළඟ LSTM ස්ථරයටද අනුක්රමික දත්ත යැවීමටයි.
model.add(LSTM(units=50, return_sequences=True, input_shape=(X.shape[1], X.shape[2])))
# දෙවන LSTM ස්ථරය.
model.add(LSTM(units=50))
# Overfitting අඩු කිරීමට Dropout ස්ථරයක් (විකල්ප)
model.add(Dropout(0.2))
# Dense ස්ථරයක්
model.add(Dense(units=25))
# ප්රතිදාන ස්ථරය (අපට අංක 5ක් අනාවැකි කීමට අවශ්ය නිසා, units=5)
model.add(Dense(units=X.shape[2]))
# ආකෘතියේ ව්යුහය සාරාංශයක් ලෙස බලාගැනීම
model.summary()
පියවර 2: ආකෘතිය Compile කිරීම (Compiling the Model)
ආකෘතිය ගොඩනැගුවාට පසුව, එය පුහුණු කිරීමට පෙර, අපි එයට "ඉගෙන ගන්නා ආකාරය" කියා දිය යුතුයි. මෙය හරියට ශිෂ්යයෙකුට පාඩම් කරන්න කලින්, විභාගය සමත් වෙන්න පාවිච්චි කරන ක්රමය, වැරදුනොත් ලකුණු අඩු වෙන විදිය, සහ ඉගෙනීමේ උපක්රම මොනවද කියලා දෙනවා වගේ.
- Optimizer ('adam'): මෙය ආකෘතියේ ඉගෙනීමේ එන්ජිමයි. අනාවැකි වැරදෙන විට, එය තමන්ව නිවැරදි කරගන්නා වේගය සහ ක්රමය මෙය තීරණය කරයි. 'adam' යනු ඉතා ජනප්රිය සහ කාර්යක්ෂම optimizer එකකි.
- Loss Function ('mean_squared_error'): මෙය ආකෘතියේ "ලකුණු දීමේ ක්රමයයි". ආකෘතියේ අනාවැකිය සහ සැබෑ පිළිතුර අතර වෙනස (error එක) මනින්නේ මෙයින්. අපේ ඉලක්කය මෙම 'loss' අගය හැකි තරම් අඩු කර ගැනීමයි.
# ආකෘතිය compile කරමු
model.compile(optimizer='adam', loss='mean_squared_error')
පියවර 3: ආකෘතිය පුහුණු කිරීම (Training the Model) 💪
දැන් තමයි නියම ඉගෙනීමේ ක්රියාවලිය පටන් ගන්නේ. අපි `model.fit()` ශ්රිතය (function) භාවිතා කර, 6 වන ඒකකයේදී සකස් කළ `X` (ප්රශ්න) සහ `y` (පිළිතුරු) දත්ත, අපේ ආකෘතියට ලබා දෙනවා.
මෙය හරියට ශිෂ්යයා පාඩම් කරනවා වගේ. ආකෘතිය දත්ත හරහා නැවත නැවතත් ගමන් කරමින් (epochs), තමන්ගේ වැරදි වලින් පාඩම් ඉගෙනගෙන, ටිකෙන් ටික දක්ෂ වෙනවා.
# ආකෘතිය පුහුණු කරමු!
# epochs=25 යනු සම්පූර්ණ දත්ත කට්ටලය හරහා 25 වතාවක් ගමන් කරන බවයි.
# batch_size=32 යනු එක වරකදී උදාහරණ 32ක් සලකා බලා ඉගෙන ගන්නා බවයි.
history = model.fit(X, y, epochs=25, batch_size=32, verbose=1)
print("ආකෘතිය පුහුණු කිරීම අවසන්!")
මෙම කේතය ක්රියාත්මක කරන විට, ඔබට එක් එක් epoch එක අවසානයේ `loss` අගය පෙන්වනු ඇත. මෙම `loss` අගය ක්රමයෙන් අඩුවන බව ඔබට පෙනේවි. එයින් අදහස් වන්නේ, අපේ ආකෘතිය ටිකෙන් ටික දත්තවල ඇති රටා ඉගෙන ගනිමින්, වඩාත් නිවැරදි වන බවයි!
සුභ පැතුම්! ඔබ දැන් සම්පූර්ණ ස්නායුක ජාල ආකෘතියක් සාර්ථකව ගොඩනගා, එය දත්ත මගින් පුහුණු කර අවසන්. ඊළඟ ඒකකයේදී, අපි මේ පුහුණු කළ ආකෘතිය භාවිතා කර, සැබෑ අනාවැකි ලබා ගන්නා ආකාරය සහ එහි ප්රතිඵල ඇගයීමට ලක් කරන ආකාරය ඉගෙන ගනිමු.