👇🏽 ⚠️ 👨‍👨‍👦 चरित्र प्रतिगमन 🎄 ☝🏼 👊🏾

मशीन सीखने के तरीकों का उपयोग करके समस्याओं को हल करते समय, एक नियम के रूप में, हम कार्य के संदर्भ में सबसे उपयुक्त एल्गोरिथ्म चुनते हैं, साथ ही इसके मापदंडों को कॉन्फ़िगर करने का एक तरीका भी है।

आइए थोड़ा अलग दृष्टिकोण देखें: स्वतंत्र रूप से एक एल्गोरिथ्म का चयन करने के बजाय, हम एक प्रोग्राम विकसित करेंगे जो समस्याओं को हल करने के लिए स्वचालित रूप से एल्गोरिदम उत्पन्न करने में सक्षम है।

आनुवंशिक एल्गोरिथम के उपयोग के आधार पर कार्यक्रमों के निर्माण के लिए एक स्टोकेस्टिक विधि को आनुवंशिक प्रोग्रामिंग कहा जाता है।

आनुवंशिक एल्गोरिथ्म के बारे में कुछ शब्द

आनुवंशिक एल्गोरिथम एक अनुकूलन विधि है जो प्राकृतिक चयन के विचार के आधार पर सबसे अच्छा परिणाम प्राप्त करने के लिए है। शब्दांकन का सामान्यीकरण विभिन्न समस्याओं को हल करने के लिए इस एल्गोरिथ्म का उपयोग करना संभव बनाता है। आप सभी की जरूरत है:

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

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

आनुवंशिक प्रोग्रामिंग और प्रतीकात्मक प्रतिगमन

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

कार्यक्रम प्रस्तुत करने के लिए एक काफी सुविधाजनक विकल्प वाक्यविन्यास वृक्ष है। इस मामले में, "कार्यक्रमों" की भूमिका बीजगणितीय सूत्रों द्वारा निभाई जाती है। लीफ नोड्स चर या संख्यात्मक स्थिरांक के अनुरूप होते हैं, जबकि गैर-पत्ती नोड में एक ऑपरेशन होता है जो चाइल्ड नोड पर किया जाता है।

सिंटेक्स ट्री उदाहरण:

यह ध्यान देने योग्य है कि प्रत्येक वाक्यविन्यास वृक्ष के लिए अनंत रूप से समतुल्य पेड़ों की एक अनंत संख्या है, उदाहरण के लिए:

हम वाक्यविन्यास के पेड़ों को गुणसूत्र के रूप में उपयोग करेंगे।

वाक्यविन्यास पेड़ों पर आनुवंशिक संचालन

क्रॉसिंग को बेतरतीब ढंग से चयनित उपप्रकारों के आदान-प्रदान द्वारा कार्यान्वित किया जा सकता है:

उत्परिवर्तन कई अलग-अलग विकल्पों के साथ आ सकते हैं, लेकिन अंततः, मेरे कार्यान्वयन में, मैं निम्नलिखित पर बस गया:

बेतरतीब ढंग से चयनित अन्य के साथ एक समारोह की जगह:
बेतरतीब ढंग से उत्पन्न सबट्री के साथ एक सबट्री की जगह:
एक मध्यवर्ती गैर पत्ती नोड को हटाना:
एक यादृच्छिक नोड बनाना जो पेड़ की नई जड़ द्वारा सौंपा गया है:
गैर-कम्यूटेटिव ऑपरेशंस वाले नोड्स के लिए, बच्चे को फिर से व्यवस्थित करें:

वाक्यविन्यास वृक्ष का फिटनेस फ़ंक्शन यह गणना करता है कि संबंधित बीजीय सूत्र कितनी अच्छी तरह से डेटा को अनुमानित करता है, और, वास्तव में, प्रशिक्षण डेटा से उत्पन्न फ़ंक्शन के मूल्यों के चुकता विचलन का योग है।

प्रारंभिक जनसंख्या यादृच्छिक रूप से उत्पन्न सिंटैक्स पेड़ों का एक संग्रह है।

अनुकूलन

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

आइए समाधानों की खोज में बनाए गए दो सूत्रों को देखें (रेड क्रॉस डेटा का प्रशिक्षण दे रहे हैं):

यह देखना आसान है कि नीली रेखा हरे रंग के पेराबोला के विपरीत, प्रशिक्षण डेटा के काफी करीब है, जिसका अर्थ है कि इसमें प्रशिक्षण नमूने के सापेक्ष छोटे वर्गों का विचलन है।

