logic problem

[Unknown]

Dear Juan
First of all thank you very much for your supports, and your software.I am using fuzzylite 5.0 and I have built a fuzzy application including 18 membership functions.Basically Trapezoid shape has been used for all functions.The problem is,it provides the output values as a pattern not different atomic values for different input values.(0.8,0.5 likewise).It is my research work and I have added a sample application.It exists similar problem of below fuzzy application as well.

Engine engine = new Engine();
engine.setName(“”);

InputVariable inputVariable1 = new InputVariable();
inputVariable1.setEnabled(true);
inputVariable1.setName(“Q1”);
inputVariable1.setRange(0.000, 1.000);
inputVariable1.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
inputVariable1.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
inputVariable1.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addInputVariable(inputVariable1);

InputVariable inputVariable2 = new InputVariable();
inputVariable2.setEnabled(true);
inputVariable2.setName(“Q2”);
inputVariable2.setRange(0.000, 1.000);
inputVariable2.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
inputVariable2.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
inputVariable2.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addInputVariable(inputVariable2);

InputVariable inputVariable3 = new InputVariable();
inputVariable3.setEnabled(true);
inputVariable3.setName(“Q3”);
inputVariable3.setRange(0.000, 1.000);
inputVariable3.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
inputVariable3.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
inputVariable3.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addInputVariable(inputVariable3);

InputVariable inputVariable4 = new InputVariable();
inputVariable4.setEnabled(true);
inputVariable4.setName(“Q4”);
inputVariable4.setRange(0.000, 1.000);
inputVariable4.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
inputVariable4.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
inputVariable4.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addInputVariable(inputVariable4);

OutputVariable outputVariable1 = new OutputVariable();
outputVariable1.setEnabled(true);
outputVariable1.setName(“OUT1”);
outputVariable1.setRange(0.000, 1.000);
outputVariable1.fuzzyOutput().setAccumulation(new Maximum());
outputVariable1.setDefuzzifier(new Centroid(200));
outputVariable1.setDefaultValue(Double.NaN);
outputVariable1.setLockPreviousOutputValue(false);
outputVariable1.setLockOutputValueInRange(false);
outputVariable1.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
outputVariable1.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
outputVariable1.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.200, 1.400));
engine.addOutputVariable(outputVariable1);

OutputVariable outputVariable2 = new OutputVariable();
outputVariable2.setEnabled(true);
outputVariable2.setName(“OUT2”);
outputVariable2.setRange(0.000, 1.000);
outputVariable2.fuzzyOutput().setAccumulation(new Maximum());
outputVariable2.setDefuzzifier(new Centroid(200));
outputVariable2.setDefaultValue(Double.NaN);
outputVariable2.setLockPreviousOutputValue(false);
outputVariable2.setLockOutputValueInRange(false);
outputVariable2.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
outputVariable2.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
outputVariable2.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addOutputVariable(outputVariable2);

OutputVariable outputVariable3 = new OutputVariable();
outputVariable3.setEnabled(true);
outputVariable3.setName(“OUTFINAL”);
outputVariable3.setRange(0.000, 1.000);
outputVariable3.fuzzyOutput().setAccumulation(new Maximum());
outputVariable3.setDefuzzifier(new Centroid(200));
outputVariable3.setDefaultValue(Double.NaN);
outputVariable3.setLockPreviousOutputValue(false);
outputVariable3.setLockOutputValueInRange(false);
outputVariable3.addTerm(new Trapezoid(“NO”, 0.000, 0.000, 0.200, 0.400));
outputVariable3.addTerm(new Trapezoid(“AVERAGE”, 0.200, 0.400, 0.600, 0.800));
outputVariable3.addTerm(new Trapezoid(“YES”, 0.600, 0.800, 1.000, 1.000));
engine.addOutputVariable(outputVariable3);

