Domain resolution value changes output value...

[BorelHendrake]

In the showcase example of HVAC motor control, the Domain for the motor is defined as follows:

motor = Domain( "Speed", 0, 2000 )

When the example code is run, it results in an output of 1633.122481617619

when the domain has a resolution added as follows:

motor = Domain( "Speed", 0, 2000, 0.1 )

the output when run is then 163.36247274216137

It would appear that changing the resolution is altering the scale of the output -> resolution reduced by an order of magnitude results in an output reduction of an order of magnitude. I do not believe that this is mentioned in the documentation.

Is this the intended result of additing resolution to the domains? Does adding the resolution to the inputs (temperature and humidity in this example) have any scaling consequences?

Thank you very much

[amogorkon]

Well observed. There is some debate on this problem here #47.

[BorelHendrake]

Well, here is the situation I am in. I am interested in applying fuzzy logic to some engineering problems. The first attempted application is in calculating the impedance of a microstrip transmission line. The thinner the line, the higher the impedance, the thinner the line, the lower the impedance. Currently, I have a routine which will iterate over different width of the transmission line to calculate an impedance, compare it to the target impedance and stop when the target impedance is close enough to calculated impedance.

It is my desire to use fuzzy logic and very the amount of change applied to the trace width as we calcuate new impedances. The basic idea is that the larger the error between the target impedance and the desired impedance the more we change the width of the trace. as we get closer to the desired impedance the smaller the change.

As I am new to fuzzy logic, and I really like the implementation of your code, I would like to understand how to implement a simple set of fuzzy logic calculations to determine the change in width to be applied to the trace based on the magnitude of the impedance error.

Below is my test code for attempting to implement the calculations for determining the change in width to be applied to the traces. There are sections which are commented out for plotting the graphs of the veriables involved. I have set up a loop which will run through different errors from large negative errors to large positive errors. The expected outcome is for the width changes to start out large positive, approach 0, and then proceed to large negative numbers.

If the code below is run, the change in width which is output is practically constant. I do not understand where things are going horribly wrong...

If there is any guidance you could suggest, I would greatly appreciate the suggestions...

This code is to be used in another program which calculates the impedance of a
microstrip transmission line

The purpose of this routine is to determine the delta between the
desired impedance and the calculated impedance

The impedance error is the error between the desired impedance and the calculated
impedance

The trace_delta will be the amount that the trace width will be modified by

The idea being the bigger the impedance error, the larger the modification to the trace
before the impedance is calculated again. The smaller the error, the smaller the
change in the trace width

import matplotlib
from fuzzylogic.classes import Domain, Set, Rule
from fuzzylogic.hedges import very
from fuzzylogic.functions import R, S
from fuzzylogic.functions import (sigmoid, gauss, trapezoid, triangular,
                             triangular_sigmoid, rectangular)
import sys

#define the domains of our variables
trace_delta     = Domain( "Delta", -2, 2  )         #width delta in mm
impedance_error = Domain( "Error", -200, 200  )     #impedance error in ohms

#define the various deltas in width
trace_delta.neg_large   = S( -1, -0.25 )
trace_delta.neg_small   = trapezoid( -0.5, -0.25, -0.1, -0.05, c_m = 1 )
#trace_delta.small       = trapezoid( -0.1, -0.05, 0.05, 0.1, c_m = 1 )
#trace_delta.small       = gauss( 0, 100, c_m = 1 )
trace_delta.small       = triangular( -0.1, 0.1 )
trace_delta.pos_small   = trapezoid( 0.05, 0.1, 0.25, 0.5, c_m = 1  )
trace_delta.pos_large   = R( 0.25, 1 )

##define the error magnitude
#impedance_error.neg_large   = S( -100, -50 )
#impedance_error.neg_small   = trapezoid( -70, -30, -10, 0, c_m = 1 )
#impedance_error.small       = trapezoid( -10, -5, 5, 10, c_m = 1 )
#impedance_error.pos_small   = trapezoid( 0, 10, 30, 70, c_m = 1 )
#impedance_error.pos_large   = R( 50, 100 )


