प्रोग्राम उद्देश्य: एकीकरण का उपयोग करके लक्ष्य को परिभाषित करना। मैं उच्च आयामों (100 तक) के लिए एक अनुकूली चतुर्भुज (उर्फ संख्यात्मक एकीकरण) एल्गोरिदम लागू कर रहा हूं। विचार उस बिंदु पर त्रुटि के अनुमान के अनुपात में नमूना घनत्व का उपयोग करके अंक का मूल्यांकन करके छोटे वर्गों में वॉल्यूम को यादृच्छिक रूप से तोड़ना है। प्रारंभिक रूप से मैं एक समान नमूना "बर्न-इन" करता हूं, फिर अनुमानित त्रुटि पर गॉसियन वितरण के अनुसार यादृच्छिक रूप से अंक चुनते हैं। नकली एनीलिंग के समान तरीके से, मैं "तापमान कम करता हूं" और समय के साथ-साथ अपने गॉसियन के मानक विचलन को कम करता हूं, ताकि कम त्रुटि वाले बिंदुओं में शुरुआत में चुने जाने का एक उचित मौका हो, लेकिन बाद में लगातार कम हो रहा है संभावना। यह प्रोग्राम को स्पाइक्स पर ठोकरने में सक्षम बनाता है जो त्रुटि फ़ंक्शन में अपूर्णताओं के कारण याद किया जा सकता है। (मेरा एल्गोरिदम भावना में मार्कोव-चेन मोंटे-कार्लो एकीकरण है।)माइक्रोसॉफ्ट सॉल्यूशन फाउंडेशन
फ़ंक्शन लक्षण। एक एकीकृत आपदा के कारण कई इमारतों के लिए बीमा पॉलिसी हानि का अनुमान लगाया जाना है। नीति कार्य आसान नहीं हैं: कटौती, अधिकतम सीमाएं, परतें (उदाहरण के लिए 1 मिलियन डॉलर की हानि तक शून्य भुगतान, 1-2 मिलियन डॉलर से 100% भुगतान, फिर 2 मिलियन डॉलर से अधिक शून्य भुगतान) और अन्य विषम नीति शर्तें हैं। यह गैर-रैखिक व्यवहार और कार्यों को प्रस्तुत करता है जिनमें कई विमानों में व्युत्पन्न नहीं है। पॉलिसी फ़ंक्शन के शीर्ष पर क्षति का कार्य होता है, जो इमारत के प्रकार और तूफान की ताकत से भिन्न होता है और निश्चित रूप से घंटी के आकार का नहीं होता है।
समस्या संदर्भ: त्रुटि फ़ंक्शन। कठिनाई एक अच्छा त्रुटि समारोह चुन रहा है। प्रत्येक बिंदु के लिए मैं उन उपायों को रिकॉर्ड करता हूं जो इसके लिए उपयोगी लगते हैं: फ़ंक्शन की परिमाण, पिछले माप के परिणामस्वरूप (यह पहली व्युत्पन्न के लिए प्रॉक्सी) के परिणामस्वरूप कितनी बदल गई, उस बिंदु की मात्रा जिस पर बिंदु है (बड़ी मात्राएं हो सकती हैं त्रुटि को बेहतर छिपाएं), और क्षेत्र के आकार से संबंधित एक ज्यामितीय कारक। मेरा त्रुटि फ़ंक्शन इन उपायों का एक रैखिक संयोजन होगा जहां प्रत्येक उपाय को एक अलग वजन दिया जाता है। (यदि मुझे खराब परिणाम मिलते हैं, तो मैं गैर-रैखिक कार्यों पर विचार करूंगा।) इस प्रयास में मेरी सहायता करने के लिए, मैंने प्रत्येक वजन के लिए संभावित मूल्यों की एक विस्तृत श्रृंखला पर ऑप्टिमाइज़ेशन करने का निर्णय लिया, इसलिए माइक्रोसॉफ्ट सॉल्यूशन फाउंडेशन।
अनुकूलित करने के लिए क्या करें: त्रुटि रैंक। मेरे उपायों को शून्य से एक से सामान्यीकृत किया जाता है। इन त्रुटि मानों को क्रमिक रूप से संशोधित किया जाता है क्योंकि एकीकरण कार्य फ़ंक्शन मानों, परिवर्तनों आदि के लिए हालिया औसत को प्रतिबिंबित करने के लिए प्राप्त होता है। परिणामस्वरूप, मैं एक ऐसा फ़ंक्शन बनाने की कोशिश नहीं कर रहा हूं जो वास्तविक त्रुटि मान उत्पन्न करता है, लेकिन इसके बजाय एक संख्या उत्पन्न करता है जो समान है वास्तविक त्रुटि, यानी यदि सभी नमूना बिंदु इस अनुमानित त्रुटि मान द्वारा क्रमबद्ध किए जाते हैं, तो उन्हें सही रैंक द्वारा क्रमबद्ध रैंक के समान रैंक प्राप्त करना चाहिए।
सभी बिंदु बराबर नहीं हैं। मुझे बहुत अधिक परवाह है यदि # 1 सच्ची त्रुटि वाले बिंदु क्षेत्र को # 1000 (या इसके विपरीत) रैंक किया गया है, लेकिन # 500 बिंदु # 1000 स्थान पर है तो बहुत कम ध्यान दें। सफलता का मेरे उपाय बीच-बीच में एल्गोरिथ्म के निष्पादन में एक बिंदु पर कई क्षेत्रों पर निम्नलिखित का योग कम करने के लिए है:
ABS (log2 (trueErrorRank) - log2 (estimatedErrorRank))
log2 के लिए मैं उपयोग कर रहा हूँ एक फ़ंक्शन जो संख्या से कम या उसके बराबर की सबसे बड़ी शक्ति देता है। इस परिभाषा से, उपयोगी परिणाम आओ। स्वैपिंग # 1 और # 2 एक बिंदु खर्च करते हैं, लेकिन # 2 और # 3 स्वैपिंग कुछ भी नहीं है। इसका दो स्तरों की शक्ति में स्तरीकरण बिंदुओं का प्रभाव पड़ता है। एक श्रेणी के भीतर स्वैप किए गए अंक फ़ंक्शन में नहीं जुड़ते हैं।
मैं का मूल्यांकन कैसे करता हूं।एक बार सच त्रुटि द्वारा
रैंक सभी क्षेत्रों: मैं एक वर्ग रैंक कहा जाता है कि यह करता है का निर्माण किया है।
पैरामीटरयुक्त वजन के प्रत्येक अलग सेट के लिए, यह उस क्षेत्र के लिए परीक्षण (अनुमानित) त्रुटि की गणना करता है।
उस परीक्षण त्रुटि से क्षेत्रों को टाइप करता है।
प्रत्येक क्षेत्र के लिए परीक्षण रैंक की गणना करता है।
दो रैंकों के लॉग का पूर्ण अंतर जोड़ता है और पैरामीटर के मान पर कॉल करता है, इसलिए मान कम हो जाता है।
सी # कोड। ऐसा करने के बाद, मुझे सबसे अच्छा पैरामीटर खोजने के लिए मुझे माइक्रोसॉफ्ट सॉल्वर फाउंडेशन स्थापित करने का एक तरीका चाहिए। सिंटैक्स ने मुझे स्टंप किया है। यहां मेरा सी # कोड है जो अब तक है। इसमें आप टिप्पणियों को तीन समस्याओं के लिए देखेंगे जिन्हें मैंने पहचाना है। शायद आप और भी स्पॉट कर सकते हैं! कोई विचार यह काम कैसे करें?
public void Optimize()
{
// Get the parameters from the GUI and figures out the low and high values for each weight.
ParseParameters();
// Computes the true rank for each region according to true error.
var myRanker = new Rank(ErrorData, false);
// Obtain Microsoft Solver Foundation's core solver object.
var solver = SolverContext.GetContext();
var model = solver.CreateModel();
// Create a delegate that can extract the current value of each solver parameter
// and stuff it in to a double array so we can later use it to call LinearTrial.
Func<Model, double[]> marshalWeights = (Model m) =>
{
var i = 0;
var weights = new double[myRanker.ParameterCount];
foreach (var d in m.Decisions)
{
weights[i] = d.ToDouble();
i++;
}
return weights;
};
// Make a solver decision for each GUI defined parameter.
// Parameters is a Dictionary whose Key is the parameter name, and whose
// value is a Tuple of two doubles, the low and high values for the range.
// All are Real numbers constrained to fall between a defined low and high value.
foreach (var pair in Parameters)
{
// PROBLEM 1! Should I be using Decisions or Parameters here?
var decision = new Decision(Domain.RealRange(ToRational(pair.Value.Item1), ToRational(pair.Value.Item2)), pair.Key);
model.AddDecision(decision);
}
// PROBLEM 2! This calls myRanker.LinearTrial immediately,
// before the Decisions have values. Also, it does not return a Term.
// I want to pass it in a lambda to be evaluated by the solver for each attempted set
// of decision values.
model.AddGoal("Goal", GoalKind.Minimize,
myRanker.LinearTrial(marshalWeights(model), false)
);
// PROBLEM 3! Should I use a directive, like SimplexDirective? What type of solver is best?
var solution = solver.Solve();
var report = solution.GetReport();
foreach (var d in model.Decisions)
{
Debug.WriteLine("Decision " + d.Name + ": " + d.ToDouble());
}
Debug.WriteLine(report);
// Enable/disable buttons.
UpdateButtons();
}
अद्यतन: मैं एक वापस आने के रूप में एक और पुस्तकालय के लिए देखने का फैसला किया है, और DotNumerics (http://dotnumerics.com/) में पाया गया। उनके Nelder-मीड सिंप्लेक्स solver कॉल करने के लिए आसान था:
Simplex simplex = new Simplex()
{
MaxFunEvaluations = 20000,
Tolerance = 0.001
};
int numVariables = Parameters.Count();
OptBoundVariable[] variables = new OptBoundVariable[numVariables];
//Constrained Minimization on the intervals specified by the user, initial Guess = 1;
foreach (var x in Parameters.Select((parameter, index) => new { parameter, index }))
{
variables[x.index] = new OptBoundVariable(x.parameter.Key, 1, x.parameter.Value.Item1, x.parameter.Value.Item2);
}
double[] minimum = simplex.ComputeMin(ObjectiveFunction, variables);
Debug.WriteLine("Simplex Method. Constrained Minimization.");
for (int i = 0; i < minimum.Length; i++)
Debug.WriteLine(Parameters[i].Key + " = " + minimum[i].ToString());
सभी मैं ObjectiveFunction एक विधि एक डबल सरणी लेने के रूप में लागू करने के लिए था की जरूरत:
private double ObjectiveFunction(double[] weights)
{
return Ranker.LinearTrial(weights, false);
}
मैं वास्तविक डेटा के खिलाफ इसे करने की कोशिश नहीं की है, लेकिन मैंने परीक्षण डेटा सेट अप करने और इसे स्कोर करने के लिए Excel में सिमुलेशन बनाया है। उनके एल्गोरिदम से वापस आने वाले परिणाम सही नहीं थे, लेकिन एक बहुत अच्छा समाधान दिया।
मुझे लगता है कि "टीएलडीएनआर" के लोगों का एक-क्लिक विकल्प उपरोक्त है। मैं इस सिद्धांत का परीक्षण कर सकता हूं जो एक अविश्वसनीय रूप से जटिल लगता है, कुछ उन्नत कम्प्यूटेशनल एल्गोरिदम buzz शब्दों और कोड स्निपेट का एक स्पलैश छोड़ देता है। एह, कभी नहीं, मैं बस इसके बजाय इसे ऊपर उठाऊंगा। :-) – kingdango