Machine Learning(ML) හදුනා ගනිමු(1 කොටස)

Machine Learning(ML) කියන්නේ Expert System වලට වැටෙන Artificial Intelligent වල ඇති එක් කොටසකි.මෙමගින් පද්ධති වලට ස්වයංකීය ඉගෙනීමේ හැකියවක් හා අත්දැකීම් ගොඩනගා ගැනීමේ හැකියාවක් යන්ත්‍රයකට ලබා දේ. මෙය දත්ත වලට ප්‍රවේශ කළ හැකි මෘදුකාංග සංවර්ධනය ඉලක්ක කරගෙන ඒ දත්ත භාවිතයෙන් තමාම ස්වයංක්‍රීයව ඉගෙන්වීම සිදුවේ. ඒ කියන්නේ යන්ත්‍රයට තනියම ඉගෙන ගැනීමේ හැකියාව ලබා දීමයි.  

Artificial Intelligent කියන්නේ කෘතිම බුද්ධිය නම් Machine Learning(ML) නම් එයට ඇති ඉගෙනගැනී‍මේ හැකියාවයි. දත්තයි මොළයයි තිබුණට මදී  ඉගෙනුමයි ඒවායින් වඩාත් නිවැරදි තීරණ ගැනිම ඉතා වැදගත්

ඉගෙනුම ක්‍රියාවලිය දත්ත හා නිිරික්ෂණයන්, අත්දැකීම් අධීක්ෂණයෙන්‍, pattern වලට අනුව අනාගතයට වඩාත් සුදුසුම තීරණයන් ගොඩනගනු ලබයි. මෙහි ප්‍රධාන අරමුණ වන්නේ පරිගණකයකට මිනිස් මැදිහත් වීමකින් හෝ ක්‍රියාවලි අධාරයෙන් සැකසීම්  නොකොට පරිගණකයන්ට ස්වයංකීයව ඉගෙනීමට ඉඩ ලබා දීමයි.

Machine Learning ප්‍රඩාන වශයෙන් කොටස් 3කට කැඩෙනවා. ඒවාට  Learning methods කියලා කියනවා.

• Supervised Learning
• Unsupervised Learning
• Reinforcement learning

Supervised Learning

මෙහිදී label කරන ලද නිදර්ශනයක් භාවීතයෙන් පරණ දත්ත වල සිට අලුත් දත්ත දක්වා ඉගැන්වීම් වලින් අනාගතය අවස්ථාවන් ගැන අනාවැකි ලබා ගැනීම සිදුකරයි.  ආරම්භයේ්දී training data set(input කරන data) විශ්ලේශණය කරමින් අනාවැකි Output කරන්න සූත්‍රයක්(function) හදාගන්නවා. ඉදිරියට එන දත්ත ලබා ගන්නවා වගේම අලුත් train කරන data එකක් compare කරලා දෝෂ නිර්ණය කිරීම ද මෙහි භාවිතා වන algorithm වලින් සිදුකරයි. එම ලබාගත් දෝෂයන් ට  අදාලව model යන් modify(වෙනස්) වේ.

මේකෙදී input data හා output data දෙකම වැදගත් සංරචක දෙකකි.

උදාහරණ

• ඉදිරි කාළගුණ වර්තාව
• ඉදිරි මාස 6ක කොටස් වෙළද පලේ කොටසක මිළ ගණන ය කිරීම.

ඉහත ලේබල් කරනවා කියන එකෙන් අදහස් කරන්නේ දත්ත කුමන වර්ගයේ දත්තයක්ද කියා හදුනා ගැනීමයි. උදාහරණයක්  ලෙස සැබෑ ජීවිතයේදී බල්ලන් ගත්විට, බල්ලකු හදුනා ගැනීමට බල්ලා ලෙස නම් කරගත් දත්ත උපකාරීවේ. එහි පූසා හදුනාගැනීමට පුසා කියා නම්කර ගත් දත්ත, කුරුල්ලා හදුනාගැනීමට කුරුල්ලා කියා නම්කර ගත් දත්ත අඩංගු වේ. මෙය ලේබල් කිරීම කියා හදුන්වයි.

Unsupervised Learning