#define the error magnitude
impedance_error.neg_large   = S( -100, -50 )
impedance_error.neg_small   = trapezoid( -80, -75, -20, 0, c_m = 1 )
#impedance_error.small       = trapezoid( -30, -5, 5, 30, c_m = 1 )
impedance_error.small       = triangular( -30, 30, c_m = 1 )
impedance_error.pos_small   = trapezoid( 0, 20, 75, 80, c_m = 1 )
impedance_error.pos_large   = R( 50, 100 )



#define the plots
trace_delta.neg_large.plot( )
trace_delta.neg_small.plot( )
trace_delta.small.plot( )
trace_delta.pos_small.plot( )
trace_delta.pos_large.plot( )

##define the plots
#impedance_error.neg_large.plot( )
#impedance_error.neg_small.plot( )
#impedance_error.small.plot( )
#impedance_error.pos_small.plot( )
#impedance_error.pos_large.plot( )


##show the plots
#matplotlib.pyplot.show( )
#sys.exit( )



#define the rules
R1 = Rule( { (impedance_error.neg_large, )  : trace_delta.neg_large    } )
R2 = Rule( { ( impedance_error.neg_small, ) : trace_delta.neg_small } )
R3 = Rule( { ( impedance_error.small, )     : trace_delta.small } )
R4 = Rule( { ( impedance_error.pos_small, ) : trace_delta.pos_small } )
R5 = Rule( { ( impedance_error.pos_large, ) : trace_delta.pos_large } )


#rules = Rule( { ( impedance_error.neg_large, )  : trace_delta.neg_large,
##( impedance_error.neg_small, )    : trace_delta.neg_small,
##( impedance_error.small, )        : trace_delta.small,
##( impedance_error.pos_small, )    : trace_delta.pos_small,
##( impedance_error.pos_large, )    : trace_delta.pos_large,
##} )

#implement the rules
rules = R1 | R2 | R3 | R4 | R5
#rules = sum( [ R1, R2, R3, R4, R5 ] )

#for debug only
for test_value in range( -100, 101, 25 ):
    values = { impedance_error : test_value }
    print(   f'{"-"*80}' )
    print(   f' impedance_error = {test_value}' )
    print(   f'\t{R1( values )=}' )
    print(   f'\t{R2( values )=}' )
    print(   f'\t{R3( values )=}' )
    print(   f'\t{R4( values )=}' )
    print(   f'\t{R5( values )=}' )
    print(   f'\t\t {rules( values ) = }' )

[BorelHendrake]

Tried to fix the formatting for the code segment..
FuzzyLogic-Test4.py.txt

[amogorkon]

