👩🏻‍🏭 👂🏾 🌆 PyBullet सुदृढीकरण प्रशिक्षण 👰🏻 🛣️ 👩🏼‍⚕️

मशीन लर्निंग का अध्ययन करने वाले कई लोग OpenAI परियोजना से परिचित हैं, जिनमें से एक एलोन मस्क है, और अपने तंत्रिका नेटवर्क मॉडल को प्रशिक्षित करने के लिए OpenAI जिम मंच का उपयोग करते हैं।

जिम में पर्यावरण का एक विशाल समूह होता है, उनमें से कुछ विभिन्न प्रकार के भौतिक सिमुलेशन हैं: जानवरों, मनुष्यों, रोबोटों के आंदोलनों। ये सिमुलेशन MuJoCo भौतिकी इंजन पर आधारित हैं, जो शैक्षिक और वैज्ञानिक उद्देश्यों के लिए स्वतंत्र है।

इस अनुच्छेद में, हम OpenAI जिम वातावरण के समान एक बहुत ही सरल शारीरिक सिमुलेशन बनाएंगे, लेकिन मुक्त भौतिकी इंजन बुलेट ( PyBullet ) पर आधारित है। और इस वातावरण के साथ काम करने के लिए एक एजेंट भी बनाएं।

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

PyBullet के लिए एक बहुत अच्छा QuickStartGuide है जिसमें GitHub के स्रोत पृष्ठ पर उदाहरणों के लिंक हैं।

PyBullet आपको URDF, SDF या MJCF प्रारूप में पहले से निर्मित मॉडल लोड करने की अनुमति देता है। स्रोतों में इन प्रारूपों में मॉडलों का एक पुस्तकालय है, साथ ही वास्तविक रोबोटों के सिमुलेटर के पूरी तरह से तैयार वातावरण भी हैं ।

हमारे मामले में, हम स्वयं PyBullet का उपयोग करके वातावरण बनाएंगे। पर्यावरण इंटरफ़ेस OpenAI जिम इंटरफ़ेस के समान होगा। इस तरह हम अपने एजेंटों को अपने परिवेश और जिम के वातावरण में प्रशिक्षित कर सकते हैं।

सभी कोड (iPython), साथ ही साथ कार्यक्रम का संचालन Google Colaboratory में देखा जा सकता है।

पर्यावरण (पर्यावरण)

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

सिमुलेशन बहुत सरल है, और वास्तव में कुछ प्राथमिक प्रस्तावक के अनुकरण के रूप में माना जा सकता है।

पर्यावरण के साथ काम करने के लिए, 3 विधियों का उपयोग किया जाता है: रीसेट (प्रयोग को फिर से शुरू करना और पर्यावरण के सभी ऑब्जेक्ट बनाना), चरण (चयनित कार्रवाई को लागू करना और पर्यावरण की परिणामी स्थिति प्राप्त करना), रेंडर (पर्यावरण का दृश्य प्रदर्शन)।

पर्यावरण को आरंभ करते समय, हमारी वस्तु को भौतिक अनुकरण से जोड़ना आवश्यक है। 2 कनेक्शन विकल्प हैं: एक ग्राफिकल इंटरफ़ेस (GUI) और बिना (DIRECT) के साथ। हमारे मामले में, यह DIRECT है।

pb.connect(pb.DIRECT)

रीसेट

प्रत्येक नए प्रयोग के साथ, हम pb.resetSimulation () सिमुलेशन को रीसेट करते हैं और सभी पर्यावरण वस्तुओं को फिर से बनाते हैं।

PyBullet में, वस्तुओं के 2 आकार होते हैं: एक टकराव का आकार , और एक दृश्य आकार । पहले भौतिक इंजन द्वारा वस्तुओं के टकराव की गणना करने के लिए और भौतिकी की गणना को गति देने के लिए उपयोग किया जाता है, आमतौर पर एक वास्तविक वस्तु की तुलना में एक सरल रूप होता है। दूसरा वैकल्पिक है, और इसका उपयोग केवल ऑब्जेक्ट की छवि बनाते समय किया जाता है।

फॉर्म एक ही वस्तु (निकाय) में एकत्र किए जाते हैं - मल्टीबॉडी । एक शरीर एक आकृति ( कोलिशन शेप / विज़ुअल शेप पेयर) से बना हो सकता है, जैसा कि हमारे मामले में, या कई।

शरीर को बनाने वाले रूपों के अलावा, अंतरिक्ष में इसके द्रव्यमान, स्थिति और अभिविन्यास को निर्धारित करना आवश्यक है।

बहु-वस्तु निकायों के बारे में कुछ शब्द।

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