මෙහිදී label කරන ලද නිදර්ශනයන් හා වර්ගීකණය දත්ත සලකා නොබැලේ.  රැස් කරගත් දත්ත වලින් Pattern එකක් හදුනා ගැනීමට මෙහි ඇති algorithm භාවිතා කරයි.

මේකෙදී input data පමණක් වැදගත් සංරචකයක් වේ.

උදාහරණ

• සමාජ ජාල අඩවියක එකට බැදුණු කණ්ඩායම් සෙවීම.
• e-commerce website එකක recommendation system

Reinforcement Learning

මෙහිදි agent කෙනෙකු යොදාගැනීම සිදුවේ. agent විසින් actions ගොඩනගමින් සිදුවන errors හා ලබාගන්නා reward සලකා බලමින් environment  එකත් එක්ක සම්බන්ධ වේ. Trial(පරික්ෂාවන්) and error search(දෝෂ සෙවීම) and delayed reward(ප්‍රමාදිති ප්‍රතිඑල) මෙයට සුවිශේෂි ලක්ෂණ වේ.

උදාහරණ

• ස්වයංක්‍රිය ධාවනය වන මෝටර් රථ
• Chess, Car, Pacman වැනි Game සදහා

මෙම පාඩම් මාලාව ඉදිරියට ගෙනයාම ඉල්ලුම මත තීරණය කෙරේ.

Access Modifiers හදුනාගනිමු

දී ඇති class කට යම් class එකක්, constructorඑකක්, attributeඑකක් හෝ method එකක් ප්‍රවේෂ කළ හැකිදැයි බලන්නේ මෙම Access Modifiers වලිනි.

Public

ඕනෑම code එකකට මෙමගින් අර්ථ දක්වන Members(attributes and methods) ලට ප්‍රවේශ විමට ඉඩ ලබා දේ. එහිදි  code එක තියෙන් තැනවත් package එක වත් අදාළ වෙන්නේ නැහැ. ඒ කියන්නේ වෙන වෙන class වලට හා වෙන වෙත් package වලට public වලින් අර්ථ දක්වන Members ලට ප්‍රවේශ කරන්න පුලුවන් බවයි.

1. public class Clock {
2.     public long time = 0;
3. }
4. 
   
5. 
   
6. public class ClockReader {
7.     Clock clock = new Clock();
8. 
   
9.     public long readClock{
10.         return clock.time;
11.     }
12. }

ඉහත උදහරණය සලකමු. line 2 දී time කියලා variable එක අර්ථ දක්වලා තියෙනවා. line 7 දී Clock කියන class  එක refer කරලා clock නමින් Clock object එකක් හදලා තියෙනවා. line 9 දී  readClock method එක තුළින් Clock එකේ time එකේ data කෙළින්ම ලබාගන්නවා.

Private

මෙමගින් අර්ථ දක්වන Members(attributes and methods) ලට ප්‍රවේශ විමට  හැකිවන්නේ එම Members ලා අයත් වන class එකේම අනෙක් Members ලටම පමණි.

උදා:

public class Person {

    private long age= 0;

}

මෙහි time කියන variable එකට Access කළ හැක්කේ Clock කියනclass එකේ members ලටම පමණී. නමුත්  accessor methods හරහා මෙම variable එකට ප්‍රවේශ විය හැක. එය Encapsulation කතා කරන ලදී. 

Constructor එකක් private වුනොත් එකකෙන් කියන්නේ ඒ Constructor එක  පිටත ඇති වෙන class එකක define කරන්න බැරි බවයි. එය ගතහැකි වන්නේ ඒ class එකේම ඇති වෙනත් Constructor එකකින් හෝ වෙනත් static method එකකිනි.

1.  public class Man {
2.     private int age= 0;
3. 
   
4.     private Man(intage) {
5.         this.age= age;
6.     }
7. 
   
8.     public Man(int age, int timeOffset) {
9.         this(age);
10.         this.age+= timeOffset;
11.     }
12. 
    
13.     public static Man newAge() {
14.         return new Clock(System.currentTimeMillis());
15.     }
16. 
    
17. }