You need to use backticks ``` to format a block as code. There, I fixed it for you.

[amogorkon]

trace_delta.neg_large = S( -1, -0.25 ) with a domain of trace_delta = Domain( "Delta", -2, 2 ) looks weird. This assumes a resolution of 1, which is only the values of [-2, -1, 0, 1, 2], no? Is that what you intend?

[BorelHendrake]

trace_delta = Domain( "Delta", -2, 2 ) looks weird. This assumes a resolution of 1, which is only the values of [-2, -1, 0, 1, 2], no? Is that what you intend?

This is where the resolution issue arose. Originally, I had the resolution set to 0.01 as I felt this would be a good incremental value for changing the width. When I was getting results which did not make sense to me, I started experimenting with other resolutions. That piece of code is simply the point where I had eliminated the resolution to see if there would be a difference in the output characteristic. There was not.

It was at this point where I thought I would seek the advise of a resonsible adult who could perhaps show me the error of my ways.

[amogorkon]

It was at this point where I thought I would seek the advise of a resonsible adult who could perhaps show me the error of my ways.

Reasonable? Me? Uhmmm... 😆

Well. "Eliminating" the resolution just means defaulting to 1 in this case. The problem with the resolution probably is with line 493 in classes.py, the final defuzzification step. You can try to experiment and see if you can figure out a better solution?

                return (target_domain._high - target_domain._low) / len(
                    target_domain.range
                ) * index + target_domain._low

[amogorkon]

Btw, thanks a lot for your actual usecase. Helps so much in understanding how my code is actually used and how it's supposed to work. Last person who contacted me wanted me to implement stuff without giving any clue on how it's supposed to work due to "intellectual property" BS. Made me wonder if I should've licensed the lib with GPL3 instead... 🙄

[amogorkon]

Hmmm. Could the problem with the resolution be caused by the negative lower limit in the domain? I'm just trying to reproduce your problem and having a result of -3.2 in a domain that has -2 as lower bound really is an obvious bug.
Also, the result probably should be rounded according to the resolution, no?

[BorelHendrake]

Thank you for taking the time to look at the code.

I also noticed that there were cases where the output would be outside the domain. If the inputs were outside their domain then I would not be surprised at something like that happening. However, if all the values are within the approriate domains, I would not expect that output.

When I run the code, it appears that the output is stuck, or biased, toward the lower end of the domain. I am not sure that I would expect the results to be rounded to the resolution if there is interpolation occuring, but if there is no interpolation, then yes, I would expect a result at some value in the domain that is a multple of the resolution...

In examing things this morning, I was checking to see if the impedance_error, for the various test values, was giving values that made sense. It appears that reasonable values were being returned. This only leaves the application of the various rules returning incorrect values. I was waiting to hear what your thoughts were befroe trying to dive in any deeper as I only have a cursory understanding of the mathematics behind the transformations being applied.

[BorelHendrake]

I have a question concerning the center of gravity calculation (this is where I think things are going horribly wrong):

I modifed the code to print out values of various things:

                target_domain = list(self.conditions.values())[0].domain
                index = sum(v.center_of_gravity( ) * x for v, x in weights) / sum(x for v, x in weights)

                print( f'{target_domain = }' )
                print( f'{index = }' )

                temp_value = (target_domain._high - target_domain._low) / len(
                    target_domain.range
                ) * index + target_domain._low
                
                print( f'{temp_value = }' )
                
                return (target_domain._high - target_domain._low) / len(
                    target_domain.range
                ) * index + target_domain._low

temp_value is the same as the return value. The index value contains a calculation of the center_of_gravity (cog), I print out the cog value from center_of_gravity. For the program that I run with the last value of imepedance_error = 100, I get the following output:

pos_large: weights = array([0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0. , 0. , 0. , 0. ,
0. , 0.01333333, 0.02666667, 0.04 , 0.05333333,
0.06666667, 0.08 , 0.09333333, 0.10666667, 0.12 ,
0.13333333, 0.14666667, 0.16 , 0.17333333, 0.18666667,
0.2 , 0.21333333, 0.22666667, 0.24 , 0.25333333,
0.26666667, 0.28 , 0.29333333, 0.30666667, 0.32 ,
0.33333333, 0.34666667, 0.36 , 0.37333333, 0.38666667,
0.4 , 0.41333333, 0.42666667, 0.44 , 0.45333333,
0.46666667, 0.48 , 0.49333333, 0.50666667, 0.52 ,
0.53333333, 0.54666667, 0.56 , 0.57333333, 0.58666667,
0.6 , 0.61333333, 0.62666667, 0.64 , 0.65333333,
0.66666667, 0.68 , 0.69333333, 0.70666667, 0.72 ,
0.73333333, 0.74666667, 0.76 , 0.77333333, 0.78666667,
0.8 , 0.81333333, 0.82666667, 0.84 , 0.85333333,
0.86666667, 0.88 , 0.89333333, 0.90666667, 0.92 ,
0.93333333, 0.94666667, 0.96 , 0.97333333, 0.98666667,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. ,
1. ])
self.domain.range = array([-2. , -1.99, -1.98, -1.97, -1.96, -1.95, -1.94, -1.93, -1.92,
-1.91, -1.9 , -1.89, -1.88, -1.87, -1.86, -1.85, -1.84, -1.83,
-1.82, -1.81, -1.8 , -1.79, -1.78, -1.77, -1.76, -1.75, -1.74,
-1.73, -1.72, -1.71, -1.7 , -1.69, -1.68, -1.67, -1.66, -1.65,
-1.64, -1.63, -1.62, -1.61, -1.6 , -1.59, -1.58, -1.57, -1.56,
-1.55, -1.54, -1.53, -1.52, -1.51, -1.5 , -1.49, -1.48, -1.47,
-1.46, -1.45, -1.44, -1.43, -1.42, -1.41, -1.4 , -1.39, -1.38,
-1.37, -1.36, -1.35, -1.34, -1.33, -1.32, -1.31, -1.3 , -1.29,
-1.28, -1.27, -1.26, -1.25, -1.24, -1.23, -1.22, -1.21, -1.2 ,
-1.19, -1.18, -1.17, -1.16, -1.15, -1.14, -1.13, -1.12, -1.11,
-1.1 , -1.09, -1.08, -1.07, -1.06, -1.05, -1.04, -1.03, -1.02,
-1.01, -1. , -0.99, -0.98, -0.97, -0.96, -0.95, -0.94, -0.93,
-0.92, -0.91, -0.9 , -0.89, -0.88, -0.87, -0.86, -0.85, -0.84,
-0.83, -0.82, -0.81, -0.8 , -0.79, -0.78, -0.77, -0.76, -0.75,
-0.74, -0.73, -0.72, -0.71, -0.7 , -0.69, -0.68, -0.67, -0.66,
-0.65, -0.64, -0.63, -0.62, -0.61, -0.6 , -0.59, -0.58, -0.57,
-0.56, -0.55, -0.54, -0.53, -0.52, -0.51, -0.5 , -0.49, -0.48,
-0.47, -0.46, -0.45, -0.44, -0.43, -0.42, -0.41, -0.4 , -0.39,
-0.38, -0.37, -0.36, -0.35, -0.34, -0.33, -0.32, -0.31, -0.3 ,
-0.29, -0.28, -0.27, -0.26, -0.25, -0.24, -0.23, -0.22, -0.21,
-0.2 , -0.19, -0.18, -0.17, -0.16, -0.15, -0.14, -0.13, -0.12,
-0.11, -0.1 , -0.09, -0.08, -0.07, -0.06, -0.05, -0.04, -0.03,
-0.02, -0.01, 0. , 0.01, 0.02, 0.03, 0.04, 0.05, 0.06,
0.07, 0.08, 0.09, 0.1 , 0.11, 0.12, 0.13, 0.14, 0.15,
0.16, 0.17, 0.18, 0.19, 0.2 , 0.21, 0.22, 0.23, 0.24,
0.25, 0.26, 0.27, 0.28, 0.29, 0.3 , 0.31, 0.32, 0.33,
0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4 , 0.41, 0.42,
0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5 , 0.51,
0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6 ,
0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69,
0.7 , 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78,
0.79, 0.8 , 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87,
0.88, 0.89, 0.9 , 0.91, 0.92, 0.93, 0.94, 0.95, 0.96,
0.97, 0.98, 0.99, 1. , 1.01, 1.02, 1.03, 1.04, 1.05,
1.06, 1.07, 1.08, 1.09, 1.1 , 1.11, 1.12, 1.13, 1.14,
1.15, 1.16, 1.17, 1.18, 1.19, 1.2 , 1.21, 1.22, 1.23,
1.24, 1.25, 1.26, 1.27, 1.28, 1.29, 1.3 , 1.31, 1.32,
1.33, 1.34, 1.35, 1.36, 1.37, 1.38, 1.39, 1.4 , 1.41,
1.42, 1.43, 1.44, 1.45, 1.46, 1.47, 1.48, 1.49, 1.5 ,
1.51, 1.52, 1.53, 1.54, 1.55, 1.56, 1.57, 1.58, 1.59,
1.6 , 1.61, 1.62, 1.63, 1.64, 1.65, 1.66, 1.67, 1.68,
1.69, 1.7 , 1.71, 1.72, 1.73, 1.74, 1.75, 1.76, 1.77,
1.78, 1.79, 1.8 , 1.81, 1.82, 1.83, 1.84, 1.85, 1.86,
1.87, 1.88, 1.89, 1.9 , 1.91, 1.92, 1.93, 1.94, 1.95,
1.96, 1.97, 1.98, 1.99, 2. ])
cog = 1.2980193236714976
target_domain = Domain('Delta', -2.0, 2.0, res=0.01, sets={'neg_large': Set(<function S..f at 0x00000193A4848A40>), 'neg_small': Set(<function trapezoid..f at 0x00000193CDD71A80>), 'small': Set(<function triangular..f at 0x00000193CF635580>), 'pos_small': Set(<function trapezoid..f at 0x00000193CF635760>), 'pos_large': Set(<function R..f at 0x00000193CF635800>)})
index = 1.2980193236714976
temp_value = -1.9870521763224789
rules( values ) = -1.9870521763224789

The array for pos_large I believe. It looks reasonable. Zeros for the beginng, a transition region, and the last values all 1. So I would say that is correct.

The self.domain.range also looks goot (-2 to 2 with a res=0.1). That is fine.

cog value of 1.298, assuming the np.average calculation is done correctly (and why wouldn't it), seems like a reasonable answer.

The index value is the same as cog. This is not what I would expect. I would expect the index to be an integer which is an index into the array which is closest to 1.298, as such, I would expect an integer and not a float.

using index as an index into the domain (-2 to 2 with res=0.1) is going to return a value very close to -2, which is what appears to be happening looking at temp_value = -1.9870521763224789.

So, it seems to me that the index value is not correct. I am not wise enough to work on fixing the code to get and actual index. Perhaps this is something you could look at and see if what I am saying is correct or not.

Thank you very much

[amogorkon]

Seems like you've done a lot of digging, wow. Okay. Hmm. Let's see...

[BorelHendrake]

I would expect the index to be an integer which is an index into the array which is closest to 1.298, as such, I would expect an integer and not a float.

The return calculation (which should return the appropriate delta value to applied to the width) is attempting to return the value which is closest to 1.298 (which is the cog value returned). The calculation takes the span of the domain, divides it by the number of values in this range, (essentially getting res=0.01 value), multiplies by the index to get the number of res=0.01 steps which corresponds to the closest value of 1.298, and then adds the low value of the domain to obtain that value...

since this returns the closes value to the cog, why not just return the cog? Or, take the cog value and divide by res=0.01 add 0.5 and take the integer value to get the index into the array, and return that value at that index...

seems like just returning the cog would be good enough to me...

[amogorkon]

Sorry, I deleted my comments after re-reading what you posted in detail.

As I understand it, the index is not an integer because at this point in the calculation it's basically an inversion of the axis and the index is abstract - you've calculated the y values, weighted them and then you've got an x value, which is not an actual array index, but rather stands for the relative position inside the continuous, but limited domain. This last step attempts to re-map the relative position inside the domain to the absolute number, taking into account the limits.

[amogorkon]

There is an alternative approach to using arrays, which could actually be intermixed. Simple functions like R, S, triangular, trapezoid could be mapped to actual geometric formulas, so the "index" would really be the x-value of your graph. I hope that clears it up.

[BorelHendrake]

well, I changed the code to simply return the cog value and I appear to be actually getting usable results.

Like I said, I am no expert on this subject, but you statement above pretty much agrees with my observation. In fact, your statement "the index is abstract - you've calculated the y values, weighted them and then you've got an x value, which is not an actual array index, but rather stands for the relative position inside the continuous, but limited domain.", which I agree with (and that is my point), index which is calculated is NOT an index into the array, but it is being treated as if it is...

I also believe your statement "As I understand it, the index is not an integer because at this point in the calculation it's basically an inversion of the axis" I also agree with, and I believe that the cog calculation is performing that inversion and giving you this inverted value which is being calculated as the cog...

As I am not an expert, and have no experience in any of this, this could very well be a coincidence and I am completely wrong...

[amogorkon]

What's the cog value you return now?

[BorelHendrake]

Sorry, I was busy for a couple of days and didn't have time to look at this discussion.

From the above output, the cog = 1.2980193236714976. This is instead of the erroreous -1.9870521763224789.

From the looks of the self.domain.range, this looks like it is a reasonable answer.

[amogorkon]

I would like to ask you a favor. I think the way forward is test-driven. This means I need the simplest possible example for the different combinations of domains with ranges from negative-negative, negativ-zero, zero-positive, positive-positive and different resolutions with their respective expected results. Could you construct a few of those examples which I can turn into tests?

Key points are "obvious" and "simple" so there are no ambiguities on when the code is wrong.

[BorelHendrake]

HI there. Sorry it has taken so long to respond. I got busy with work and had to put this problem aside for a time.

Let me have a think about this and see if there is anything I can generate.