हम 3 बॉडी बनाएंगे: बॉल, प्लेन (अर्थ) और टार्गेट पॉइंटर। अंतिम ऑब्जेक्ट में केवल एक दृश्य रूप और शून्य द्रव्यमान होगा, इसलिए यह निकायों के बीच भौतिक बातचीत में भाग नहीं लेगा:

 #  floorColShape = pb.createCollisionShape(pb.GEOM_PLANE) #   (GEOM_PLANE), visualShape -    ,   GEOM_BOX floorVisualShapeId = pb.createVisualShape(pb.GEOM_BOX,halfExtents=[100,100,0.0001], rgbaColor=[1,1,.98,1]) pb_floorId = pb.createMultiBody(0,floorColShape,floorVisualShapeId, [0,0,0], [0,0,0,1]) #  PB_BallRadius = 0.2 PB_BallMass = 1 ballPosition = [0,0,5] ballOrientation=[0,0,0,1] ballColShape = pb.createCollisionShape(pb.GEOM_SPHERE,radius=PB_BallRadius) ballVisualShapeId = pb.createVisualShape(pb.GEOM_SPHERE,radius=PB_BallRadius, rgbaColor=[1,0.27,0,1]) pb_ballId = pb.createMultiBody(PB_BallMass, ballColShape, ballVisualShapeId, ballPosition, ballOrientation) #   TARGET_Z = 8 targetPosition = [0,0,TARGET_Z] targetOrientation=[0,0,0,1] targetVisualShapeId = pb.createVisualShape(pb.GEOM_BOX,halfExtents=[1,0.025,0.025], rgbaColor=[0,0,0,1]) pb_targetId = pb.createMultiBody(0,-1, targetVisualShapeId, targetPosition, targetOrientation)

सिमुलेशन कदम के गुरुत्वाकर्षण और समय को परिभाषित करें।

 pb.setGravity(0,0,-10) pb.setTimeStep(1./60)

सिमुलेशन शुरू करने के तुरंत बाद गेंद को गिरने से रोकने के लिए, हम गुरुत्वाकर्षण को संतुलित करते हैं।

 pb_force = 10 * PB_BallMass pb.applyExternalForce(pb_ballId, -1, [0,0,pb_force], [0,0,0], pb.LINK_FRAME)

कदम

एजेंट पर्यावरण की वर्तमान स्थिति के आधार पर क्रियाओं का चयन करता है, जिसके बाद वह चरण विधि को कॉल करता है और एक नया राज्य प्राप्त करता है।

2 प्रकार की कार्रवाई को परिभाषित किया जाता है: गेंद पर अभिनय करने वाले बल की वृद्धि और कमी। बल की सीमाएँ सीमित हैं।

गेंद पर अभिनय करने वाले बल को बदलने के बाद, भौतिक सिमुलेशन pb.stepSimulation () का एक नया चरण लॉन्च किया जाता है , और निम्न पैरामीटर एजेंट को दिए जाते हैं:

अवलोकन - अवलोकन (पर्यावरण की स्थिति)
इनाम - सही कार्रवाई के लिए इनाम
किया - अनुभव को समाप्त करने के लिए झंडा
जानकारी - अतिरिक्त जानकारी

पर्यावरण की स्थिति के रूप में, 3 मान लौटाए जाते हैं: लक्ष्य तक की दूरी, गेंद पर लागू वर्तमान बल और गेंद की गति। मूल्यों को सामान्यीकृत किया जाता है (0..1), क्योंकि ये मान निर्धारित करने वाले पर्यावरणीय पैरामीटर हमारी इच्छा के आधार पर भिन्न हो सकते हैं।

 #     (     Z curPos[2]) curPos, curOrient = pb.getBasePositionAndOrientation(pb_ballId) #     (      Z lin_vel[2]) lin_vel, ang_vel= pb.getBaseVelocity(self.pb_ballId)

सही कार्रवाई के लिए इनाम 1 है यदि गेंद लक्ष्य के करीब है (लक्ष्य ऊंचाई प्लस / स्वीकार्य रोलिंग वैल्यू TARGET_DELTA ) और अन्य मामलों में 0।
प्रयोग पूरा हो जाता है यदि गेंद ज़ोन के बाहर जाती है (जमीन पर गिरती है या ऊंची उड़ान भरती है)। यदि गेंद लक्ष्य तक पहुँच जाती है, तो प्रयोग भी समाप्त हो जाता है, लेकिन एक निश्चित समय के बाद ( STEPS_AFTER_TARGET चरणों का प्रयोग)। इस प्रकार, हमारे एजेंट को न केवल लक्ष्य की ओर बढ़ने के लिए प्रशिक्षित किया जाता है, बल्कि इसे रोकने और इसके करीब होने के लिए भी प्रशिक्षित किया जाता है। यह देखते हुए कि जब आप लक्ष्य के करीब होते हैं तो इनाम 1 होता है, पूरी तरह से सफल अनुभव के लिए STEPS_AFTER_TARGET के बराबर कुल इनाम होना चाहिए।

