Perceptron என்பதே neural networks-க்கான அடிப்படை. இது ஒரு நேர்கோடு மூலம் பிரிக்க வல்ல தரவுகளுக்கான binary classification algorithm ஆகும். ஆனால் இது logistic regression போன்று தனது கற்றலை அமைக்காது. ஒரு நியூரான் எவ்வாறு கொஞ்சம் கொஞ்சமாக கற்றுக் கொள்கிறதோ அதனை அடிப்படையாக வைத்து, பயிற்சித் தரவுகளைப் பற்றிப் படிப்படியாகக் கற்றுக் கொள்கிறது. கீழ்க்கண்ட எடுத்துக்காட்டில் 4 பயிற்சித் தரவுகள் கொடுக்கப்பட்டுள்ளன. அதில் x1, x2 எனும் 2 features-ஐ வைத்து 0 அல்லது 1 எனும் வகையின் கீழ் அமையும் தரவுகள் பயிற்சிக்கு உள்ளன.
x1 , x2 , y
[0.4 ,0.3 ,1],
[0.6 ,0.8 ,1],
[0.7 ,0.5 ,1],
[0.9 ,0.2 ,0]
Neural Networks என்பது நேரடியாக கற்றுக் கொள்ளாமல் இடையில் பல activation units-ஐ உருவாக்கி அதனடிப்படையில் கற்றுக் கொள்ளும் என்று ஏற்கெனவே பார்த்தோம். இங்கும் features-ஐயும் அதனுடைய weights-ஐயும் இணைத்து நேரடியாக hypothesis-ஐக் கற்றுக் கொள்ளாமல், இடையில் activation unit-ஐக் கணக்கிடுகிறது. பின்னர் அம்மதிப்பின் அடிப்படையில் தரவுகளுக்கு ஏற்றார் போன்று weights-ஐ மாற்றி சரியான முறையில் கற்றுக் கொள்கிறது. இது பின்வருமாறு. parameters என்பதே இங்கு weights என அழைக்கப்படுகிறது.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| def predict(row, weights): | |
| activation = weights[0] | |
| for i in range(len(row)-1): | |
| activation += weights[i + 1] * row[i] | |
| return 1.0 if activation > 0.0 else 0.0 | |
| def train_weights(dataset, l_rate, n_epoch): | |
| weights = [0.0 for i in range(len(dataset[0]))] | |
| for epoch in range(n_epoch): | |
| sum_error = 0.0 | |
| for row in dataset: | |
| error = row[-1] – predict(row, weights) | |
| sum_error += error**2 | |
| weights[0] = weights[0] + l_rate * error | |
| for i in range(len(row)-1): | |
| weights[i + 1] = weights[i + 1] + l_rate * error * row[i] | |
| print('epoch=%d, error=%.2f' % (epoch, sum_error)) | |
| print (weights) | |
| dataset = [[0.4,0.3,1], | |
| [0.6,0.8,1], | |
| [0.7,0.5,1], | |
| [0.9,0.2,0]] | |
| l_rate = 0.1 | |
| n_epoch = 6 | |
| train_weights(dataset, l_rate, n_epoch) |
நிரலுக்கான வெளியீடு:
epoch=0, error=2.00
epoch=1, error=2.00
epoch=2, error=2.00
epoch=3, error=2.00
epoch=4, error=1.00
epoch=5, error=0.00
[0.1, -0.16, 0.06999999999999998]
கணக்கீடுகள் நிகழும் விதம்:
முதலில் கொடுக்கப்பட்டுள்ள features-வுடன் இணைக்கப்பட வேண்டிய weights-ன் மதிப்பாக 0, 0, 0 என்பதை வைத்து தனது கற்றலைத் தொடங்குகிறது. முதலில் உள்ள பூஜ்ஜியம், x0 எனும் bias unit-க்கான மதிப்பாகும். இந்த bias unit எப்போதும் 1 எனும் மதிப்பையே பெற்றிருக்கும் என ஏற்கெனவே பார்த்தோம். அடுத்தடுத்து உள்ள பூஜ்ஜியங்கள் x1, x2 -க்கான weights மதிப்பாகும். இவற்றை வைத்து பின்வரும் வாய்ப்பாட்டின் மூலம் முதல் தரவுக்கான [0.4 ,0.3 ,1] activation unit கணக்கிடப்படுகிறது. இதுவே heaviside activation function என்று அழைக்கப்படுகிறது. sigmoid போன்று இது மற்றொரு வகை.
Activation_unit_1 = w0.x0 + w1.x1 + w2.x2
= 0(1) + 0(0.4) + 0(0.3)
= 0
if Activation_unit > 0, Predict 1
else Predict 0.
இவ்வாறு கண்டறிந்த மதிப்பு, 0-ஐ விட அதிகமாக இருந்தால் 1 எனவும், இல்லையெனில் 0 எனவும் predict செய்யும். இங்கு 0 என predict செய்யும். ஆனால் பயிற்சித் தரவில் 1 என கொடுக்கப்பட்டுள்ளது. இவ்வாறு பயிற்சித் தரவில் உள்ள மதிப்பு, activation unit கணித்த மதிப்புடன் ஒத்துப் போகவில்லையெனில்(1 != 0) weights-ன் மதிப்பினை மாற்றி அடுத்த தரவுக்கு பயிற்சி அளிக்க வேண்டும். பின்வரும் வாய்ப்பாட்டின் மூலம் புதிய weights கணக்கிடப்படுகிறது.
w0 = w0 + learning_rate * (actual-predict) * x0
இதில் ஒவ்வொரு weight-ம் தன்னுடைய பழைய மதிப்புடன் learning rate-ஐக் கூட்டுகிறது. இந்த learning rate என்பது gradient descent-ல் நாம் பயன்படுத்துகின்ற மதிப்பினை ஒத்ததே ஆகும். அதாவது update-ன் அளவானது இந்த learning rate மூலம் கட்டுப்படுத்தப்படுகிறது. இதன் மதிப்பு 0.1 என வைக்கப்பட்டுள்ளது. அதாவது மிகச்சிறிய அளவில் இதனுடைய weights, adjust செய்யப்பட வேண்டும் என்பதையே இது குறிக்கிறது. பின்னர் இக்கூட்டுத் தொகையுடன் உண்மையான மதிப்புக்கும் – கணிப்புக்கும் உள்ள வேறுபாட்டின் மதிப்பும், weights இணைக்கப்பட்டுள்ள features-ன் மதிப்பும் பெருக்கப்படுகிறது. இவ்வாறாக புதிய weight-ன் மதிப்பு கணக்கிடப்படுகிறது.
இந்த வாய்ப்பாட்டைப் பயன்படுத்திக் கணக்கிடப்பட்ட weights-ன் மதிப்புகள் பின்வருமாறு.
w0 = 0 + 0.1 * 1 * 1 = 0.10
w1 = 0 + 0.1 * 1 * 0.4 = 0.04
w2 = 0 + 0.1 * 1 * 0.3 = 0.03
இத்தகைய புதிய weights-ஐப் பயன்படுத்தி 2-வது தரவுக்கான [0.6 ,0.8 ,1] activation unit பின்வருமாறு கணக்கிடப்படுகிறது.
Activation_unit_2 = w0.x0 + w1.x1 + w2.x2
= 0.1(1) + 0.04(0.6) + 0.03(0.8)
= 0.1 + 0.024 + 0.024
= 0.148
இங்கு 0-ஐ விட அதிகமாக இருப்பதால் 1 என predict செய்யும். பயிற்சித் தரவிலும் 1 என உள்ளது. ஆகவே weights-ஐ மாற்றாமல் 3-வது தரவுக்கான [0.7 ,0.5 ,1] activation unit கணக்கிடப்படுகிறது.
Activation_unit_3 = w0.x0 + w1.x1 + w2.x2
= 0.1(1) + 0.04(0.7) + 0.03(0.5)
= 0.1 + 0.028 + 0.015
= 0.143
இங்கும் 1 என predict செய்கிறது. பயிற்சித் தரவிலும் 1 என உள்ளது. ஆகவே weights-ஐ மாற்றாமல் 4-வது தரவுக்கான [0.9 ,0.2 ,0] activation unit கணக்கிடப்படுகிறது.
Activation_unit_4 = w0.x0 + w1.x1 + w2.x2
= 0.1(1) + 0.04(0.9) + 0.03(0.2)
= 0.1 + 0.036 + 0.006
= 0.142
w0 = 0.1 + 0.1 * -1 * 1 = 0.0
w1 = 0.04 + 0.1 * -1 * 0.9 = -0.05
w2 = 0.03 + 0.1 * -1 * 0.2 = 0.01
இங்கு 1 என கணிக்கிறது. ஆனால் உண்மையில் 0 என உள்ளது. எனவே மீண்டும் weights கணக்கிடப்படுகிறது. இவ்வாறாக கொடுக்கப்பட்டுள்ள 4 பயிற்சித் தரவுகளில் 2 சரியாக கணிக்கப்பட்டுள்ளது, 2 தவறாக கணிக்கப்பட்டுள்ளது. இத்துடன் முதல் epoch முடிகிறது. அதாவது ஒரு சுற்றில் அனைத்துப் பயிற்சித் தரவுகளும் மேற்கண்ட சோதனைக்கு உட்படுத்தப்பட்டு, algorithm கற்றுக் கொள்வதையே 1 epoch என்கிறோம். இது பின்வருமாறு.
முதல் epoch-ன் கடைசியில் புதிதாக கணக்கிடப்பட்ட மதிப்புகளே அடுத்த epoch-ன் பயிற்சித் தரவுகளுடன் சேர்த்து பயன்படுத்தப்படுகிறது. இவ்வாறாக 6 முறை epochs கணக்கிடப்படுகிறது. இது பின்வருமாறு.
6-வது epoch-ல் தான், அனைத்துப் பயிற்சித் தரவுகளும் சரியாக கணிக்கப்படுகின்றன. எனவே அதனுடைய weights-ஐயே பிற்காலத் தரவுகளை கணிப்பதற்கான algorithm-ன் weights-ஆக நாம் எடுத்துக் கொள்ளலாம். இவ்வாறாக முதல் தரவின் கணிப்பு சரியாக இருந்தால், அடுத்த தரவிற்குச் செல்லும். இல்லையெனில் weights-ஐ மீண்டும் கணக்கிட்டு அடுத்த தரவிற்குச் செல்லும். கணிப்புகள் அனைத்தும் சரியாக நிகழும் வரை இதே முறை பின்பற்றப்படுவதால், இது error-driven learning algorithm என்று அழைக்கப்படுகிறது. இதனடிப்படையில் அமைகின்ற MLP (Multiple Linear Perceptron) என்பதே neural networks-ஐ உருவாக்குகிறது.