हम एक तंत्रिका नेटवर्क का उपयोग करके फ़ंक्शन को अनुमानित करते हैं

तंत्रिका नेटवर्क के साथ काम करने के लिए पुस्तकालयों को मास्टर करने के लिए, हम प्रशिक्षण और भविष्यवाणी के लिए तंत्रिका नेटवर्क एल्गोरिदम का उपयोग करके एक तर्क के कार्य को अनुमानित करने की समस्या को हल करेंगे।

प्रविष्टि

एक फंक्शन दिया जाए: [x0, X1] -> R

हम दिए गए फ़ंक्शन को सूत्र द्वारा अनुमानित करते हैं

P(x) = SUM W[i]*E(x,M[i]) 

जहाँ

• i = 1..n.
• M [i] R का
• डब्ल्यू [i] आर का
• ई <(एक्स, एम) = {0, एक्स <एम के लिए; 1/2, एक्स = एम के साथ; 1, एक्स> एम के लिए

जाहिर है, अंतराल (x0, X1) पर एम [i] के मूल्यों का एक समान वितरण के साथ, ऐसी मात्राएं W [i] हैं, जिसके लिए सूत्र P (x) फ़ंक्शन f (x) को लगभग अनुमानित करेगा। इसके अलावा, एम [i] के मूल्यों के लिए अंतराल (x0, X1) पर परिभाषित और आरोही क्रम में आदेश दिया गया है, हम सूत्र P (x) के लिए W [i] मात्राओं की गणना के लिए एक अनुक्रमिक एल्गोरिथ्म का वर्णन कर सकते हैं।

और यहाँ तंत्रिका नेटवर्क है

हम एक इनपुट न्यूरॉन, एक आउटपुट न्यूरॉन और एन हिडन लेयर न्यूरॉन्स के साथ तंत्रिका नेटवर्क मॉडल के सूत्र पी (एक्स) = एसयूएम डब्ल्यू [i] * ई (एक्स, एम [i]) को रूपांतरित करते हैं।

 P(x) = SUM W[i]*S(K[i]*x + B[i]) + C 

जहाँ

• चर x - "इनपुट" परत जिसमें एक न्यूरॉन होता है
• {K, B} - "छिपे" परत के पैरामीटर, जिसमें एन न्यूरॉन्स और सक्रियण फ़ंक्शन शामिल हैं - सिग्मॉइड
• {डब्ल्यू, सी} - "आउटपुट" परत के पैरामीटर, एक न्यूरॉन से मिलकर, जो इसके इनपुट की भारित राशि की गणना करता है।
• एस एक सिग्मोइड है,

जब

• "छिपी" परत K [i] = 1 के प्रारंभिक पैरामीटर
• "छिपे हुए" परत B [i] के प्रारंभिक पैरामीटर समान रूप से खंड पर वितरित किए जाते हैं (-x1, -x0)

तंत्रिका नेटवर्क K, B, W, और C के सभी पैरामीटर फ़ंक्शन f के मूल्यों के नमूनों (x, y) पर तंत्रिका नेटवर्क को प्रशिक्षित करके निर्धारित किए जाते हैं।

अवग्रह

सिगमॉइड एक चिकनी मोनोटोनिक है जो नॉनलाइनियर फ़ंक्शन को बढ़ाता है

• S (x) = 1 / (1 + exp (-x))।

कार्यक्रम

हम अपने तंत्रिका नेटवर्क का वर्णन करने के लिए टेन्सरफ़्लो पैकेज का उपयोग करते हैं।

 #        x = tf.placeholder(tf.float32, [None, 1], name="x") #        y = tf.placeholder(tf.float32, [None, 1], name="y") #   nn = tf.layers.dense(x, hiddenSize, activation=tf.nn.sigmoid, kernel_initializer=tf.initializers.ones(), bias_initializer=tf.initializers.random_uniform(minval=-x1, maxval=-x0), name="hidden") #   model = tf.layers.dense(nn, 1, activation=None, name="output") #    cost = tf.losses.mean_squared_error(y, model) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) 

ट्रेनिंग

 init = tf.initializers.global_variables() with tf.Session() as session: session.run(init) for _ in range(iterations): train_dataset, train_values = generate_test_values() session.run(train, feed_dict={ x: train_dataset, y: train_values }) 

पूरा पाठ

 import math import numpy as np import tensorflow as tf import matplotlib.pyplot as plt x0, x1 = 10, 20 #    test_data_size = 2000 #      iterations = 20000 #    learn_rate = 0.01 #   hiddenSize = 10 #    #     def generate_test_values(): train_x = [] train_y = [] for _ in range(test_data_size): x = x0+(x1-x0)*np.random.rand() y = math.sin(x) #   train_x.append([x]) train_y.append([y]) return np.array(train_x), np.array(train_y) #        x = tf.placeholder(tf.float32, [None, 1], name="x") #        y = tf.placeholder(tf.float32, [None, 1], name="y") #   nn = tf.layers.dense(x, hiddenSize, activation=tf.nn.sigmoid, kernel_initializer=tf.initializers.ones(), bias_initializer=tf.initializers.random_uniform(minval=-x1, maxval=-x0), name="hidden") #   model = tf.layers.dense(nn, 1, activation=None, name="output") #    cost = tf.losses.mean_squared_error(y, model) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) init = tf.initializers.global_variables() with tf.Session() as session: session.run(init) for _ in range(iterations): train_dataset, train_values = generate_test_values() session.run(train, feed_dict={ x: train_dataset, y: train_values }) if(_ % 1000 == 999): print("cost = {}".format(session.run(cost, feed_dict={ x: train_dataset, y: train_values }))) train_dataset, train_values = generate_test_values() train_values1 = session.run(model, feed_dict={ x: train_dataset, }) plt.plot(train_dataset, train_values, "bo", train_dataset, train_values1, "ro") plt.show() with tf.variable_scope("hidden", reuse=True): w = tf.get_variable("kernel") b = tf.get_variable("bias") print("hidden:") print("kernel=", w.eval()) print("bias = ", b.eval()) with tf.variable_scope("output", reuse=True): w = tf.get_variable("kernel") b = tf.get_variable("bias") print("output:") print("kernel=", w.eval()) print("bias = ", b.eval()) 

वही हुआ

• नीला मूल कार्य है।
• लाल रंग - फ़ंक्शन का सन्निकटन

कंसोल आउटपुट

 cost = 0.15786637365818024 cost = 0.10963975638151169 cost = 0.08536215126514435 cost = 0.06145831197500229 cost = 0.04406769573688507 cost = 0.03488277271389961 cost = 0.026663536205887794 cost = 0.021445846185088158 cost = 0.016708852723240852 cost = 0.012960446067154408 cost = 0.010525770485401154 cost = 0.008495906367897987 cost = 0.0067353141494095325 cost = 0.0057082874700427055 cost = 0.004624188877642155 cost = 0.004093789495527744 cost = 0.0038146725855767727 cost = 0.018593043088912964 cost = 0.010414039716124535 cost = 0.004842184949666262 hidden: kernel= [[1.1523403 1.181032 1.1671464 0.9644377 0.8377886 1.0919508 0.87283015 1.0875995 0.9677301 0.6194152 ]] bias = [-14.812331 -12.219926 -12.067375 -14.872566 -10.633507 -14.014006 -13.379829 -20.508204 -14.923473 -19.354435] output: kernel= [[ 2.0069902 ] [-1.0321712 ] [-0.8878887 ] [-2.0531905 ] [ 1.4293027 ] [ 2.1250408 ] [-1.578137 ] [ 4.141281 ] [-2.1264815 ] [-0.60681605]] bias = [-0.2812019] 

स्रोत कोड

https://github.com/dprotopopov/nnfunc