किताब "पायथन में दीप सुदृढीकरण सीखने। OpenAI जिम और TensorFlow पेशेवरों के लिए »

हाय, हब्रोज़ितेली! सुदृढीकरण सीखना कृत्रिम बुद्धिमत्ता का सबसे लोकप्रिय और आशाजनक क्षेत्र है। पायथन में प्रैक्टिकल लर्निंग आरएल आपको न केवल बुनियादी, बल्कि सुदृढीकरण के साथ उन्नत गहन शिक्षण एल्गोरिदम में भी मदद करेगा। यह पुस्तक एमओ डेवलपर्स और गहरी सीखने के उत्साही लोगों के लिए अभिप्रेत है जो कृत्रिम बुद्धि में रुचि रखते हैं और सुदृढीकरण सीखने की विधि सीखना चाहते हैं। इस पुस्तक को पढ़ें और काम के अंदर या बाहर व्यावहारिक उदाहरणों को लागू करके प्रबलित शिक्षा के विशेषज्ञ बनें। रैखिक बीजगणित, गणितीय विश्लेषण और पायथन प्रोग्रामिंग भाषा का ज्ञान आपको प्रस्तुति के तर्क को समझने में मदद करेगा।

अंश। LSTM RNN का उपयोग करके गीत उत्पन्न करना

अब देखते हैं कि Zayn मलिक गीत उत्पन्न करने के लिए LSTM का उपयोग कैसे करें। Zane के गाने के बोल डेटासेट डाउनलोड किए जा सकते हैं ।

आवश्यक पुस्तकालयों के आयात से काम शुरू होता है:

import tensorflow as tf import numpy as np 

फिर गीत के साथ फाइल पढ़ी जाती है:

 with open("Zayn_Lyrics.txt","r") as f: data=f.read() data=data.replace('\n','') data = data.lower() 

सुनिश्चित करें कि डेटा सफलतापूर्वक अपलोड किया गया है:

 data[:50] "now i'm on the edge can't find my way it's inside " 

अब सभी वर्ण चर__चर्च में संग्रहीत हैं:

 all_chars=list(set(data)) 

अद्वितीय वर्णों की संख्या को अनूठे_चरों में संग्रहीत किया जाता है:

 unique_chars = len(all_chars) 

और वर्णों की कुल संख्या को कुल total_chars में संग्रहीत किया जाता है:

 total_chars =len(data) 

पहले हम प्रत्येक वर्ण को एक सूचकांक देते हैं। char_to_ix में वर्ण की मैपिंग इंडेक्स में होगी, और ix_to_char में कैरेक्टर की मैपिंग इंडेक्स में होगी:

 char_to_ix = { ch:i for i,ch in enumerate(all_chars) } ix_to_char = { i:ch for i,ch in enumerate(all_chars) } 

एक उदाहरण:

 char_to_ix['e'] 9 ix_to_char[9] e 

फिर जनरेट_बैच फ़ंक्शन को परिभाषित किया जाता है, जो इनपुट और लक्ष्य मान उत्पन्न करता है। लक्ष्य मान इनपुट मूल्य बार i की पारी के बराबर हैं।

उदाहरण के लिए, यदि इनपुट = [१२,१३,२४] १ के शिफ्ट मान के साथ, तो लक्ष्य मान [१३,२४] होगा:

 def generate_batch(seq_length,i): inputs = [char_to_ix[ch] for ch in data[i:i+seq_length]] targets = [char_to_ix[ch] for ch in data[i+1:i+seq_length+1]] inputs=np.array(inputs).reshape(seq_length,1) targets=np.array(targets).reshape(seq_length,1) return inputs,targets 

हम अनुक्रम की लंबाई, सीखने की गति और नोड्स की संख्या निर्धारित करेंगे, जो कि न्यूरॉन्स की संख्या के बराबर है:

 seq_length = 25 learning_rate = 0.1 num_nodes = 300 