लेकिन, दूसरी तरफ, नग्न आंखों से देखा जा सकता है कि परबोला बस वही है जो हमें चाहिए।

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

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

+, -, sin (x), cos (x), ln (abs (x) +0.00001), sqrt (abs (x)), आदि।

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

पर्याप्त सिद्धांत, आइए देखें कि यह व्यवहार में कैसे काम करता है

आइए एक सूत्र खोजने की कोशिश करें जो निम्नलिखित पैटर्न को पूरा करेगा:

एक्स	y	z	च (x, y, z)
26	35	1	830
8	24	-11	130
20	1	10	477
33	11	2	1217
37	16	7	1524

वांछित सूत्र

111 पुनरावृत्तियों में, हम सूत्र प्राप्त करते हैं:

परिवर्तन के बाद, जो एक सूत्र में बदल जाता है, जो लगभग वांछित के साथ मेल खाता है:

नीचे समाधान के गठन की गतिशीलता है:

गणना परिणामों के पूरे लॉग को देखें

जनसंख्या संख्या	चुकता विचलन का योग	सबसे अच्छा सूत्र
0	1669012.26766007	f (x, y, z) = 544.6859000804278
1	169681.53834698	f (x, y, z) = (x * (28.961135980737247 + z)
2	१४८२८८.४६८५०७१७००१	f (x, y, z) = (x * (31.37500136808971 + z))
3	१,३२,७६७.६५९५३९७७१	f (x, y, z) = (x * (52.43484580560726 + (-16.667350145606648)))
4	२,९८५.०९२३४९५९२७५	f (x, y, z) = (x * (4,433746792798393 + x))
5	2983.6495099344102	f (x, y, z) = (x * (4,4641060233894825 + x))
6	2983.6495099344102
7	2983.3906931086399	f (x, y, z) = (x * (4.454265913806434 + x))
8	2983.3906931086399
9	2983.3904005863701	f (x, y, z) = (x * (4.454298469272653 + x))
10	597.81897366597798	f (x, y, z) = ((x * (3.844350383063788 + x)) + y)
11	594.94169424631298	f (x, y, z) = ((x * (3.8969889609817003 + x)) + y)
12	594.94169424631298
13	593.73658852479002	f (x, y, z) = ((x * (3,882218261498 + x)) + y)
14	465.83708126862598	f (x, y, z) = (((x * (4,005216664324722 + x)) + y) - z)
15	465.83708126862598
16	465.83708126862598
17	465.83708126862598
18	465.83015734565402	f (x, y, z) = (((x * (4,005911869833458 + x)) + y) - z)
19	465.83015734565402
20	465.83015734565402
21	415.16018053718898	f (x, y, z) = (((x (3,5125714437530116 + x)) + y) - (-11,692166173605955)
22	415.16018053718898
23	395.52399773897002	f (x, y, z) = (((x * (3.382514048684854 + x)) + y) - (-14.647402701410202)
24	395.07066142434297	f (x, y, z) = (((x * (3.3745415764367164 + x)) + y) - (-14.718709944856545)
25	394.26327346841998	f (x, y, z) = (((x * (3.3648511983617673 + x)) + y) - (-15,239602399729787)
26	392.88638158772301	f (x, y, z) = (((x * (3.337209019532033 + x)) + y) - (-15.802043204356028))
27	392.32411284414297	f (x, y, z) = (((x (3.3064294470317237 + x)) + y) - (-16.587523294477112)
28	392.32411284414297
29	392.32411284414297
30	201.31809082052899	f (x, y, z) = (((((x (3.1436791342095485 + x)) + y) - (-3.592869973372564) + y)
31	164.61977693577799	f (x, y, z) = (((((x (3.284782293612155 + x)) + y) - 0.2814995918777923) + y)
32	१४९.२७९५८१७२१२०६	f (x, y, z) = (((((x (3.428687042834285 + x)) + y) - 3.8492278595932117) + y)
33	१४९.२७८३४६४१५१९२	f (x, y, z) = (((((x (3.428687042834285 + x)) + y) - 3.8397689886934776) + y)
34	१४९.२७८३४६४१५१९२
35	148.94429071530399	f (x, y, z) = (((((x (3.4733961096640367 + x)) + y) - 4.871582132520638) + y)
36	148.94429071530399
37	148.92149057538799	f (x, y, z) = (((((x (3.4733961096640367 + x)) + y) - 4.927910435311452) + y)
38	१४८.८४२६४७५६९७१७	f (x, y, z) = (((((x (3.4667603760518504 + x)) + y) - 4.761715096087028) + y)
39	१४८.८४२१२६१९४३४८	f (x, y, z) = (((((x (3.4667603760518504 + x)) + y) - 4.766164660321495) + y)
40	148.83482158482201	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.761715096087028) + y)
41	148.83482158482201
42	148.83482158482201
43	148.83482158482201
44	148.83482158482201
45	१४८.८२४७१४३५७०७१	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.723957086860974) + y)
46	१४८.८२४४७४९८०८४४	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.719858152218609) + y)
47	१४८.८२४४७४९८०८४४
48	१४८.८२४४७४९८०८४४
49	१४८.८२४४७४९८०८४४
50	१४८.८२४४१३१३५३५	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.717481429398491) + y)
51	148.82441154759999	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.717364268937347) + y)
52	148.82441154759999
53	148.82441154759999
54	148.82441154759999
55	148.82441154759999
56	148.82441154759999
57	148.82441154759999
58	१४८.८२४४०३२४२९९५	f (x, y, z) = (((((x (3.464357566836493 + x)) + y) - 4.715925249764239) + y)
59	१४८.८२४४०३२४२९९५
60	१४८.८२४४०३२४२९९५
61	१४८.८२४४०३२४२९९५
62	१४८.८२४४०३२४२९९५
63	१४८.८२४४०३२४२९९५
64	१४८.८२४४०३२४२९९५
65	१४८.८२४४०३२४२९९५
66	१४८.८२४४०३२४२९९५
67	१४८.८२४४०३२४२९९५
68	१४८.८२४४०३२४२९९५
69	१४८.८२४४०३२४२९९५
70	१४८.८२४४०३२४२९९५
71	१४८.८२४४०३२४२९९५
72	१४८.८२४४०३२४२९९५
73	१४८.८२४४०३२४२९९५
74	१४८.८२४४०३२४२९९५
75	१४८.८२४४०३२४२९९५
76	१४८.८२४४०३२४२९९५
77	१४८.८२४४०३२४२९९५
78	१४८.८२४४०३२४२९९५
79	१४८.८२४४०३२४२९९५
80	१४८.८२४४०३२४२९९५
81	१४८.८२४४०३२४२९९५
82	१४८.८२४४०३२४२९९५
83	१४८.८२४४०३२४२९९५
84	१४८.८२४४०३२४२९९५
85	१४८.८२४४०३२४२९९५
86	१४८.८२४४०३२४२९९५
87	१४८.८२४४०३२४२९९५
88	१४८.८२४४०३२४२९९५
89	१४८.८२४४०३२४२९९५
90	१४८.८२४४०३२४२९९५
91	१४८.८२४४०३२४२९९५
92	१४८.८२४४०३२४२९९५
93	१४८.८२४४०३२४२९९५
94	१४८.८२४४०३२४२९९५
95	१४८.८२४४०३२४२९९५
96	१४८.८२४४०३२४२९९५
97	१४८.८२४४०३२४२९९५
98	१४८.८२४४०३२४२९९५
99	१४८.८२४४०३२४२९९५
100	१०९.७३८४४८३१४३७८	f (x, y, z) = (((((x (3.6304822654527666 + x)) + y) - (((y * 0.26890083188968594) - (-4,125304601227528)) + y)
101	१०९.७३८४४८३१४३७८
102	86.7213316804214	f (x, y, z) = (((((x (3.454146360987013 + x)) + y) - ((y * 0.26890083188968594) - 0.3170624310193074)) + y)
103	86.077603952275396	f (x, y, z) = (((((x (3.4532441079663054 + x)) + y) - ((y * 0.2821822285682245) - 0.5330637339727107)) + y)
104	84.787024859776594	f (x, y, z) = (((((x (3.418583927986026 + x)) + y) - ((y * 0.30109799837668216) - 1.6913597460963947) + y)
105	84.787024859776594
106	19.436528477129301	f (x, y, z) = (((((x (3.1298089197766688 + x)) + y) - ((y * (-1.1430183282239135)) - (-0.770101011336523038)) + z)
107	9.2899337994931397	f (x, y, z) = (((((x (3.1298089197766688 + x)) + y) - ((y * (-0.9847117571207198)) - (2.01456172176615)) + z)
108	9.2899337994931397
109	8.5880221046539802	f (x, y, z) = (((((x (3,1002105039045555 + x)) + y) - ((y * (-0.9847117571207198)) - (2.01456442756615)) + z)
110	8.5880221046539802
111	.38510898634568402	f (x, y, z) = (((((x (3.0172293562767245 + x)) + y) - ((y * (-0.9842629202499209)) - 4.9120614148353544)) + z)

समाधान के गठन में चरणों का पालन करना दिलचस्प है:

सबसे पहले, चर x पर निर्भरता है (यह चरण चित्र में नहीं दिखाया गया है, क्योंकि त्रुटि अभी भी बहुत बड़ी है - अधिकतम 130%)
तब सूत्र एक्स पर एक द्विघात निर्भरता में बदल जाता है (चुकता विचलन का योग ~ 3000 है)
जिसके बाद चर y पर निर्भरता की पहचान की जाती है (वर्ग विचलन का योग ~ 500)
और अंत में, संख्यात्मक मापदंडों का अनुकूलन करने और चर z पर निर्भरता की पहचान करने के बाद, एक इष्टतम परिणाम प्राप्त किया जाता है।

एक और उदाहरण

कभी-कभी आपको ऐसे सूत्र मिलते हैं जो इतने स्पष्ट नहीं होते हैं। उदाहरण के लिए, एक बार, जब एक सूत्र प्राप्त करने की कोशिश कर रहा है

मुझे निम्नलिखित परिणाम मिला:

लेकिन अगर आप पहचान का फायदा उठाते हैं:

यह दिखाया जा सकता है कि परिणामस्वरूप सूत्र सही है:

अगर आप प्रयोग करना चाहते हैं

कंसोल उपयोगिता

आपके पास जावा रनटाइम स्थापित होना चाहिए
यहां से प्रतीकात्मक_श्रेणी_1.0 . jar फ़ाइल डाउनलोड करें।
एक ही निर्देशिका में symbolic_regression_1.0.jar के रूप में, निम्न सामग्री के साथ एक फ़ाइल (उदाहरण के लिए data.txt ) बनाएँ :
# अनुमत कार्य हैं: AD SUB MUL DIV SQRT POW LN SIN COS
# सेट जो कार्यों का उपयोग करने के लिए:
ADD MUL SUB

# ढूंढ रहे हैं:
f (x, y, z) -?

# प्रशिक्षण सेट परिभाषित करें:
f (26, 35, 1) = 830
f (8, 24, -11) = 130
f (20, 1, 10) = 477
f (33, 11, 2) = 1217
f (37, 16, 7) = 1524
समाधान खोज चलाएँ:

java -jar symbolic_regression_1.0.jar data.txt

समाधान को माना जाता है यदि विचलन के वर्गों का योग 10 से कम है। यदि समाधान अभी तक नहीं मिला है, तो प्रत्येक 50 पुनरावृत्तियों के बाद आपसे पूछा जाएगा कि क्या आप जारी रखना चाहते हैं।

जावा प्रोग्रामर

आप यहाँ स्रोत कोड पा सकते हैं: github.com/lagodiuk/genetic-programming

एक निष्कर्ष के बजाय

जिन सूत्रों की मैं जाँच करने में कामयाब रहा, उनके बहुत सीमित संख्या में, अच्छे परिणाम प्राप्त हुए, आदिम और व्युत्पत्ति खोजने में अभी भी सफल प्रयोग हुए।

इसके अलावा, तंत्रिका नेटवर्क के स्वचालित निर्माण के लिए आनुवंशिक प्रोग्रामिंग का सफलतापूर्वक उपयोग किया जा सकता है ( यहां उस एप्लिकेशन का एक छोटा डेमो है जिसमें मैंने इस दृष्टिकोण को लागू किया है )।

अभी भी एक विचार है - वांछित गुणों के साथ रासायनिक यौगिकों की संरचनाओं के स्वचालित निर्माण के लिए एक समान दृष्टिकोण (क्यूएसएआर विधियों के साथ) लागू करने के लिए।

साहित्य

वेब पर आप आनुवंशिक प्रोग्रामिंग के विषय पर बहुत सारी सामग्री पा सकते हैं।
अलग-अलग, मैं निम्नलिखित स्रोतों को नोट करना चाहता हूं:

चरित्र प्रतिगमन