फजी बचाव नियमों का उपयोग कर विकल्पों की बहु-मापदंड पसंद। जावा कार्यान्वयन। भाग 2/3: मूल एल्गोरिथम

पढ़ने से पहले, मैं आपको सलाह देता हूं कि आप लेख का पहला भाग पढ़ें:
फजी बचाव नियमों का उपयोग कर विकल्पों का बहु-मापदंड विकल्प। भाग 1/3: सिद्धांत

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

आपकी सुविधा के लिए, नियम वर्ग के अंदर डेटा (दोहरे तत्वों के एक आयामी सरणियों) को कौशल आवरण कक्षा में संग्रहीत किया जाता है।

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

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


कार्य के अंत में, प्रत्येक वस्तु के लिए बिंदु अनुमान प्राप्त किए जाएंगे, जिनमें से बड़ा मूल्य सबसे अच्छा विकल्प (गेटबोन विधि) से मेल खाता है।

1. आंकड़ों की प्रस्तुति।

मैट्रिक्स डी के आयाम, जो गणना की सटीकता को प्रभावित करते हैं, वेरिएबल्स वर्ग द्वारा निर्धारित किए जाते हैं

package Variables; public class Variables { private static int SIZE_OF_D = 11; private static double STEP_OF_D = (double)1/(SIZE_OF_D-1); public static int SIZE_OF_D();/*  SIZE_OF_D*/ public static double STEP_OF_D();/*  STEP_OF_D*/ } 