ඉහත උදාහරණය සලකන්න. line 4 දී Constructor, private  වෙලා තියෙනවා. එයින් කියැවෙන්නේ ඒ  Constructor වෙනත් Class එකක define කරන්න බැරි බවයි. line 8 දී ඊළග Constructor එක define එක තියෙනවා, ඒක publicවෙලායි තියෙන්නේ. එකේ අදහස ඒ  Constructor වෙනත් ඕනෑම Class එකක define කරන්න පුලුවන් බවයි.  line 9 දී  line 4 හි ඇති Constructor එක "this" keyword එකෙන් අරගෙන තියෙනවා. line 13 දී private වුන Constructor එක static method එකකින් අරගෙන තියෙනවා.

මෙය වෙනත් class එකක පහත ආකර දෙකනේ කැමති විදිහකට define කරන්න පුලුවන්.
පළමු ආකාරය - public constructor යොදාගෙන.
Man m1=new Man(27, 3);
දෙවන ආකාරය - static method යොදාගෙන.
Man m2=Man.newAge();

Protected

මේක ටිකක් වෙනස්ම access modifier එකක් වෙනවා. මේ තරමක් default එකට ටිකක් සමාන වුනත් Inheritance වලදී ටිකක් වෙනස්. protected වලින් define කරන member කෙනෙක් ට access  කරන්න හැකි වෙන්නේ ඒ package එකේ ඇති ඕනෑම Class  එකකට හා වෙනත් package  එකක ඇති sub class(child class) එකකටම පමණී. 

උදා1.

1. public class Clock {
2.     protected long time = 0;    // time in milliseconds
3. }
4. 
   
5. public class SmartClock() extends Clock{
6.     public long getTimeInSeconds() {
7.         return this.time / 1000;
8.     }
9. }

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් super class එකේ protected වූ time කියන variable එකට access කරන ආකාරයයි. 

උදා2.

1. package p1; 
2. public class Clock {
3.     protected long time = 0;    // time in milliseconds
4. }

1. package p2; 
2. import p1.*; 
3. public class SmartClock() extends Clock{
4.     public long getTimeInSeconds() {
5.         return this.time / 1000;
6.     }
7. }

ඉහත උදාහරණයේ දැක්වෙන්නේ  වෙනස්ම package දෙකකදී sub class එකක් super class එකේ protected වූ time කියන variable එකට access කරන ආකාරයයි. 

උදා3.

1. public class Clock {
2.     protected long time = 0;    // time in milliseconds
3. }
4. 
   
5. public class SmartClock(){
6.     Clock  clock=new Clock  ();
7.     public long getTimeInSeconds() {
8.         return clock.time / 1000;
9.     }
10. }

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් නොවන විට එක class එකක protected වූ time කියන variable එකට අනෙක්  class එක access කරන ආකාරයයි. 

default 

මෙය package modifier කියලත් හදුන්වනවා. මෙයට වෙනම keyword එකක් නැහැ. හිස් අවකාශයකින් දකවනවා. සෑම විටම එකම package එකේ classes අතර data වලට access කිරීමේ හැකියාව ලබා දේ. නමුත් වෙනත් package වල  data වලට access  කිරීමට  කුමන අයුරිකින් වත් නොහැක.

එය protected මෙන් sub class එකකට එකකින් ලැබෙන්නාක් මෙන් ලබා ගතනොහැක.

public class Clock {

    long time = 0;

}

public class ClockReader {

    Clock clock = new Clock();

    public long readClock{

        return clock.time;

    }

}

ඉහත උදාහරණයේ දැක්වෙන්නේ එකම package එකේ දී sub class එකක් super class එකේ default වූ time කියන variable එකට access කරන ආකාරයයි. 

Class Access Modifiers

class එකේ membersලා define කරන්න ඉහත සියලුම Modifiers භාවිතා කළත් 

class හදද්දි ඒ Modifiers සියල්ලම භාවිතා කරන්න බැහැ. Private හා Protected යන Modifiers දෙකම class එකක් හදන්න යොදාගන්නේ නැහැ. ඒවා යෙදීමෙන් code වලංගු භාවය නැතිවේ.

