අපි කවුරුත් දන්නවා වර්තමාන පරිගණක වැඩ කරන්නේ කොහොමද කියලා. ඔයා ලියන Java කෝඩ් එකක් වුණත්, Python script එකක් වුණත් අවසානයේදී processor එක ඇතුලට යන්නේ 0 සහ 1 කියන බිට්ස් (Bits) විදියටයි. මේකට අපි කියනවා Von Neumann Architecture එක කියලා. හැම දත්තයක්ම එක්කෝ 32-bit, නැත්නම් 64-bit අගයන් විදියට තමයි මතකයේ ගබඩා වෙන්නේ.
හැබැයි ඔයා කවදාහරි හිතලා තියෙනවද මිනිස් මොළය වැඩ කරන්නේ මේ විදියටද කියලා? අපේ මොළයේ "0 සහ 1" කියලා වෙනම වෙන් වුණු මතක ගබඩාවල් නෑ. මොළයේ එක සංකල්පයක් (උදාහරණයක් විදියට "ඇපල් ගෙඩියක්" කියන රූපය) මතක තියාගන්නේ නියුරෝන (Neurons) මිලියන ගණනක එකතුවකින් හැදෙන දැවැන්ත ජාලයක රටාවක් (Pattern) විදියටයි. අන්න ඒ ස්වභාවික රටාව කෘතිමව පරිගණක තාක්ෂණයට ගේන්න හදන, ලංකාවේ තබා ලෝකයේවත් ප්රධාන පෙළේ මාධ්යයක තවම කතා නොකරපු අතිශය රහසිගත සහ දියුණු විද්යාත්මක මාතෘකාවක් තමයි Hyperdimensional Computing (HDC) කියන්නේ.
අද KP Tech Gear ලිපියෙන් අපි කතා කරන්නේ, සාමාන්ය පරිගණක ක්රමවේද සම්පූර්ණයෙන්ම අභියෝගයට ලක් කරමින් බිහිවෙන්න යන මේ අපූරු තාක්ෂණය ගැන පතුලටම බහිමින්.
🧠 1. මොකක්ද මේ Hyperdimensional Computing (HDC) කියන්නේ?
සරලවම කිව්වොත්, Hyperdimensional Computing කියන්නේ 32-bit හෝ 64-bit වැනි කුඩා දත්ත කොටස් වෙනුවට, මාන 10,000කට වඩා වැඩි (10,000-dimensional space) දැවැන්ත Vectors මත කෙලින්ම ගණනය කිරීම් සිදු කරන ක්රමවේදයකටයි. මේ දැවැන්ත vectors වලට අපි කියනවා Hypervectors කියලා.
මේ හැම Hypervector එකකම අහඹු ලෙස (Randomly) සැකසුණු බිට්ස් 10,000ක් තියෙනවා. උදාහරණයක් විදියට, සාමාන්ය පරිගණකයක "රතු පාට" කියන දේ #FF0000 (Hex code) එකකින් හෝ 24-bit අගයකින් පෙන්නද්දී, HDC පරිගණකයක "රතු පාට" කියන්නේ අහඹු ලෙස හැදුණු 0 සහ 1 පේළි 10,000ක එකතුවකින් හැදුණු එකම එක Hypervector එකකටයි.
අධි-මාන අවකාශයක (High-dimensional space) තියෙන විශේෂත්වයක් තමයි, ඔයා අහඹු ලෙස (Randomly) Hypervectors දෙකක් හැදුවොත්, ඒ දෙක 90° ක කෝණයකින්, ඒ කියන්නේ එකිනෙකට සම්පූර්ණයෙන්ම ලම්බක (Orthogonal / Unrelated) වෙන්න තියෙන සම්භාවිතාව 99.99% කටත් වඩා වැඩියි. මෙන්න මේ ගුණය නිසා එකිනෙකට වෙනස් සංකල්ප බිලියන ගණනක් එකිනෙකා පටලවා නොගෙන එකම පද්ධතියක් ඇතුලේ ගබඩා කරන්න පුළුවන් වෙනවා.
⚙️ 2. Von Neumann Architecture එක සහ HDC අතර වෙනස
අපි දැනට Campus වල ඉගෙන ගන්නා සාමාන්ය පරිගණක රටාව සහ මේ අලුත්ම HDC රටාව අතර තියෙන වෙනස්කම් තේරුම් ගැනීම අනිවාර්යයි. ඒක මේ table එකෙන් ලේසියෙන්ම බලාගන්න පුළුවන්.
| ලක්ෂණය (Feature) | සාමාන්ය පරිගණක (Traditional Computing) | Hyperdimensional Computing (HDC) |
|---|---|---|
| දත්ත මානය (Data Dimension) | 32-bit හෝ 64-bit (Scalar values) | 10,000+ bit (Massive Hypervectors) |
| වැරදි වලට ඔරොත්තු දීම (Fault Tolerance) | ඉතා අඩුයි. එක බිට් එකක් වෙනස් වුවහොත් (Bit-flip) මුළු file එකම corrupt වේ. | ඉතා ඉහළයි. බිට්ස් 1000ක් විනාශ වුවද දත්තයේ අර්ථය නැති නොවේ. |
| කෘතිම බුද්ධිය (AI Learning) | මිලියන ගණනක් දත්ත සහ දැවැන්ත Backpropagation පුහුණුවීම් අවශ්යයි. | එක් වරකින් මතක තබා ගත හැක (One-shot Learning). |
| ශක්ති පරිභෝජනය (Energy Consumption) | Mega-Watts ගණනක විශාල විදුලි බලයක් අවශ්යයි (GPUs/TPUs). | Micro-Watts ගණනක ඉතා අවම විදුලි බලයකින් ක්රියාත්මක විය හැක. |
🛠️ 3. HDC වල සිදුවන ඉන්ද්රජාලික ගණිතමය මෙහෙයුම් 3 (The Three Magic Operations)
සාමාන්ය පරිගණක වල අපිට Addition, Subtraction, Multiplication වගේ දේවල් තියෙනවනේ. හැබැයි HDC වලදී මුළු මොළයක ක්රියාකාරීත්වයම පාලනය වෙන්නේ ප්රධාන මෙහෙයුම් තුනකින් විතරයි. මේවා සරල Bitwise operations නිසා hardware මට්ටමින් මාරම වේගවත්.
1️⃣ Binding (බැඳීම / ✖️ මෙහෙයුම)
Binding මඟින් කරන්නේ සංකල්ප දෙකක් එකතු කරලා අලුත්ම සංකල්පයක් බිහිකිරීමයි. මේ සඳහා පාවිච්චි කරන්නේ සරල XOR (Exclusive OR) ගේට් එකක්.
උදාහරණයක් විදියට අපිට "පලතුරු" කියන එකට Hypervector එකක් සහ "රතු පාට" කියන එකට තව Hypervector එකක් තිබ්බොත්, ඒ දෙක XOR කිරීමෙන් "රතු පලතුරු (ඇපල්)" කියන අලුත්ම ගුණය සහිත Hypervector එකක් ලැබෙනවා. මේ ලැබෙන අලුත් vector එක මුල් vectors දෙකටම සමාන වෙන්නේ නෑ (Orthogonal වෙනවා).
2️⃣ Bundling (එකතු කිරීම / ➕ මෙහෙයුම)
Bundling මඟින් කරන්නේ සංකල්ප කිහිපයක් එකතු කරලා කට්ටලයක් (Set හෝ Context එකක්) සෑදීමයි. මේ සඳහා කරන්නේ vectors වල බිට්ස් එකින් එක එකතු කරලා, බහුතරය (Majority Vote) අනුව අලුත් vector එකක් තේරීමයි.
විශේෂත්වය තමයි, මෙසේ සාදාගන්නා පොදු vector එක ඇතුලේ මුල් සියලුම vectors වල ජාන (Information) අඩංගු වෙනවා. අපිට ඕනෑම වෙලාවක මේ bundle එක ඇතුලේ "ඇපල්" තිබ්බද කියලා ළඟම තියෙන vector එක මඟින් (Cosine Similarity) පරික්ෂා කරන්න පුළුවන්.
3️⃣ Permutation (ස්ථාන මාරු කිරීම / 🔄 මෙහෙයුම)
මොළයට යම් කිසි දේක අනුපිළිවෙල (Sequence හෝ Order) මතක තබා ගැනීමට මේ මෙහෙයුම වැදගත් වෙනවා. මෙහිදී කරන්නේ Hypervector එකේ තියෙන බිට්ස් ටික එක ස්ථානයක් දකුණට හෝ වමට නෙරපා හැරීමයි (Shift notation).
උදාහරණයක් විදියට "A ඊට පසු B" සහ "B ඊට පසු A" කියන අවස්ථා දෙක වෙන් කරලා හඳුනාගන්නේ මේ Permutation එක ආධාරයෙනුයි.
සාමාන්ය පරිගණක මතකයක "Kavisha" කියන නම සේව් කරද්දී, ඒක මතකයේ නිශ්චිත ලිපිනයක (Specific Memory Address) විතරයි තියෙන්නේ. ඒ address එකේ එක බිට් එකක් කැඩුණොත් නම නැති වෙනවා. හැබැයි HDC වලදී දත්තය පැතිරිලා තියෙන්නේ මුළු බිට් 10,000 පුරාමයි (Holographic). ඒ කියන්නේ බිට් 10,000න් 2,000ක්ම අහඹු ලෙස මැකී ගියත්, ඉතිරි බිට් 8,000 ඇසුරෙන් 100% ක් නිවැරදිව මුල් දත්තය නැවත ලබාගන්න පුළුවන්!
💻 4. Python ඇසුරෙන් HDC පද්ධතියක් Simulate කර බලමු
අපි දැන් අපේ පරිගණකයේ සැබෑ ලෙසම මාන 10,000ක Hypervectors නිර්මාණය කරලා, ඒවායේ Binding සහ Bundling ක්රියාත්මක වෙන්නේ කොහොමද කියලා සරල Python script එකකින් බලමු. (මේක ඔයාගේ වෘත්තීය දැනුමට වගේම පර්යේෂණ වලට මාරම වටිනවා).
# 1. මාන 10,000ක අහඹු Hypervector එකක් සෑදීම (-1 සහ 1 භාවිතයෙන්)
def create_hypervector(dims=10000):
return np.random.choice([-1, 1], size=dims)
# 2. Binding මෙහෙයුම (Element-wise Multiplication - XOR වලට සමානයි)
def bind(hv1, hv2):
return hv1 * hv2
# 3. Bundling මෙහෙයුම (Vectors එකතු කර බහුතරය සෙවීම - Majority Vote)
def bundle(hvs):
sum_hv = np.sum(hvs, axis=0)
# 0 ට වැඩි නම් 1, අඩු නම් -1 ලෙස වෙනස් කිරීම
return np.where(sum_hv >= 0, 1, -1)
# 4. Vectors දෙකක් අතර තියෙන සමානකම මැනීම (Similarity check)
def similarity(hv1, hv2):
return np.mean(hv1 == hv2)
# --- Simulation එක ක්රියාත්මක කිරීම ---
DIMENSIONS = 10000
# මූලික සංකල්ප නිර්මාණය
color_red = create_hypervector(DIMENSIONS)
fruit_apple = create_hypervector(DIMENSIONS)
fruit_banana = create_hypervector(DIMENSIONS)
# 'රතු ඇපල්' කියන අලුත් සංකල්පය බන්ධනය (Bind) කිරීම
red_apple = bind(color_red, fruit_apple)
# පරික්ෂා කිරීම්
print(f"Red සහ Apple අතර සමානකම: {similarity(color_red, fruit_apple):.4f}") # 0.5 කිට්ටු අගයක් (Orthogonal)
print(f"Red_Apple සහ Apple අතර සමානකම: {similarity(red_apple, fruit_apple):.4f}") # සම්පූර්ණයෙන්ම වෙනස්
# මතකයෙන් නැවත දත්තය හඳුනාගැනීම (De-binding)
guessed_fruit = bind(red_apple, color_red)
print(f"නැවත ලබාගත් දත්තය Apple ද? සමානකම: {similarity(guessed_fruit, fruit_apple):.4f}") # 1.0000 (100% ක් නිවැරදියි!)
🚀 5. ඇයි මේ තාක්ෂණය අනාගත AI ලෝකය වෙනස් කරන්නේ?
අද කාලේ පාවිච්චි කරන ChatGPT, Midjourney වගේ දැවැන්ත AI මාදිලි වැඩ කරන්නේ Supercomputers ඇතුලේ තියෙන දහස් ගණනක් Nvidia GPUs වල විශාල විදුලි බලයක් වැය කරලයි. හැබැයි HDC තාක්ෂණයට පුළුවන් මේ හැමදේම ඉතාම සුළු ශක්තියකින් කරන්න.
වත්මන් Deep Learning වලදී එක බල්ලෙක්ව හඳුනාගන්න බල්ලන්ගේ රූප මිලියන ගණනක් AI එකට පෙන්නන්න ඕනේ. හැබැයි කුඩා ළමයෙක්ට එක පාරක් බල්ලෙක්ව පෙන්නුවාම ඌව මතක හිටිනවා. HDC වැඩ කරන්නේ අන්න ඒ විදියටයි. එකම එක Hypervector එකක් මතකයට එකතු කිරීමෙන් (One-shot learning) පද්ධතියට අලුත් දෙයක් ක්ෂණිකව ඉගෙන ගන්න පුළුවන්.
මේ නිසා අනාගතයේ එන ස්මාර්ට්ෆෝන්, රොබෝවරු සහ Wearable Devices වලට කිසිදු Internet හෝ Cloud සම්බන්ධතාවක් නැතුව, තමන්ගේම කුඩා චිප් එකක් ඇතුලෙන්ම ලෝකය ඉගෙන ගැනීමේ හැකියාව ලැබෙනවා.
🚧 6. පවතින අභියෝග (Current Challenges)
HDC තාක්ෂණය තවමත් ලැබ් මට්ටමෙන් එළියට එන්න ප්රධානම බාධාව තමයි Hardware නොගැලපීම. අද අපේ ලැප්ටොප් වල තියෙන processors හදලා තියෙන්නේ 64-bit ගණනය කිරීම් වේගයෙන් කරන්නයි. බිට් 10,000ක vectors එකපාර handle කරන්න පුළුවන් චිප්ස් (In-Memory Computing Chips) තවමත් මහා පරිමාණයෙන් නිපදවන්නේ නෑ. IBM සහ Intel සමාගම් මේ වෙනුවෙන් විශේෂිත Neuromorphic Chips නිර්මාණය කරමින් පවතිනවා.
Hyperdimensional Computing කියන්නේ පරිගණක විද්යාවේ ඊළඟ මහා පිම්මයි. බිට් වල සිරවෙලා සිටි යුගය අවසන් කරලා, මිනිස් මොළයේ ඇති අසිරිමත් ගුණයන් කේතයන් බවට පත් කරන මේ අපූරු තාක්ෂණය ගැන ඔයාගේ අදහස කමෙන්ට් කරන්න.
Advanced Computer Science ක්ෂේත්රයේ මෙවැනි කවුරුත් නොදන්නා රහස් තොරතුරු දැනගන්න KP Tech Gear සමඟම රැඳී සිටින්න! ජය වේවා! 👇
Discussion