Deep Neural Networks
ஒன்றுக்கும் மேற்பட்ட hidden layers-ஐ உருவாக்கிக் கற்கும் நெட்வொர்க் deep நியூரல் நெட்வொர்க் அல்லது multi-layer நியூரல் நெட்வொர்க் என்று அழைக்கப்படுகிறது. Shallow-ல் நாம் ஏற்கெனவே பயன்படுத்திய எடுத்துக்காட்டு வழியாக இப்போது இதைக் கற்போம். சென்ற எடுத்துக்காட்டில் நாம் பயன்படுத்திய அனைத்து நிரலையும் இங்கும் பயன்படுத்தியுள்ளோம்.. ஒவ்வொரு லேயருக்குமான அளவுருக்களை வரையறுக்கும் இடத்திலும், அவை கணிப்புகளை நிகழ்த்தும் இடத்திலும் மட்டும் நிரல் வித்தியாசப்படுகிறது.
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 numpy as np | |
| import tensorflow as tf | |
| from sklearn.datasets import load_breast_cancer | |
| from sklearn.model_selection import train_test_split | |
| def normalize(data): | |
| col_max = np.max(data, axis = 0) | |
| col_min = np.min(data, axis = 0) | |
| return np.divide(data – col_min, col_max – col_min) | |
| (X_cancer, y_cancer) = load_breast_cancer(return_X_y = True) | |
| X_train, X_test, Y_train, Y_test = train_test_split(X_cancer, y_cancer, random_state = 25) | |
| X_train = normalize(X_train).T | |
| Y_train = Y_train.reshape(1, len(Y_train)) | |
| X_test = normalize(X_test).T | |
| Y_test = Y_test.reshape(1, len(Y_test)) | |
| X = tf.placeholder(dtype = tf.float64, shape = ([X_train.shape[0],None])) | |
| Y = tf.placeholder(dtype = tf.float64, shape = ([1,None])) | |
| layer_dims = [X_train.shape[0],8,8,1] | |
| parameters = {} | |
| for i in range(1,len(layer_dims)): | |
| parameters['W' + str(i)] = tf.Variable(initial_value=tf.random_normal([layer_dims[i], layer_dims[i-1]], dtype=tf.float64)* 0.01) | |
| parameters['b' + str(i)] = tf.Variable(initial_value=tf.zeros([layer_dims[i],1],dtype=tf.float64) * 0.01) | |
| A = X | |
| L = int(len(parameters)/2) | |
| for i in range(1,L): | |
| A_prev = A | |
| Z = tf.add(tf.matmul(parameters['W' + str(i)], A_prev), parameters['b' + str(i)]) | |
| A = tf.nn.relu(Z) | |
| Z_final = tf.add(tf.matmul(parameters['W' + str(L)], A), parameters['b' + str(L)]) | |
| cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=Z_final,labels=Y)) | |
| GD = tf.train.GradientDescentOptimizer(0.1).minimize(cost) | |
| with tf.Session() as sess: | |
| sess.run(tf.global_variables_initializer() ) | |
| for i in range(5000): | |
| c = sess.run([GD, cost], feed_dict={X: X_train, Y: Y_train})[1] | |
| if i % 1000 == 0: | |
| print ("cost after %d epoch:"%i) | |
| print(c) | |
| correct_prediction = tf.equal(tf.round(tf.sigmoid(Z_final)), Y) | |
| accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) | |
| print("Accuracy for training data:", accuracy.eval({X: X_train, Y: Y_train})) | |
| print("Accuracy for test data:", accuracy.eval({X: X_test, Y: Y_test})) |
நிரலுக்கான விளக்கம் & வெளியீடு:
cost after 0 epoch:
0.6931471575913913
cost after 1000 epoch:
0.6641999475918181
cost after 2000 epoch:
0.6641800975355493
cost after 3000 epoch:
0.2876489563036946
cost after 4000 epoch:
0.04967108208362405
Accuracy for training data: 0.9906103
Accuracy for test data: 0.91608393
மேற்கண்ட எடுத்துக்காட்டில் பயன்படுத்திய மார்பகப் புற்றுநோய்க்கான மாதிரித் தரவுகள் train_test_split மூலம் பிரிக்கப்படுவதும், பின்னர் அவை normalize செய்யப்பட்டு reshape செய்யப்படுவதும், உள்ளீட்டு தரவுகளை நியூரல் நெட்வொர்க்குக்குச் செலுத்துவதும், cost கண்டுபிடிப்பது, gradient descent மூலம் குறைந்த cost கண்டறிவது, கடைசியாக accuracy கண்டுபிடிப்பது போன்ற அனைத்து இடங்களிலும் shallow மற்றும் deep நியூரல் நெட்வொர்க் ஒரே மாதிரியாகவே செயல்படுகிறது. ஆனால் பின்வரும் ஒருசில இடங்களில் மட்டும் வித்தியாசப்படுகிறது.
1. Shallow மற்றும் deep நியூரல் நெட்வொர்க்கில் முதலாவது லேயர் உள்ளீட்டுக்கானதாகவும், கடைசி லேயர் வெளியீட்டுக்கானதாகவும் அமையும். ஆனால் இடையில் உள்ள hidden லேயரைப் பொறுத்து இரண்டும் மாறுபடும். shallow-ல் ஒரே ஒரு hidden லேயர் மட்டும் காணப்படும். deep-ல் ஒன்றுக்கும் மேற்பட்ட லேயர்கள் அமைந்திருக்கும். எனவே deep-ல் ஒவ்வொரு லேயரிலும் உள்ள nodes-க்கான அளவுருக்களை வரையறுப்பதற்கு முன்னர், மொத்தம் எத்தனை லேயர்கள் உள்ளன? அவற்றில் எத்தனை nodes உள்ளன? என்பதை நாம் வரையறுக்க வேண்டும். இதற்காக இங்கு, layer_dims = [X_train.shape[0],8,8,1] என கொடுக்கப்பட்டுள்ளது. முதலாவது லேயர் உள்ளீட்டுக்கானது என்பதால், பயிற்சித் தரவுகளில் உள்ள features-ன் எண்ணிக்கையை அளிப்பதற்காக இங்கு X_train.shape[0] என கொடுக்கப்பட்டுள்ளது. கடைசியாக உள்ள 1 என்பது வெளியீட்டு லேயரில் உள்ள nodes-ன் எண்ணிக்கை ஆகும். இடையில் உள்ள 8,8 என்பதே இரண்டு hidden லேயர்கள் உருவாகப்போவதையும், ஒவ்வொரு லேயரிலும் 8 nodes அமைந்திருப்பதையும் குறிக்கிறது.
layer_dims = [X_train.shape[0],8,8,1]
2. அடுத்ததாக Shallow-ல் ஒரே ஒரு hidden லேயரில் உள்ள 8 nodes-க்கான அளவுருக்களை w1, b1 எனும் பெயரிலும், வெளியீட்டு லேயரில் உள்ள 1 node-க்கான அளவுருக்களை w2, b2 எனும் பெயரிலும் அமைத்தோம். தற்போது deep-ல் முதல் hidden லேயருக்காக w1, b1 எனும் பெயரிலும், இரண்டாவது hidden லேயருக்காக w2, b2 எனும் பெயரிலும், வெளியீட்டு லேயருக்காக w3, b3 எனும் பெயரிலும் அளவுருக்களை அமைக்கப்போகிறோம். இந்த 6 அளவுருக்களும் for loop மூலம் உருவாக்கப்பட்டு parameters எனும் பெயரில் dictionary வடிவில் சேமிக்கப்படுகின்றன. இதில் w1 என்பது இரண்டாவது லேயருக்காக வரையறுக்கப்படுவது. இது முதலாவது லேயரிலிருந்து வரும் 30 features-க்கான 8 rows-ஐக் கொண்டிருக்கும். அவ்வாறே அடுத்தடுத்த லேயரில் உள்ள w2 , w3 ஆகியவை அதற்கு முந்தைய லேயரிலிருந்து வரும் மதிப்புக்களுக்கான அளவுருக்களை கொண்டிருக்கும்.எனவே தான் layer_dims[i], layer_dims[i-1] என கொடுக்கப்பட்டுள்ளது. layer_dims[i] என்பது weights அணியில் உள்ள row-ன் மதிப்பையும், layer_dims[i-1] என்பது அணியில் உள்ள column-ன் மதிப்பையும் குறிக்கிறது. முதலாவது லேயருக்கு எந்த ஒரு அளவுரு மதிப்பையும் வரையறுக்கத் தேவையில்லாததால், for loop-ஆனது 1 முதல் len(layer_dims) வரை அமைவதைக் காணலாம்.
parameters = {}
for i in range(1,len(layer_dims)):
parameters[‘W’ + str(i)] = tf.Variable(initial_value=tf.random_normal([layer_dims[i], layer_dims[i-1]], dtype=tf.float64)* 0.01)
parameters[‘b’ + str(i)] = tf.Variable(initial_value=tf.zeros([layer_dims[i],1],dtype=tf.float64) * 0.01)
3. Shallow-ல் உள்ள ஒரே hidden லேயர் தனக்கு முந்தைய லேயரிலிருந்து வரும் features மதிப்பையும் weights மதிப்பையும் சேர்த்து Z1, A1 எனும் மதிப்பினைக் கணக்கிடும். கடைசியில் உள்ள வெளியீட்டு லேயர் Z2 எனும் மதிப்பினை மட்டும் கணக்கிட்டு activate செய்யாமல் cost-க்குச் செலுத்தும் என்று ஏற்கெனவே பார்த்தோம். deep நியூரல் நெட்வொர்க் என்று வரும்போது முதல் hidden லேயருக்கான Z, A மதிப்புகளையும், இரண்டாவது hidden லேயருக்கான Z, A மதிப்புகளையும், கடைசி வெளியீட்டு லேயருக்கான Z மதிப்பினையும் கணக்கிட வேண்டும். இதற்காக for loop ஒன்று செயல்பட்டு முதன் முதலில் A_prev எனும் variable-ல் X-ல் உள்ள features-ன் மதிப்பு அமைக்கப்பட்டு முதல் லேயருக்கான Z , A மதிப்புகள் கணக்கிடப்படுகின்றன. பின்னர் முதல் லேயர் கணக்கிட்ட Z மதிப்பே A_prev மதிப்பாக அமைகிறது. இதை features-ஆக வைத்து அடுத்த லேயருக்கான Z, A மதிப்புகள் கணக்கிடப்படுகின்றன. கடைசி லேயருக்கான Z மதிப்பு loop முடிந்த பின் கணக்கிடப்படுகிறது.
A = X
L = int(len(parameters)/2)
for i in range(1,L):
A_prev = A
Z = tf.add(tf.matmul(parameters[‘W’ + str(i)], A_prev), parameters[‘b’ + str(i)])
A = tf.nn.relu(Z)
Z_final = tf.add(tf.matmul(parameters[‘W’ + str(L)], A), parameters[‘b’ + str(L)])
நிரலுக்கான வெளியீடு:
cost after 0 epoch:
0.6931471575913913
cost after 1000 epoch:
0.6641999475918181
cost after 2000 epoch:
0.6641800975355493
cost after 3000 epoch:
0.2876489563036946
cost after 4000 epoch:
0.04967108208362405
Accuracy for training data: 0.9906103
Accuracy for test data: 0.91608393