मैं gekko का उपयोग करके एक यादृच्छिक 'परीक्षण फ़ंक्शन' को कम करने और अधिकतम करने की कोशिश कर रहा हूं जो ए से जुड़ा हुआ है। ए में रेंज (0-100) और ए <100 के योग के बीच 4 पैरामीटर होते हैं। हालांकि मुझे अजीब परिणाम मिलते रहते हैं, क्योंकि न्यूनतम परीक्षण कार्य 2500 और अधिकतम 10000 होना चाहिए। मेरा कोड नीचे है। क्या कोई मुझे बता सकता है कि समस्या कहां है? अग्रिम में धन्यवाद


    import numpy as np
    from gekko import GEKKO 


    def test_function(x):
        return np.dot(x, x)


    A = m.Array(m.Var, (4))
    # initial guess
    ig = [1, 5, 5, 1]
    # lower bounds
    i = 0
    for Ai in A:
        Ai.value = ig[i]
        Ai.lower = 0
        Ai.upper = 100
        i += 1
    m.Equation(np.sum(A) < 100)
    m.Obj(test_function(A))
    m.solve()
    print(test_function(A))
    print (A)

परिणाम

Solver         :  IPOPT (v3.12)
 Solution time  :   1.379999999971915E-002 sec
 Objective      :   4.141037033873033E-007
 Successful solution
 ---------------------------------------------------

(((((v1)*(v1))+((v2)*(v2)))+((v3)*(v3)))+((v4)*(v4)))
[[0.00042734466188] [0.00015629584657] [0.00015629584657]
 [0.00042734466188]]

Process finished with exit code 0
4
Abdirizak 20 जिंदा 2020, 02:21

2 जवाब

सबसे बढ़िया उत्तर

मैंने आपके कथन से मेल खाने के लिए समस्या को संशोधित किया है। एक सूची समझ भी है जो ऊपरी और निचली सीमाओं के साथ नए चर को परिभाषित करने की प्रक्रिया को सरल बनाती है। निम्नलिखित स्क्रिप्ट test_function(x) को (1) गेको वेरिएबल्स के साथ एक्सेस करने के दो तरीके दिखाती है जो प्रतीकात्मक अभिव्यक्ति हैं या (2) उस बाधा और उद्देश्य फ़ंक्शन का मूल्यांकन करने के लिए संख्यात्मक मानों के साथ।

import numpy as np
from gekko import GEKKO 
m = GEKKO(remote=False)
def test_function(x):
    return np.dot(x, x)
ig = [1, 5, 5, 1] # initial guess
A = np.array([m.Var(value=ig[i],lb=0,ub=10000,name='a'+str(i)) \
              for i in range(4)])
m.Equation(test_function(A)>2500)
m.Equation(test_function(A)<10000)
m.Minimize(test_function(A))
m.solve()
# extract values to get a numerical solution of test_function
A_sol = [A[i].value[0] for i in range(4)]
print(test_function(A_sol))
# get the objective function value from the solver
print(m.options.OBJFCNVAL)
# print variables
print (A)

स्क्रिप्ट के परिणाम नीचे दिखाए गए हैं। यदि आप print(test_function(A_sol)) का उपयोग करते हैं, तो यह प्रतीकात्मक अभिव्यक्ति को प्रिंट करता है जिसका उपयोग Gekko समाधान खोजने के लिए करता है। आपके मामले में, आपको सांख्यिक समाधान में रुचि हो सकती है, प्रतीकात्मक रूप में नहीं।

# results
2499.999999993099
2500.0
[[14.90599615] [32.059495922] [32.059495922] [14.90599615]]

दोनों m.options.OBJFCNVAL और व्यंजक का मूल्यांकन एक ही परिणाम देते हैं लेकिन मशीन की शुद्धता के कारण थोड़े भिन्न होते हैं।

1
John Hedengren 23 जिंदा 2020, 06:59

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

2
Andrew T 20 जिंदा 2020, 21:46