आंकड़ों को प्रदर्शित करने के लिए अतिरिक्त जानकारी के रूप में, प्रयोग के भीतर प्रदर्शन किए गए चरणों की कुल संख्या, साथ ही प्रति सेकंड निष्पादित चरणों की संख्या वापस आ जाती है।

प्रस्तुत करना

PyBullet में 2 इमेज रेंडरिंग विकल्प हैं - OpenGL पर आधारित GPU रेंडरिंग और CPU TinyRenderer पर आधारित है। हमारे मामले में, केवल एक सीपीयू कार्यान्वयन संभव है।

सिमुलेशन के वर्तमान फ्रेम को प्राप्त करने के लिए, प्रजाति मैट्रिक्स और प्रक्षेपण मैट्रिक्स निर्धारित करना आवश्यक है, और फिर कैमरे से दिए गए आकार की आरजीबी छवि प्राप्त करें।

 camTargetPos = [0,0,5] #   ()  camDistance = 10 #     yaw = 0 #     pitch = 0 #     roll=0 #      upAxisIndex = 2 #    (z) fov = 60 #    nearPlane = 0.01 #      farPlane = 20 #      pixelWidth = 320 #   pixelHeight = 200 #   aspect = pixelWidth/pixelHeight; #    #   viewMatrix = pb.computeViewMatrixFromYawPitchRoll(camTargetPos, camDistance, yaw, pitch, roll, upAxisIndex) #   projectionMatrix = pb.computeProjectionMatrixFOV(fov, aspect, nearPlane, farPlane); #     img_arr = pb.getCameraImage(pixelWidth, pixelHeight, viewMatrix, projectionMatrix, shadow=0, lightDirection=[0,1,1],renderer=pb.ER_TINY_RENDERER) w=img_arr[0] #width of the image, in pixels h=img_arr[1] #height of the image, in pixels rgb=img_arr[2] #color data RGB dep=img_arr[3] #depth data

प्रत्येक प्रयोग के अंत में, एकत्रित चित्रों के आधार पर एक वीडियो तैयार किया जाता है।

 ani = animation.ArtistAnimation(plt.gcf(), render_imgs, interval=10, blit=True,repeat_delay=1000) display(HTML(ani.to_html5_video()))

एजेंट

GitHub jaara उपयोगकर्ता कोड को जिम वातावरण के लिए सुदृढीकरण प्रशिक्षण को लागू करने के एक सरल और समझने योग्य उदाहरण के रूप में, एजेंट के लिए आधार के रूप में लिया गया था।

एजेंट में 2 ऑब्जेक्ट होते हैं: मेमोरी - प्रशिक्षण उदाहरणों के गठन के लिए एक भंडारण और मस्तिष्क ही तंत्रिका नेटवर्क है जिसे वह प्रशिक्षित करता है।

प्रशिक्षित न्यूरल नेटवर्क टेन्सरफ्लो पर केरस लाइब्रेरी का उपयोग करके बनाया गया था, जिसे हाल ही में टेंसोरफ्लो में पूरी तरह से शामिल किया गया है।
तंत्रिका नेटवर्क की एक सरल संरचना है - 3 परतें, अर्थात्। केवल 1 छिपी हुई परत।

पहली परत में 512 न्यूरॉन्स होते हैं और इसमें माध्यम की स्थिति के मापदंडों की संख्या के बराबर इनपुट होते हैं (3 पैरामीटर: लक्ष्य से दूरी, गेंद की गति और गति)। छिपी हुई परत का आयाम पहली परत के बराबर है - 512 न्यूरॉन्स, आउटपुट पर यह आउटपुट परत से जुड़ा होता है। आउटपुट परत के न्यूरॉन्स की संख्या एजेंट द्वारा किए गए कार्यों की संख्या से मेल खाती है (2 क्रियाएं: अभिनय बल में कमी और वृद्धि)।

इस प्रकार, सिस्टम की स्थिति नेटवर्क इनपुट को आपूर्ति की जाती है, और आउटपुट पर हमें प्रत्येक क्रिया के लिए लाभ होता है।

पहले दो परतों के लिए, ReLU (रेक्टिफाइड लीनियर यूनिट) का उपयोग सक्रियण कार्यों के रूप में किया जाता है, अंतिम के लिए - एक लीनियर फ़ंक्शन (इनपुट मानों का योग सरल है)।
एक अनुकूलन एल्गोरिथ्म के रूप में त्रुटि के एक समारोह के रूप में, एमएसई (मानक त्रुटि) - आरएमएसप्रॉप (रूट मीन स्क्वायर प्रचार)।

 model = Sequential() model.add(Dense(units=512, activation='relu', input_dim=3)) model.add(Dense(units=512, activation='relu')) model.add(Dense(units=2, activation='linear')) opt = RMSprop(lr=0.00025) model.compile(loss='mse', optimizer=opt)