බොහෝ විට class එකක් හදන්න යොදාගන්නේ public හා default modifiers ය. යම් modifier එකක් class  එකකට යෙදෙන විට class  එකේ membersලට modifier  දී තිබුණත් මුලින්ම class  එකේ ඇති modifier එක සලකා බැලේ පසුව තමා class  එකේ members ලගේ modifier සලකා බලන්නේ.

class එක default නම් එකේ members ලා public වුනත් නැතත් වෙනත් package වල class වලට ඒ members ලගේ data වලට access කරන්න බැහැ. එමෙන්ම class එක public වුනොත් class එකේ members ලගේ access modifiers සලකා බැලිය යුතුවේ.

සාරංශය

geeksforgeeks site එකෙන්

Object Oriented Methodology

ලෝව මුල්ම කාලයේ බිහි වු(Machine language, Assembly language හැරුනු විට) ක්‍රමලේඛණ බොහොමයක් වස්තු පාදක කරගත් ඒවා නොවේ. එවැනි language හැදින්වූයේ Procedural හෝ Functional language කියාය. ප්‍රධාන වශයෙන් මෙහි variables, methods අර්ථ දැක්වීම් හා library import කිරීම් අඩංගු වේ.

මෙම Procedural languages පසු කලීනව, විශාල ක්‍රමලේඛණය පැමිණීමත් හා තාක්ෂණයේ දියුණුවත් සමග ඉවත් විය. නමුත් මෙම භාෂාවන් වර්ගය සුලු වශයෙන් භාවීතා වේ. අද වන විට වස්තු පාදක ක්‍රමලේඛණය පෙර තිබු Functional languages වල දුර්වලතා මග හරිමින් ක්‍රමලේඛ කරුවන් අතර ඉහල ජනප්‍රියතාවයක් හිමි කරගෙන තිබේ.

Object-oriented programming enables you to develop large-scale software and GUIs effectively

මෙයින් කියැවෙන්නේ වස්තු පාදක ක්‍රමලේඛණය මහා පරිමානයේ මෘදුකාංග හා අතුරු මූණත් කර්යක්ෂමව ගොඩනැංවීමට ඉඩ ලබා දෙන බවක්ය. Procedural languages වලදි code ලියැවුනේ එකම document එකේ line එකෙන් line එකට පහළට පහළට ගමන් කරන ලෙසිනි. මේකේදී හොද software එකක් ලියද්දී පේළිගාණ විශාල වෙනවා. එවිට දෝෂ(error එකක්) සොයා ගැනීම ටිකක් අපහසුයි.

මෙහි ඇතිවන අපහසුතා වූයේ,

1.       ක්‍රමලේඛය විශාල වන විට කියැවීමේ අපහසුව

2.       ක්‍රමලේඛය වෙනස් කිරීමේ අපහසුව

3.       තනි ගොනුවක ලියැවෙන නිසා memory එකේ අනවශ්‍ය ඉඩක් ගැනීම

ඉහත අපහසුතා මගින්

1.       කේත සම්පූර්ණයෙන් කියැවීම නිසා කාලය අපතේ යාම

2.       Line වැඩි නිසා කේත වල සංකිර්ණ තාවය වැඩියි

3.       වෙනස් කිරීමේ අපහසුව නිසා flexibility එක අඩුයි

Procedural languages වලට වැටෙන ක්‍රමලේඛන වන්නේ C, Pascal වැනි languages. දැනට  සුලු වශයෙන් ක්‍රමලේඛයන් මේවා යොදාගන්නවා. නමුත් Operating System, Hardware වලට, හා Microcontroller වල ක්‍රමලේඛ ලිවීම සදහා මෙම භාෂාවන් සුලබව යොදා ගන්නවා.

වස්තු පාදක ක්‍රමලේඛණයේදී එකම document එකේ ලියනවා වෙනුවට ඒ code එක document කිහිපයකට කඩලා ලියනවා. පසුව එ්වා අදාළ document එකක් සමගම සම්බන්ධ කරනවා. උදාහරණයක් ලෙස් Banking System සලකමු, එහි අතුරුමූණත සදහා එකක් document, කේත Operating System එකේ ධාවනය කරන්න තවත් document එකක් අදාල bank account වලට තවත්  document එකක්, transaction වලට තවත්  document එකක් හා user details වලට වෙනම එකක් සාදයි.