දැනුම ක්රියාවට නැංවීම 🚀
7 වන ඒකකයේදී අපි අපේ AI "මොළය" හෙවත් LSTM ආකෘතිය ගොඩනගා එය දත්ත මගින් පුහුණු කළා. එය හරියට ශිෂ්යයෙක් විභාගයට හොඳින් පාඩම් කළා වගේ වැඩක්. දැන්, එම ශිෂ්යයා විභාගයට මුහුණ දෙන වෙලාවයි. ಈ ඒකකයේදී, අපි පුහුණු කළ ආකෘතියට අලුත් දත්ත ලබා දී, එය ඊළඟ දිනුම් ඇදීම සඳහා කුමන අංක අනුමාන කරයිදැයි බලමු.
මෙම ක්රියාවලිය පියවර කිහිපයකින් සමන්විතයි: අනාවැකිය සඳහා දත්ත සකස් කිරීම, ආකෘතියෙන් අනාවැකිය ලබා ගැනීම, සහ අපට තේරුම් ගත හැකි භාෂාවකට එම ප්රතිඵලය පරිවර්තනය කිරීම.
පියවර 1: අනාවැකිය සඳහා දත්ත සූදානම් කිරීම
අපේ ආකෘතියට මතක තියාගන්න පුළුවන් එකම භාෂාව, අපි එය පුහුණු කළ භාෂාවමයි. ඒ කියන්නේ, අපි අනාවැකියක් ලබා ගැනීමට දෙන දත්තත්, පුහුණු කිරීමේදී භාවිතා කළ ආකෘතියටම (format) තිබිය යුතුයි.
එනම්, ආදානය (input) මෙසේ විය යුතුය:
- අවසන් දිනුම් ඇදීම් 10ක අනුක්රමයක් විය යුතුය.
- පුහුණු කිරීමේදී භාවිතා කළ **එකම scaler එක** භාවිතයෙන් 0 සහ 1 අතර අගයන් බවට Normalization කර තිබිය යුතුය.
- ` (1, 10, 5)` යන 3D හැඩයට (shape) Reshape කර තිබිය යුතුය. මෙහි `1` යන්නෙන් අදහස් වන්නේ, අපි එක වරකට එක අනාවැකියක් පමණක් ලබා ගන්නා බවයි.
import numpy as np
# 6 වන ඒකකයේදී අප සෑදූ scaled_data සහ SEQUENCE_LENGTH භාවිතා කරමු.
# අනාවැකිය සඳහා ආදානය වන්නේ දත්ත කට්ටලයේ අවසන් දිනුම් ඇදීම් 10යි.
last_sequence = scaled_data[-SEQUENCE_LENGTH:]
# ආකෘතියට ලබා දීම සඳහා 3D හැඩයට Reshape කරමු.
input_for_prediction = np.reshape(last_sequence, (1, SEQUENCE_LENGTH, X.shape[2]))
print("අනාවැකිය සඳහා යොදන ආදානයේ හැඩය:", input_for_prediction.shape)
පියවර 2: අනාවැකිය ලබා ගැනීම (model.predict)
දැන් අපේ ආදානය සූදානම්. එය ආකෘතියට ලබා දී, එහි ප්රතිඵලය කුමක්දැයි බැලීමට `model.predict()` ශ්රිතය භාවිතා කරමු.
# අනාවැකිය ලබා ගනිමු
predicted_scaled_output = model.predict(input_for_prediction)
print("ආකෘතියෙන් ලැබුණු Normalized අනාවැකිය:")
print(predicted_scaled_output)
ඔබට ලැබෙන ප්රතිඵලය `[[0.23, 0.56, 0.89, ...]]` වැනි 0 සහ 1 අතර දශම සංඛ්යා සමූහයක් වනු ඇත. මෙය අපට තේරුම් ගැනීමට අපහසුයි. ඊළඟ පියවරේදී, අපි මෙය සැබෑ ලොතරැයි අංක බවට පත් කරමු.
පියවර 3: ප්රතිඵලය සැබෑ අංක බවට පත් කිරීම (Inverse Transform)
අපට ලැබුණු normalized අනාවැකිය නැවත සැබෑ ලොතරැයි අංක (උදා: 1 සිට 40 දක්වා) බවට පත් කිරීමට, අපි Normalization කිරීමේදී භාවිතා කළ **එම scaler එකේම `inverse_transform()`** ශ්රිතය භාවිතා කරමු.
# Normalized අනාවැකිය නැවත සැබෑ අංක බවට පත් කරමු.
predicted_numbers = scaler.inverse_transform(predicted_scaled_output)
print("සැබෑ අංක බවට පත්කළ අනාවැකිය (දශම සහිතව):")
print(predicted_numbers)
# එම අංක ආසන්නම පූර්ණ සංඛ්යාවට වටයමු (round).
final_prediction = np.round(predicted_numbers).astype(int)
print("\\nඅවසාන අනාවැකිය (සකස් කළ):")
# පිළිවෙළකට පෙන්වීමට sorted() භාවිතා කරමු
print(sorted(final_prediction[0]))
සුභ පැතුම්! ඔබට දැන් ලැබී ඇත්තේ, අපේ AI ආකෘතිය විසින්, පසුගිය දිනුම් ඇදීම් 10 විශ්ලේෂණය කර, ඊළඟ දිනුම් ඇදීම සඳහා ලබා දුන් හොඳම අනාවැකියයි.
අනාගත භාවිතය සඳහා ආකෘතිය සුරැකීම (Saving the Model) 💾
ස්නායුක ජාල ආකෘතියක් පුහුණු කිරීමට බොහෝ විට පැය ගණනක් හෝ දවස් ගණනක් ගතවිය හැක. අපි අනාවැකියක් ලබා ගැනීමට අවශ්ය සෑම වාරයකදීම එය නැවත පුහුණු කළ යුතු නැත. Keras මගින්, අප පුහුණු කළ සම්පූර්ණ ආකෘතියම (එහි ව්යුහය, ඉගෙන ගත් බර - weights, සහ සියලු දේ) එක ගොනුවක් ලෙස සුරැකීමට පහසුකම් සලසයි.
# ආකෘතිය ගොනුවක් ලෙස සුරකිමු.
# .h5 හෝ .keras යන දිගුව (extension) භාවිතා කළ හැක.
model.save('lottery_predictor_model.keras')
print("ආකෘතිය 'lottery_predictor_model.keras' ලෙස සාර්ථකව සුරැකුවා!")
පසුව, ඔබට මෙම ආකෘතිය නැවත භාවිතා කිරීමට අවශ්ය වූ විට, `tensorflow.keras.models.load_model('lottery_predictor_model.keras')` යන විධානය මගින් එය නැවත මතකයට නංවා, පුහුණු කිරීමකින් තොරවම අනාවැකි ලබා ගත හැක.
ඊළඟ ඒකකයේදී, අපි අපේ ආකෘතියේ අනාවැකි තවදුරටත් දියුණු කරගන්නේ කෙසේදැයි විවිධ ක්රමවේදයන් ගැන ඉගෙන ගනිමු.