संख्या वर्ग जो मुश्किल छँटाई को आसान बनाता है:

 package Support; public class Num { public double x; public double u; public Num(double x, double u); //  x  u } 

कार्य - दिलचस्प कुछ भी नहीं, बस एक विधि और पहचानकर्ता युक्त इंटरफेस।

 package Support; public abstract class Function { public String ID; public abstract double getY(double x); } 

कौशल वर्ग प्रत्येक ऑब्जेक्ट के मापदंडों का वर्णन करने के लिए समान दिखता है:

 package Support; public class Skill { public double[] skill; public Skill(double[] skill);/*  skill  */ } 

मैट्रिक्स के साथ काम करने के लिए, मैट्रिक्स क्लास लिखा जाता है:

 package Support; public class Matrix { private double matrix[][]; public int ROWS; public int COLUMNS; public Matrix(int rows, int columns); //    public Matrix(double[][] m); //    public double[][] getMatrix(); //      public static Matrix findMin(Matrix[] Arr) throws Exception()/*      ,     —  */ { int rows = Arr[0].getMatrix().length; int cols = Arr[0].getMatrix()[0].length; for (int i=0;i<Arr.length;i++) if ((Arr[i].getMatrix().length != rows) || (Arr[i].getMatrix()[0].length != cols)) throw new Exception("Incorrect size of matrix"); double[][] min = new double[rows][cols]; for (int i=0;i<rows;i++) for (int j=0;j<cols;j++) min[i][j]=Double.MAX_VALUE; for (int i=0;i<rows;i++) for (int j=0;j<cols;j++) for (int k=0;k<Arr.length;k++) if (Arr[k].getMatrix()[i][j]<min[i][j]) min[i][j]=Arr[k].getMatrix()[i][j]; return new Matrix(min); } public double[] getRow(int row); //    public void output(); //     } 

नियम - नियमों का विवरण:

 package Support; public class Rule{ public Skill[] u; private Function function; public double[] m; public Rule(Skill[] u, Function function) throws Exception{ this.u = u; this.function = function; m = findMin(u); } public double[] findMin(Skill[] arr) throws Exception /*        (   —     )*/ { int size=arr[0].skill.length; for (int i=0;i<arr.length;i++) if (arr[i].skill.length != size) throw new Exception("Incorrect skill"); double[] min = new double[size]; for (int i=0;i<min.length;i++) min[i] = Integer.MAX_VALUE; for (int i=0;i<arr.length;i++) for (int j=0;j<size;j++) if (arr[i].skill[j]< min[j]) min[j] = arr[i].skill[j]; return min; } public double getF(double x){ /* ,   */ return function.getY(x); } } 

सबसेटड - प्रत्येक नियम के लिए मेट्रिस डी (i) के निर्माण में उपयोग किया जाता है

 package Support; import Variables.Variables; public class SubsetD { private final boolean DEBUG = false; public double[][] d_arr; public SubsetD(Rule rule) throws Exception{ d_arr = makeD(rule); } /*    - */ public double[][] makeD(Rule rule) throws Exception{ d_arr = new double[rule.m.length][Variables.SIZE_OF_D()]; for (int i=0;i<rule.m.length;i++) for (int j=0;j<Variables.SIZE_OF_D();j++){ /*   D,       —      findMin*/ d_arr[i][j]=findMin(1-rule.m[i]+rule.getF(j*Variables.STEP_OF_D())); if (DEBUG) System.out.print("m["+i+"]="+rule.m[i]+"\tj*Variables.STEP_OF_D()="+j*Variables.STEP_OF_D()+"\tY="+rule.getF(j*Variables.STEP_OF_D())+"\n"); } return d_arr; } private double findMin(double x){ if (x>1) return 1; return x; } } 

डेटा प्रविष्टि के लिए जिम्मेदार मुख्य वर्गों में से एक इनपुट है:

 package Support; public abstract class Input { protected Rule[] rl = null; protected Function[] func = null; public int PARAMS_CNT = -1; public int FUNC_CNT = -1; public abstract Rule[] makeRules(double[][] arr) throws Exception; //   public abstract void initFunc(Function[] func); //   public Function[] getFunctions(); //    } 

2. मुखौटा

एल्गोरिथ्म का मुकुट जो सभी आवश्यक गणना करता है।

 package FLO_Engine; import Variables.Variables; import Support.Matrix; import Support.Rule; import Support.SubsetD; import Support.Num; public class Facade { boolean DEBUG_D = false; boolean DEBUG_C = false; boolean DEBUG_LM = false; Facade(boolean debug_d, boolean debug_c, boolean debug_lm){} /*             */ public Matrix calcD(Rule[] rules) throws Exception{ /*      */ //page 97 Rule[] M = rules; //page 98 SubsetD[] sD = new SubsetD[M.length]; for (int i=0;i<M.length;i++) sD[i] = new SubsetD(M[i]); Matrix[] matr = new Matrix[sD.length]; for (int i=0;i<sD.length;i++){ matr[i]=new Matrix(sD[i].d_arr); if (DEBUG_D) ; /*  D(i)*/ } Matrix min = Matrix.findMin(matr); /*   D*/ if (DEBUG_D) min.output(); return min; } public double[] calcC(Matrix D){ /*   */ int len = D.COLUMNS; double[] c = new double[D.ROWS]; /*   ,    */ double[] x = getX(); /*  X    */ for (int i=0;i<D.ROWS;i++){ double[] u = D.getRow(i); Num[] arr = new Num[len]; for (int j=0;j<len;j++) arr[j]= new Num(x[j],u[j]); for (int j=0;j<len;j++) /*     ,  i-   ,             —         */ for (int k=j;k<len;k++) if (arr[k].u<arr[j].u){ Num temp = arr[k]; arr[k] = arr[j]; arr[j] = temp; } c[i] = calcS(arr); /*     i- */ } return c; } public int getBest(double[] C){} //     private double[] getX(){ /*  X      D*/ double[] temp = new double[Variables.SIZE_OF_D()]; for (int i=0;i<temp.length;i++) temp[i]=Variables.STEP_OF_D()*i; return temp; } private double calcS(num[] arr){ /*      */ int size = arr.length; double[] x = new double[size]; double[] u = new double[size]; for (int i=0;i<size;i++){ /*              */ x[i]=arr[i].x; u[i]=arr[i].u; } double max = findMax(u); /*          */ double s = 0.0; double[] m = new double[size]; double[] lbd = new double[size]; for (int i=0;i<size;i++){ /*     */ if (i==0){ lbd[i]=u[0]; m[i]=calcM(x,0); } else{ lbd[i] = u[i]-u[i-1]; m[i] = calcM(x,i); } } for (int i=0;i<size;i++) /*      */ s+=(double)lbd[i]*m[i]; return (double)s/max; //   } private double findMax(double[] arr){} /*   */ private double calcM(double[] x, int first){ /*   */ double s = 0.0; for (int i=first;i<x.length;i++) s+=x[i]; return (double)s/(x.length-first); } } 

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

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

फजी बचाव नियमों का उपयोग कर विकल्पों का बहु-मापदंड विकल्प। जावा कार्यान्वयन। भाग 3/3: उदाहरण