LSTM RNN का निर्माण करें। TensorFlow LSTM कोशिकाओं के निर्माण के लिए BasicLSTMCell () फ़ंक्शन प्रदान करता है; आपको LSTM सेल में इकाइयों की संख्या और उपयोग किए जाने वाले सक्रियण फ़ंक्शन को निर्दिष्ट करना होगा।

इसलिए, हम LSTM सेल बनाते हैं और tf.nn.dynamic_rnn () फ़ंक्शन का उपयोग करके इस सेल के साथ RNN नेटवर्क का निर्माण करते हैं, जो आउटपुट और स्टेट वैल्यू लौटाता है:

 def build_rnn(x): cell= tf.contrib.rnn.BasicLSTMCell(num_units=num_nodes, activation=tf.nn.relu) outputs, states = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32) return outputs,states 

अब इनपुट X के लिए एक विकल्प बनाएं और Y को लक्षित करें:

 X=tf.placeholder(tf.float32,[None,1]) Y=tf.placeholder(tf.float32,[None,1]) 

X और Y को int में बदलें:

 X=tf.cast(X,tf.int32) Y=tf.cast(Y,tf.int32) 

X और Y के लिए एक दृश्य भी बनाएं:

 X_onehot=tf.one_hot(X,unique_chars) Y_onehot=tf.one_hot(Y,unique_chars) 

Build_rnn फ़ंक्शन को कॉल करके RNN से आउटपुट और स्टेट्स प्राप्त करें:

 outputs,states=build_rnn(X_onehot) 

उत्पादन को स्थानांतरित करें:

 outputs=tf.transpose(outputs,perm=[1,0,2]) 

हम वज़न और ऑफ़सेट शुरू करते हैं:

 W=tf.Variable(tf.random_normal((num_nodes,unique_chars),stddev=0.001)) B=tf.Variable(tf.zeros((1,unique_chars))) 

हम आउटपुट को वजन से गुणा करके और ऑफसेट को जोड़कर आउटपुट की गणना करते हैं:

 Ys=tf.matmul(outputs[0],W)+B 

अब हम सॉफ्टमैक्स सक्रियण का प्रदर्शन करेंगे और संभावनाएँ प्राप्त करेंगे:

 prediction = tf.nn.softmax(Ys) 

Cross_entropy के नुकसान की गणना निम्नानुसार की जाएगी:

 cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels =Y_onehot,logits=Ys)) 

हमारा लक्ष्य नुकसान को कम करना है, इसलिए हम नेटवर्क के लिए प्रचार प्रसार करेंगे और धीरे-धीरे वंश को आगे बढ़ाएंगे:

 optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cro ss_entropy) 

तब सहायक फ़ंक्शन भविष्यवाणी को परिभाषित किया जाएगा, जो RNN मॉडल के अनुसार अगले अनुमानित प्रतीक के सूचक देगा:

 def predict(seed,i): x=np.zeros((1,1)) x[0][0]= seed indices=[] for t in range(i): p=sess.run(prediction,{X:x}) index = np.random.choice(range(unique_chars), p=p.ravel()) x[0][0]=index indices.append(index) return indices 

