Single Input Neuron
இப்பகுதியில் உள்ளீட்டு அடுக்கில் ஒரு நியூரானையும், வெளியீட்டு அடுக்கில் ஒரு நியூரானையும் வைத்து கணிப்பினை நிகழ்த்துவது எப்படி என்று பார்க்கலாம். இதனை நாம் tensorflow பயன்படுத்தி செய்து பார்க்கப் போகிறோம்.
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
| import tensorflow as tf | |
| X = tf.constant(0.5) | |
| Y = tf.constant(0.0) | |
| W = tf.Variable(1.0) | |
| predict_Y = tf.multiply(X,W) | |
| cost = tf.pow(Y – predict_Y,2) | |
| min_cost = tf.train.GradientDescentOptimizer(0.025).minimize(cost) | |
| for i in [X,W,Y,predict_Y,cost]: | |
| tf.summary.scalar(i.op.name,i) | |
| summaries = tf.summary.merge_all() | |
| with tf.Session() as s: | |
| summary_writer = tf.summary.FileWriter('single_input_neuron',s.graph) | |
| s.run(tf.global_variables_initializer()) | |
| for i in range(100): | |
| summary_writer.add_summary(s.run(summaries),i) | |
| s.run(min_cost) |
உள்ளீட்டு அடுக்கில் உள்ள நியூரான் உள்ளீட்டு மதிப்புடன் weight எனும் அளவுறுவினை இணைத்து தனது கணிப்பினை நிகழ்த்தும் என்று அறிவோம். இங்கு 0.5 எனும் உள்ளீட்டு மதிப்பினை எடுத்துக் கொண்டு, அதனுடன் 1.0 எனும் weight மதிப்பினை இணைத்து நிகழ்த்தியுள்ள கணிப்பு predict_y எனும் பெயரில் சேமிக்கப்பட்டுள்ளது. உண்மையான 0.0 எனும் வெளியீட்டு மதிப்பு y எனும் பெயரில் உள்ளது. இவ்விரண்டுக்கும் உள்ள வேறுபாடே cost என்று அழைக்கப்படுகிறது. இதனைக் கணக்கிட பழைய முறையான square method -ஐ இங்கு பயன்படுத்தியுள்ளோம். cost மதிப்பினை குறைப்பதற்கான gradient descent எனும் தத்துவத்தை டென்சாரில் ஒற்றை வரியில் செயல்படுத்தி விடலாம். இது learning_rate எனும் மதிப்பினை தனது parameter-ஆக எடுத்துக்கொண்டு 100 சுற்றுகளில் cost-ஐக் குறைக்க முற்படுகிறது.
அடுத்ததாக இவற்றையெல்லாம் டென்சார் திரையில் வெளிப்படுத்துவதற்கான நிரல் கொடுக்கப்பட்டுள்ளது. எந்தெந்த மதிப்புகளையெல்லாம் திரையில் வெளிப்படுத்த விரும்புகிறோமோ, அவற்றையெல்லாம் ஒரு list-க்குள் அமைத்து for loop-மூலம் தொடர்ச்சியாக scalar_summary() எனும் function-க்குள் செலுத்துகிறோம். இதன் arguments-ஆக list-ல் உள்ள ஒவ்வொரு டென்சாரின் பெயரும், அதன் கீழ் அமைந்துள்ள மதிப்புகளும் கொடுக்கப்பட்டுள்ளன. அதாவது ஒவ்வொரு டென்சாரின் கீழும் அமைந்துள்ள மதிப்புகளின் சுருக்க நெறிமுறையே (summary protocol buffer) இதன் வெளியீடாக அமைகிறது. இந்த சுருக்க நெறிமுறைகளின் அடிப்படையில் சுருக்கம் செய்யப்பட்ட அனைத்து டென்சார்களையும் ஒருங்கிணைப்பதற்கு summary.merge_all() பயன்படுகிறது.
பின்னர் ஒரு session-ஐ உருவாக்கி ஒருங்கிணைக்கப்பட்ட அனைத்து டென்சார்களின் சுருக்க மதிப்புகளையும் வரைபடமாக வரைந்து காட்ட tf.summary.FileWriter() பயன்பட்டுள்ளது. இது தற்போதைய directory-ல் ’single_input_neuron’ என்ற பெயரில் ஒரு folder-ஐ உருவாக்கும். இதற்குள் தான் அனைத்து டென்சார்களின் summary மதிப்புகளும் கோப்பு வடிவில் asynchronous முறையில் சேர்க்கப்படும். பின்னர் for loop மூலம் 100 சுற்றுகளை உருவாக்கி, ஒவ்வொரு சுற்றிலும் 0.025 எனும் கற்றல் விகிதத்தின் அடிப்படையில் அமைந்த புதிய parameter மதிப்புகளுக்கு summaries-ஐ உருவாக்கி இணைக்கிறது. டென்சார் திரையில் வரைபடத்தைக் காண்பதற்கான பதிவுக் கோப்புகள் (log files) அனைத்தும் இம்முறையிலேயே உருவாக்கப்படும்.
அடுத்ததாக கீழ்க்கண்ட கட்டளையை இயக்கி டென்சார் திரையில் சென்று பார்க்கவும்.
$ tensorboard –logdir=single_input_neuron
TensorBoard 1.13.1 at shrinivasan-Lenovo-Z50-70:6006 (Press CTRL+C to quit)
திரையில் Scalars மற்றும் Graphs எனும் இரண்டு பிரிவுகள் காணப்படும். Scalar எனும் பிரிவில் list-க்குள் நாம் கொடுத்து வெளிப்படுத்தச் சொல்லிய ஒவ்வொரு மதிப்புகளுக்குமான வரைபடம் பின்வருவதுபோல் காணப்படும். எடுத்துக்காட்டாக predict_y தாங்கியுள்ள மதிப்பு 100 சுழற்சிகளில், ஒவ்வொரு சுழற்சியிலும் 0.0 எனும் உண்மையான y-மதிப்புக்கு நெருக்கத்தில் எவ்வாறு குறைந்து கொண்டே வருகிறது என்பது வரைந்து காட்டப்பட்டுள்ளது. அடுத்ததாக Graphs எனும் பகுதியில் டென்சார்களுக்கிடையில் நடைபெற்ற கணக்கீடுகளுக்கான வரைபடம் வரைந்து காட்டப்பட்டுள்ளது.