RuleBlock ruleBlock1 = new RuleBlock();
ruleBlock1.setEnabled(true);
ruleBlock1.setName(“”);
ruleBlock1.setConjunction(new Minimum());
ruleBlock1.setDisjunction(new Maximum());
ruleBlock1.setActivation(new Minimum());
ruleBlock1.addRule(Rule.parse(“if Q1 is YES and Q2 is YES then OUT1 is YES”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is YES and Q2 is AVERAGE then OUT1 is YES”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is YES and Q2 is NO then OUT1 is NO”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is AVERAGE and Q2 is YES then OUT1 is YES”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is AVERAGE and Q2 is AVERAGE then OUT1 is AVERAGE”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is AVERAGE and Q2 is NO then OUT1 is NO”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is NO and Q2 is YES then OUT1 is NO”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is NO and Q2 is AVERAGE then OUT1 is NO”, engine));
ruleBlock1.addRule(Rule.parse(“if Q1 is NO and Q2 is NO then OUT1 is NO”, engine));
engine.addRuleBlock(ruleBlock1);

RuleBlock ruleBlock2 = new RuleBlock();
ruleBlock2.setEnabled(true);
ruleBlock2.setName(“”);
ruleBlock2.setConjunction(new Minimum());
ruleBlock2.setDisjunction(new Maximum());
ruleBlock2.setActivation(new Minimum());
ruleBlock2.addRule(Rule.parse(“if Q3 is YES and Q4 is YES then OUT2 is YES”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is YES and Q4 is AVERAGE then OUT2 is AVERAGE”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is YES and Q4 is NO then OUT2 is NO”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is AVERAGE and Q4 is YES then OUT2 is YES”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is AVERAGE and Q4 is AVERAGE then OUT2 is AVERAGE”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is AVERAGE and Q4 is NO then OUT2 is NO”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is NO and Q4 is YES then OUT2 is AVERAGE”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is NO and Q4 is AVERAGE then OUT2 is NO”, engine));
ruleBlock2.addRule(Rule.parse(“if Q3 is NO and Q4 is NO then OUT2 is NO”, engine));
engine.addRuleBlock(ruleBlock2);

RuleBlock ruleBlock3 = new RuleBlock();
ruleBlock3.setEnabled(true);
ruleBlock3.setName(“”);
ruleBlock3.setConjunction(new Minimum());
ruleBlock3.setDisjunction(new Maximum());
ruleBlock3.setActivation(new Minimum());
ruleBlock3.addRule(Rule.parse(“if OUT1 is YES and OUT2 is YES then OUTFINAL is YES”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is YES and OUT2 is AVERAGE then OUTFINAL is YES”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is YES and OUT2 is NO then OUTFINAL is AVERAGE”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is AVERAGE and OUT2 is YES then OUTFINAL is AVERAGE”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is AVERAGE and OUT2 is AVERAGE then OUTFINAL is AVERAGE”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is AVERAGE and OUT2 is NO then OUTFINAL is NO”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is NO and OUT2 is YES then OUTFINAL is NO”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is NO and OUT2 is AVERAGE then OUTFINAL is NO”, engine));
ruleBlock3.addRule(Rule.parse(“if OUT1 is NO and OUT2 is NO then OUTFINAL is NO”, engine));
engine.addRuleBlock(ruleBlock3);

*********** ********************************
Q1-0.5 Q2-1 Q3-1 Q4-0.5
Q1-1 Q2-0.5 Q3-0.5 Q4-1
Q1-0.5 Q2-0.2 Q3-1 Q4-1
Q1-1 Q2-0.2 Q3-1 Q4-1
Q1-1 Q2-1 Q3-1 Q4-1
***********************************************
For the above inputs it provides 0.844,0.844,0.156,0.156,0.844.But I am expecting different different values for each input segments.
How can change my logic?Is it a problem with the shapes of membership functions or centroid defuzzification method? It is grateful if you could tell me the correct way of obtaining atomic values for each input segments.(eg: 0.844,0.799,0.250,0.360,0.692)

Thank you.

[Juan Rada-Vilela (admin)]

Hi,

Thank you for your post.

This seems a bit too complex and hard to follow. My best advice is that you use QtFuzzyLite to precisely detail what is happening with your engine. Once you do, please post an image of what you see, what you expect and why.

I also do not understand what you mean by atomic values and input segments.

Cheers.

[Author]

Posts