फिर, बैच_साइज़ पैकेट का आकार, पैकेट की संख्या और युग की संख्या, साथ ही पैकेट को बनाने के लिए शिफ्ट मान सेट किया जाएगा:

 batch_size=100 total_batch=int(total_chars//batch_size) epochs=1000 shift=0 

अंत में, हम एक TensorFlow सत्र बनाते हैं और एक मॉडल बनाते हैं:

 init=tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for epoch in range(epoch): print("Epoch {}:".format(epoch)) if shift + batch_size+1 >= len(data): shift =0 #         # generate_batch,      shift, #    for i in range(total_batch): inputs,targets=generate_batch(batch_size,shift) shift += batch_size # calculate loss if(i%100==0): loss=sess.run(cross_entropy,feed_dict={X:inputs, Y:targets}) #      #    predict index =predict(inputs[0],200) #     ix_to_char #    txt = ''.join(ix_to_char[ix] for ix in index) print('Iteration %i: '%(i)) print ('\n %s \n' % (txt, )) sess.run(optimiser,feed_dict={X:inputs,Y:targets}) 

जैसा कि आप परिणाम से देख सकते हैं, प्रारंभिक युग में, आउटपुट में यादृच्छिक वर्ण होते हैं, लेकिन जैसा कि आप सीखते हैं, परिणाम बेहतर होते हैं:

 Epoch 0: Iteration 0: wsadrpud,kpswkypeqawnlfyweudkgt,khdi nmgof' u vnvlmbis . snsblp,podwjqehb,e;g- 'fyqjsyeg,byjgyotsrdf;;u,ha;ik'sfc;dvtauofd.,q.;npsw'wjy-quw'quspfqw- . . . Epoch 113: Iteration 0: i wanna see you, yes, and she said yes! 

लेखक के बारे में

सुधरासन रविचंद्रन डेटा प्रोसेसिंग और विश्लेषण के विशेषज्ञ, कृत्रिम बुद्धिमत्ता के उत्साही प्रशंसक और वीडियो ब्लॉगर हैं। उन्होंने ऐनी विश्वविद्यालय से कंप्यूटर विज्ञान में स्नातक की डिग्री हासिल की और प्राकृतिक भाषा प्रसंस्करण और कंप्यूटर दृष्टि सहित गहन सीखने और प्रबलित शिक्षण के व्यावहारिक कार्यान्वयन पर शोध में लगे हुए हैं। पहले एक फ्रीलांस वेब डिजाइनर और डेवलपर के रूप में काम किया, कई पुरस्कार विजेता साइटों के निर्माण में भाग लिया। वह वर्तमान में ओपन सोर्स प्रोजेक्ट्स में भाग लेता है और अक्सर स्टैक ओवरफ्लो पर सवालों के जवाब देता है।

विज्ञान संपादकों के बारे में

सुजीत पाल एल्सेवियर लैब्स में तकनीकी अनुसंधान निदेशक, रीड-एल्सेवियर ग्रुप की नवीनतम प्रौद्योगिकी विकास टीम है। वह सिमेंटिक खोज, प्राकृतिक भाषा प्रसंस्करण, मशीन और गहन शिक्षा के क्षेत्र में अनुसंधान में लगे हुए हैं। एल्सेवियर में, उन्होंने कई पहल परियोजनाओं पर काम किया, जिसमें खोज की गुणवत्ता का मूल्यांकन और सुधार करना, छवियों को वर्गीकृत करना और डुप्लिकेट की पहचान करना, एनोटेट करना और चिकित्सा और वैज्ञानिक ग्रंथों के एंथोलॉजी को विकसित करना शामिल है। उन्होंने एंटोनियो गुल्ली के साथ एक गहन अध्ययन पुस्तक लिखी और अपने सैल्मन रन ब्लॉग पर प्रौद्योगिकी के बारे में लिखा।

सूर्यादीपन राममूर्ति भारत के पांडिचेरी में एआई शोधकर्ता और इंजीनियर से एक कृत्रिम बुद्धि शोधकर्ता और इंजीनियर हैं। उनके काम का मुख्य विषय प्राकृतिक भाषाओं को समझना और तर्क बनाना है। वह एक गहरे सीखने वाले ब्लॉग पर बड़े पैमाने पर लिखते हैं। एसएएएमए टेक्नोलॉजीज में, वह बायोमेडिकल ग्रंथों का विश्लेषण करने के लिए उन्नत गहरी शिक्षण विधियों का उपयोग करता है। मुफ्त सॉफ्टवेयर के प्रबल समर्थक होने के नाते, वह एफएसएफटीएन समुदाय में इसके विकास के लिए परियोजनाओं में सक्रिय रूप से भाग लेते हैं। वह सहयोगी नेटवर्क, डेटा विज़ुअलाइज़ेशन और रचनात्मक प्रोग्रामिंग में भी रुचि रखते हैं।

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर देखी जा सकती है
» सामग्री
» अंश

फेरीवालों के लिए कूपन पर 25% की छूट - पायथन

पुस्तक के पेपर संस्करण के भुगतान पर, ई-मेल द्वारा एक इलेक्ट्रॉनिक पुस्तक भेजी जाती है।