प्रत्येक सिमुलेशन स्टेप के बाद, एजेंट इस कदम के परिणामों को एक सूची (s, r, s_) के रूप में सहेजता है :
s - पिछला अवलोकन (पर्यावरण की स्थिति)
ए - पूर्ण कार्रवाई
आर - प्रदर्शन किया कार्रवाई के लिए इनाम प्राप्त हुआ
s_ - क्रिया के बाद अंतिम अवलोकन

उसके बाद, एजेंट स्मृति से पिछले अवधियों के लिए एक यादृच्छिक सेट प्राप्त करता है और एक प्रशिक्षण पैकेज ( बैच ) बनाता है।

मेमोरी से चुने गए यादृच्छिक चरणों की प्रारंभिक स्थिति को पैकेट के इनपुट मान ( एक्स ) के रूप में लिया जाता है।

लर्निंग आउटपुट ( Y ' ) के वास्तविक मानों की गणना निम्न प्रकार से की जाती है: s के लिए तंत्रिका नेटवर्क के आउटपुट ( Y ) में, प्रत्येक क्रिया Q (s) के लिए Q फ़ंक्शन मान होंगे। इस सेट से, एजेंट ने उच्चतम मूल्य Q (s, a) = MAX (Q (s)) के साथ कार्रवाई का चयन किया, उसे पूरा किया और पुरस्कार r प्राप्त किया। चयनित क्रिया के लिए नया Q मान Q (s, a) = Q (s, a) + DF * r होगा , जहां DF छूट कारक है। शेष आउटपुट मान समान रहेंगे।

 STATE_CNT = 3 ACTION_CNT = 2 batchLen = 32 #     states = numpy.array([ o[0] for o in batch ]) #     states_ = numpy.array([ o[3] for o in batch ]) #     p = agent.brain.predict(states) #     p_ = agent.brain.predict(states_) #     x = numpy.zeros((batchLen, STATE_CNT)) y = numpy.zeros((batchLen, ACTION_CNT)) #   for i in range(batchLen): o = batch[i] s = o[0]; a = o[1]; r = o[2]; s_ = o[3] t = p[i] #      #      ,       t[a] = r + GAMMA * numpy.amax(p_[i]) #            #    batch x[i] = s y[i] = t #      self.brain.train(x, y)

नेटवर्क प्रशिक्षण गठित पैक पर होता है

 self.model.fit(x, y, batch_size=32, epochs=1, verbose=0)

प्रयोग पूरा होने के बाद, एक वीडियो बनाया जाता है

और आंकड़े प्रदर्शित किए जाते हैं

लगभग 95 प्रतिशत परिणाम (सफल चरणों की संख्या) प्राप्त करने के लिए एजेंट को 1,200 परीक्षणों की आवश्यकता थी। और 50 वें प्रयोग से, एजेंट ने गेंद को लक्ष्य पर ले जाना सीख लिया था (असफल प्रयोग गायब हो गए)।

परिणामों को बेहतर बनाने के लिए, आप नेटवर्क परतों (LAYER_SIZE), छूट कारक (GAMMA) के पैरामीटर या यादृच्छिक कार्रवाई (LAMBDA) को चुनने की संभावना में कमी की दर को बदलने की कोशिश कर सकते हैं।

हमारे एजेंट के पास सबसे सरल आर्किटेक्चर है - DQN (डीप क्यू-नेटवर्क)। ऐसे सरल कार्य पर, स्वीकार्य परिणाम प्राप्त करने के लिए पर्याप्त है।

उदाहरण के लिए, डीडीक्यूएन (डबल डीक्यूएन) आर्किटेक्चर को चिकना और अधिक सटीक प्रशिक्षण प्रदान करना चाहिए। और RDQN नेटवर्क (आवर्तक DQN) समय के साथ पर्यावरण परिवर्तन के पैटर्न का पता लगाने में सक्षम होगा, जो नेटवर्क इनपुट मापदंडों की संख्या को कम करने, गेंद की गति पैरामीटर से छुटकारा पाना संभव बना देगा।

आप एक चर गेंद द्रव्यमान या इसके आंदोलन के झुकाव के कोण को जोड़कर हमारे सिमुलेशन का विस्तार कर सकते हैं।

लेकिन यह अगली बार है।

PyBullet सुदृढीकरण प्रशिक्षण

पर्यावरण (पर्यावरण)

रीसेट

कदम

प्रस्तुत करना

एजेंट

More articles: