कैसे करें: सॉल्वर फाउंडेशन क्वाड्रैटिक कम से कम वर्ग

Question

मेरे पास दो स्वतंत्र चर, GSH और Gls हैं। इन दो चर का उपयोग करके, मैं एक परिणाम, prob की भविष्यवाणी करने की कोशिश कर रहा हूं।

prob=a*Gls^2+b*GSH^2+c*Gls+d*GSH+e // (where a,b,c,d,e are coefficients) 

डेटा का नमूना: प्रपत्र के एक समारोह का उपयोग करना

Gls(2.3 2.3 2.5 2.5 2.5 2.5 2.7 2.7 2.7 2.7 2.7 2.9 2.9 2.9 2.9 2.9 3.1 3.1 3.1 3.1 3.1 3.1 3.3 3.3 3.3 3.3 3.3 3.3 3.5 3.5 3.5 3.5 3.5) 

GSH(0.475 0.525 0.425 0.475 0.525 0.575 0.425 0.475 0.525 0.575 0.625 0.425 0.475 0.525 0.575 0.625 0.375 0.425 0.475 0.525 0.575 0.625 0.375 0.425 0.475 0.525 0.575 0.625 0.425 0.475 0.525 0.575 0.625) 

prob(0.263636 0.324159 0.319328 0.291295 0.286086 0.253994 0.233766 0.284644 0.273818 0.263743 0.175182 0.243986 0.284848 0.28066 0.247863 0.183468 0.181818 0.237288 0.269266 0.2555 0.240924 0.206081 0.209677 0.216949 0.263261 0.25966 0.23588 0.203252 0.239316 0.209184 0.234818 0.242424 0.192118) 

मैं कम से कम वर्गों का योग कम करने के लिए गुणांक का सबसे अच्छा मूल्यों को खोजने के लिए करना चाहते हैं।

मैंने नींव सॉल्वर पर बहुत कुछ पढ़ा है लेकिन मैं इस समस्या को सी # सॉल्वर फाउंडेशन में कैसे सेट अप करने में असमर्थ हूं। सभी कोड सुझावों की बहुत सराहना की जाती है।

धन्यवाद

Answer 1

मुझे लगता है कि आपको लगता है कि के लिए solver नींव की जरूरत नहीं है। संख्यात्मक अनुकूलन में कोई आवश्यकता नहीं है, क्योंकि समाधान (बहुपद गुणांक का वेक्टर जो डेटासेट में अनुमानित प्रतिक्रियाओं और अनुमानित प्रतिक्रियाओं के बीच वर्ग लंबवत दूरी के योग को कम करता है) एक बंद रूप में मौजूद है।

विवरण के लिए wikipedia देखें।

Answer 2

आप सॉल्वर फाउंडेशन का उपयोग कर सकते हैं। आपका प्रतिगमन पहले से ही nonlinear है, और वास्तव में एक generalized linear regression है। आर में, आप रिग्रेशन करने के लिए glm जैसे पैकेज का उपयोग कर सकते हैं।

सी # में, मुझे यकीन नहीं है कि कोई ओपन सोर्स कोड मौजूद है या नहीं। लेकिन वैसे भी, आप खुद को अनुकूलन हल कर सकते हैं, और एमएसएफ में एक nonlinear solver है! तो बस दो कार्य लिखें:

Logistic Regression in F# using Microsoft Solver Foundation

:

1. उद्देश्य समारोह और

2. अपनी ढाल

एक त्वरित उदाहरण के रूप में, आप मेरे लेख देख सकते हैं

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

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

Answer 3

निम्नलिखित समाधान बहुत सीधे आगे है, बस आपके द्वारा वर्णित एल्गोरिदम का उपयोग करके स्थानीय न्यूनतम खोजने का प्रयास कर रहा है। इसका इस्तेमाल करते हुए मैं निम्न मान

एक = 0.०,२५,२७,२३७, ख = .०४७६८३७२, ग = -.००१५४९७२१, घ = .०१३८२८२८, ई = 0,002026558

0,2139592 की कुल वर्ग के साथ

मिलता है।

static void Main(string[] args) 
    { 
     var a = FindLocalMinimum(x => SumSq(x, 0, 0, 0, 0)); 
     var b = FindLocalMinimum(x => SumSq(a, x, 0, 0, 0)); 
     var c = FindLocalMinimum(x => SumSq(a, b, x, 0, 0)); 
     var d = FindLocalMinimum(x => SumSq(a, b, c, x, 0)); 
     var e = FindLocalMinimum(x => SumSq(a, b, c, d, x)); 
    } 

    private static float SumSq(float a, float b, float c, float d, float e) 
    { 
     var gls = new[] 
         { 
          2.3, 2.3, 2.5, 2.5, 2.5, 2.5, 2.7, 2.7, 2.7, 2.7, 2.7, 2.9, 2.9, 2.9, 2.9, 2.9, 3.1, 3.1, 3.1 
          , 3.1, 3.1, 3.1, 3.3, 3.3, 3.3, 3.3, 3.3, 3.3, 3.5, 3.5, 3.5, 3.5, 3.5 
         }; 

     var gsh = new[] 
         { 
          0.475, 0.525, 0.425, 0.475, 0.525, 0.575, 0.425, 0.475, 0.525, 0.575, 0.625, 0.425, 0.475, 
          0.525, 0.575, 0.625, 0.375, 0.425, 0.475, 0.525, 0.575, 0.625, 0.375, 0.425, 0.475, 0.525, 
          0.575, 0.625, 0.425, 0.475, 0.525, 0.575, 0.625 
         }; 

     var prob = new[] 
         { 
          0.263636, 0.324159, 0.319328, 0.291295, 0.286086, 0.253994, 0.233766, 0.284644, 0.273818, 
          0.263743, 0.175182, 0.243986, 0.284848, 0.28066, 0.247863, 0.183468, 0.181818, 0.237288, 
          0.269266, 0.2555, 0.240924, 0.206081, 0.209677, 0.216949, 0.263261, 0.25966, 0.23588, 
          0.203252, 0.239316, 0.209184, 0.234818, 0.242424, 0.192118 
         }; 

     var res = 0.0; 
     for (var i = 0; i < prob.Length; i++) 
     { 
      var p = a*Math.Pow(gls[i], 2) + a*Math.Pow(gsh[i], 2) + c*gls[i] + d*gsh[i] + e; 
      res += Math.Pow(p - prob[i], 2); 
     } 
     return (float)res; 
    } 

    private static float FindLocalMinimum(Func<float, float> f) 
    { 
     float bestV = float.MaxValue; 
     float bestX = 0; 
     float x = 0; 
     float lastV = bestV; 
     float diff = 1000.0f; 
     while (Math.Abs(diff) > 0.0001f) 
     { 
      float v = f(x); 
      if (v < bestV) 
      { 
       bestV = v; 
       bestX = x; 
      } 
      else if (v > lastV) 
      { 
       diff *= -0.5f; 
      } 
      lastV = v; 
      x += diff; 
     } 
     return bestX; 
    }