Fuzzy Logic in R

Author

Kunal Choudhary

Published

February 3, 2023

Abstract

This article explores the implementation of fuzzy logic in R, covering user-defined functions and built-in packages. From basic concepts to advanced applications, readers will learn to apply fuzzy logic techniques for enhanced decision-making in diverse fields.

The Tipping Problem

The Tipping Problem serves as a classic demonstration of fuzzy logic’s ability to distill complex decision-making into a set of intuitive rules. In this scenario, we aim to develop a fuzzy logic system that predicts the appropriate tip percentage at a restaurant based on service quality and food rating, both rated on a scale of 0 to 10. The output, tipping percentage, ranges from 0% to 25%.

We define three linguistic variables: service (with categories poor, good, excellent), food quality (with categories bad, decent, great), and tip (with categories low, medium, high).

Three expert rules guide our fuzzy logic system:

  1. IF service is excellent OR food quality is great, THEN tip is high.
  2. IF service was good, THEN tip is medium.
  3. IF service was poor AND food quality was bad, THEN tip is low.

These rules provide a simple yet effective framework for translating qualitative assessments of service and food quality into a quantitative tipping recommendation, showcasing the power of fuzzy logic in modeling real-world decision-making processes.

Implementation from Scratch

To implement the Fuzzy Logic System (FLS) from scratch, we need to follow several steps:

  1. Define linguistic variables: Define the linguistic variables for service, food quality, and tip, along with their respective membership functions.

  2. Define fuzzy rules: Encode the expert rules into fuzzy IF-THEN statements.

  3. Fuzzification: Convert crisp input values (service quality and food rating) into fuzzy sets using the defined membership functions.

  4. Apply fuzzy rules: Use the fuzzy IF-THEN statements to determine the degree of membership for each output fuzzy set.

  5. Aggregation: Combine the outputs from different rules to determine the overall fuzzy output.

  6. Defuzzification: Convert the aggregated fuzzy output back into a crisp value (tip percentage).

We’ll proceed with these steps using R programming to illustrate the implementation of the FLS from scratch. Let’s begin by defining the linguistic variables and their membership functions.

Let’s start constructing our membership functions. We define trapezoid membership functions for all both the inputs and output. Since the domain of service and food quality is the same, let’s keep their membership functions the same as well. The trapezoids are left- and right-open for 1st and 3rd linguistic variables for e.g. for service, ‘poor’ and ‘great’ have left- and right-open trapezoids respectively.

Let’s consider a scenario where we have service rating of 4.5 and food quality 6. Here we will treat this input as a fuzzy singleton.

Code 
# let's define the domain of input and output 
service_domain = seq(0,10,0.1) 
food_domain = seq(0,10,0.1) 
tip_domain = seq(0,0.25,0.001)

service_input = 4.5
food_input = 6

trapezoid = function(x, a, b, c, d){
  ifelse(x <= a, 0, ifelse(x <= b, (x-a)/(b-a),ifelse(x <= c, 1,
                                  ifelse(x <= d, (d-x)/(d-c), 0))))
}
# let's define membership functions
food.bad = service.poor = function(x){ 
  ifelse(x <= 3, 1, ifelse(x<= 5, (5-x)/(5-3), 0)) 
} 
food.decent = service.good = function(x){ 
  trapezoid(x, 3,4,6,7)
} 
food.great = service.ex = function(x){ 
  ifelse(x <= 5, 0, ifelse(x<=7, (x-5)/(7-5), 1))
} 

#
tip.low = function(x){ 
  ifelse(x <= 0.083, 1, ifelse(x<= 0.125, (0.125-x)/(0.125-0.083), 0)) 
} 
tip.med = function(x){ 
  trapezoid(x, 0.083,0.11,0.13,0.167)
} 
tip.high = function(x){ 
  ifelse(x <= 0.125, 0, ifelse(x<=0.167, (x-0.125)/(0.167-0.125), 1))
}

Let’s plot these functions & see where the inputs belong.

Membership values for service rating of 4.5 in Poor: 0.25, in Good: 1 and in Excellent: 0 Membership values for food quality of 6.0 in Bad 0, in Decent 1 and in Great 0.5

Here, we will see the rules firing and evaluate the output fuzzy set under the Mamdani Model.

Code 
w1 = max(service.ex(service_input), food.great(food_input))
w2 = service.good(service_input)
w3 = min(service.poor(service_input), food.bad(food_input))
cat('Firing strength of Rule 1 =',w1,', of Rule 2 =',w2,'and of Rule 3 =',w3)

Firing strength of Rule 1 = 0.5 , of Rule 2 = 1 and of Rule 3 = 0

Code 
# shape of output fuzzy set 
final_tip.low = pmin(w3, tip.low(tip_domain))
final_tip.med = pmin(w2, tip.med(tip_domain))
final_tip.high = pmin(w1, tip.high(tip_domain))
final = pmax(final_tip.low, final_tip.med, final_tip.high)

# centroid defuzzification
centroid_value = round(sum(tip_domain*final)/sum(final),3)
plot(tip_domain, final, type='l', col='red', xlab='Tip', 
     ylab='Membership Value', 
     main=paste('Tip Output, Centroid value :',100*centroid_value,'%'),
     lwd=2, ylim=c(0, 1))
abline(v=centroid_value, lty=2, lwd=2, col='red')
legend('topright',c('Centroid'),lty=2,lwd=2,col='red',bty='n')

Let’s explore other forms from numerical to linguistic defuzzification methods .

Code 
# numerical defuzzification
centroid_value = round(sum(tip_domain*final)/sum(final),3)
max_mem = tip_domain[which.max(final)]

library(pracma)
total_area = trapz(tip_domain, final)
bisector_value = tip_domain[which.min(abs(cumtrapz(tip_domain, final) - total_area/2))]
# mean, largest, smallest of max
mom = mean(tip_domain[final == max(final)])
lom = max(tip_domain[final == max(final)])
som = min(tip_domain[final == max(final)])

plot(tip_domain, final, type='l', col=1, xlab='Tip', ylab='Membership Value', 
     main='Numeric Defuzzification',lwd=2, ylim=c(0, 1))
abline(v=centroid_value, lty=2, lwd=2, col=2)
abline(v=max_mem, lty=2, lwd=2, col=3)
abline(v=bisector_value, lty=2, lwd=2, col=4)
abline(v=mom, lty=2, lwd=2, col=5)
abline(v=lom, lty=2, lwd=2, col=6)
abline(v=som, lty=2, lwd=2, col=7)
legend('topleft',c('Centroid','Max Membership','Bisector',
                   'Mean of Max','Largest of Max',
                   'Smallest of Max'),lty=2,lwd=2,col=1:7,bty='n')

Centroid = 16.1 %, Max Membership = 11 %, Bisector = 15.2 %, Mean of Max = 12 %, Largest of Max = 13 and Smallest of Max = 11

Code 
# linguistic defuzzification functions
jaccard_similarity = function(a, b) {
  union = sum(pmax(a, b))
  intersection = sum(pmin(a, b))
  if (union == 0) return(0)  # avoid division by zero
  else return(intersection / union)
}
dice_similarity = function(a, b){
  num = sum(a*b)
  den = 0.5*(sum(a^2) + sum(b^2))
  if(den == 0) return(0)    # avoid division by zero
  else return(num/den)
}
manhattan_dist = function(a, b){
  sum(abs(a-b))/length(a) 
}

hausdorff_distance = function(a,b){
  alpha <- seq(0, 1, 0.1)
  df <- numeric()
  for (i in 1:length(alpha)) {
    a_alphacut <- tip_domain[a >= alpha[i]]
    b_alphacut <- tip_domain[b >= alpha[i]]
    a1 <- as.numeric(ifelse(a_alphacut == 0, 0, min(a_alphacut)))
    a2 <- as.numeric(ifelse(a_alphacut == 0, 0, max(a_alphacut)))
    b1 <- as.numeric(ifelse(b_alphacut == 0, 0, min(b_alphacut)))
    b2 <- as.numeric(ifelse(b_alphacut == 0, 0, max(b_alphacut)))
    dist1 <- abs(a1 - b1)
    dist2 <- abs(a2 - b2)
    if (all(dist1 == 0) && all(dist2 == 0)) { df[i] <- 0
    } else { df[i] <- max(dist1, dist2) }
  }
  sum(df) / length(alpha)
}

linguistic_terms = c('Low', 'Medium', 'High')
distances <- sapply(linguistic_terms, function(term) {
  term_membership <- switch(term, 
                            'Low' = tip.low(tip_domain), 
                            'Medium' = tip.med(tip_domain), 
                            'High' = tip.high(tip_domain))
  rbind(jaccard_similarity(final, term_membership),
        dice_similarity(final, term_membership),
        manhattan_dist(final, term_membership),
        hausdorff_distance(final, term_membership)) 
  })
closest_term = rbind(cbind(linguistic_terms[apply(distances[1:2,], 1, which.max)]),
                     cbind(linguistic_terms[apply(distances[3:4,], 1, which.min)]))
df = cbind(metric=c('Jaccard','Dice','Manhattan','Hausdorff'),
           as.data.frame(distances),closest_term)
library(gt)
gt(df) %>% 
  tab_header(title = md('**Linguistic Defuzzification**')) %>% 
  tab_row_group(label = md('**Distance Metrics**'), rows = 3:4) %>% 
  tab_row_group(label = md('**Similarity Metrics**'), rows = 1:2) %>% 
  cols_label(metric='Metric',closest_term='Output') %>% 
  tab_style(style = list(cell_fill(color='#a7d0db')),locations=cells_row_groups()) %>% 
  tab_style(style = list(cell_text(weight = 'bold')),
            locations=cells_body(columns = c('closest_term'), rows = 1:4))
Linguistic Defuzzification
Metric Low Medium High Output
Similarity Metrics
Jaccard 0.06720102 0.5285714 0.39587798 Medium
Dice 0.12762180 0.7897848 0.65879519 Medium
Distance Metrics
Manhattan 0.70648651 0.1847744 0.34981567 Medium
Hausdorff 0.17590909 0.0430000 0.07254545 Medium
Code 
l1 = service.ex(service_input)*food.great(food_input)
l2 = service.good(service_input)
l3 = service.poor(service_input)*food.bad(food_input)
cat('Firing strength of Rule 1 =',l1,', of Rule 2 =',l2,'and of Rule 3 =',l3)
Firing strength of Rule 1 = 0 , of Rule 2 = 1 and of Rule 3 = 0
Code 
# shape of output fuzzy set 
l.final_tip.low = pmin(l3, tip.low(tip_domain))
l.final_tip.med = pmin(l2, tip.med(tip_domain))
l.final_tip.high = pmin(l1, tip.high(tip_domain))
l.final = pmax(l.final_tip.low, l.final_tip.med, l.final_tip.high)

# centroid defuzzification
l.centroid_value = round(sum(tip_domain*l.final)/sum(l.final),3)
plot(tip_domain, l.final, type='l', col='red', xlab='Tip', 
     ylab='Membership Value', 
     main=paste('Tip Output, Centroid value :',100*l.centroid_value,'%'),
     lwd=2, ylim=c(0, 1))
abline(v=l.centroid_value, lty=2, lwd=2, col='red')
legend('topright',c('Centroid'),lty=2,lwd=2,col='red',bty='n')

To implement Zero-Order TSK we first need to modify the rules a bit:

  • IF service is excellent OR food quality is great, THEN tip = 20%.

  • IF service was good, THEN tip = 12.5%.

  • IF service was poor AND food quality was bad, THEN tip = 5%.

Code 
tsk.w1 = max(service.ex(service_input),food.great(food_input))
tsk.w2 = service.good(service_input)
tsk.w3 = min(service.poor(service_input),food.bad(food_input))
cat('Firing strength of Rule 1 =',tsk.w1,', of Rule 2 =',tsk.w2,'and of Rule 3 =',tsk.w3)

Firing strength of Rule 1 = 0.5 , of Rule 2 = 1 and of Rule 3 = 0

Code 
output = (tsk.w1*0.20 + tsk.w2*0.125 + tsk.w3*0.05) / sum(tsk.w1,tsk.w2,tsk.w3)

Final Tip = 15 %

Now let’s implement First-order TSK with the following rules:

  • IF service is excellent OR food quality is great, THEN tip = 0.1*Service + 0.15*Food - 1.15

  • IF service was good, THEN tip = 0.025*Service + 0.05

  • IF service was poor AND food quality was bad, THEN tip = 0.1*Service + 0.05*Food - 0.085

Code 
tsk1.w1 = max(service.ex(service_input),food.great(food_input))
tsk1.w2 = service.good(service_input)
tsk1.w3 = min(service.poor(service_input),food.bad(food_input))
cat('Firing strength of Rule 1 =',tsk1.w1,', of Rule 2 =',tsk1.w2,'and of Rule 3 =',tsk1.w3)

Firing strength of Rule 1 = 0.5 , of Rule 2 = 1 and of Rule 3 = 0

Code 
final_output = tsk1.w1*(0.1*service_input + 0.15*food_input - 1.15) + tsk1.w2*(0.025*service_input + 0.05) + tsk1.w3*(0.1*service_input + 0.05*food_input - 0.085)/sum(tsk1.w1,tsk1.w2,tsk1.w3)

Final Tip = 26.25 %

Package FuzzyR

The FuzzyR package was produced by the Intelligent Modelling and Analysis Group and Lab for Uncertainty in Data and decision making (LUCID), University of Nottingham. Here is the link to IEEE Xplore website and the R Documentation & Github for the package.

Let’s introduce some of the key functions and how they work:

  • First, we initialise our Fuzzy Inference System (FIS) by using newfis() command. Here, we can specify the name of our inference system, model type, and/or methods, aggregate and defuzzification methods.

  • Next to define our input and output linguistic variables, we use addvar() command. Here, we mention our fis object, specify if this is an input or output linguistic variable, give an index, name and define the membership function for it.

    • varIndex = 1 implies that this is the first input/output variable.

    • mfType = ‘gaussmf’ for Gaussian, ‘trapmf’ for trapezoid, ‘trimf’ for triangular, ‘gbellmf’ for generalized bell function, ‘linearmf’ for linear function.

    • mfParamas = c(2,3) for example are Gaussian parameters where sigma = 2 and mu = 3. Similarly, we can provide other parameter values of membership functions.

  • Next we define our fuzzy rules. For this use rbind() to row-wise combine the rule structures for each rule. Then we specify this in addrule() command. The rules can be printed using showrule() command.

    • Let’s understand the rule structure : c(1st Input’s Linguistic Variable’s index, 2nd Input’s Linguistic Variable’s index, 1st Output’s Linguistic Variable’s index, Fuzzy Operator for Consequents, Fuzzy Operator for Antecedents)

    • The first fuzzy rule : IF Service is Excellent OR Food is Great, Then Tip is High >>> is formulated as c(3, 3, 3, 1, 2) because Excellent is 3rd variables for service, Great is 3rd variable for food and High is 3rd variable for Tip. Then, ‘1’ implies that consequents are combined using AND operator to produce the final fuzzy output. Then, ‘2’ implies that antecedents are combined using OR operator.

    • The default andMethod = “min”, orMethod = “max” under newfis() command.

  • To see the entire structure of our Fuzzy Inference System we can use the showfis() command.

  • To evaluate the output for a given set of input values, we can use the evalfis() command.

  • Lastly, we can produce some plots

    • Membership functions can be plotted using plotmf() command by specifying our fis, variable index, variable type and labels.

    • We can generate a Surface Plot using gensurf() command.

    • Here, modification is made using Plotly package, to provide an interactive 3D Surface Plots.

Code 
library(FuzzyR)

# initialise a fuzzy inference system (fis)
fis = newfis('Tipper')

# define inputs
fis = addvar(fis, 'input', 'food quality', c(0,10))
fis = addvar(fis, 'input', 'service rating', c(0,10))

# define output
fis = addvar(fis, 'output', 'tip', c(0,0.25))

# define membership functions
# for food quality
fis = addmf(fis, 'input', varIndex = 1, 'bad', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 1, 'decent',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 1, 'great',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for service rating
fis = addmf(fis, 'input', varIndex = 2, 'poor', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 2, 'good',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 2, 'excellent',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for tip 
fis = addmf(fis, 'output', varIndex = 1, 'low', mfType = 'gaussmf', 
            mfParams = c(0.05, 0.0833))
fis = addmf(fis, 'output', varIndex = 1, 'medium', mfType = 'gaussmf', 
            mfParams = c(0.05, 0.125))
fis = addmf(fis, 'output', varIndex = 1, 'high',    mfType = 'gaussmf', 
            mfParams = c(0.05, 0.1667))

# define fuzzy rules
# if excellent service OR great food, then tip High
# if good service, then tip Medium
# if poor service AND bad food, then tip Low
rules = rbind(c(3,3,3,1,2), c(0,2,2,1,0), c(1,1,1,1,1))
fis = addrule(fis, rules)
# fuzzy rules using linguistic variables
showrule(fis)
  1. If (food quality is great) or (service rating is excellent) then (tip is high) (1)
  2. If (service rating is good) then (tip is medium) (1)
  3. If (food quality is bad) and (service rating is poor) then (tip is low) (1)
Code 
# outline of the fuzzy inference system
# showfis(fis)

# evaluate
result = evalfis(c(food_input,service_input), fis)
cat('Tip =', round(result*100,2),'%')

Tip = 14.2 %

Code 
# plot membership functions
# plotmf(fis, varType = 'input',varIndex = 1,main = 'Food Quality')
# plotmf(fis, varType = 'input',varIndex = 2,main = 'Service Rating')
# plotmf(fis, varType = 'output',varIndex = 1,main = 'Tip')

# generate surface area plot
# gensurf(fis)

library(plotly)
gensurf_plotly = function(fis,ix1 = 1,ix2 = 2,ox1 = 1){
  i1 = fis$input[[ix1]]
  i2 = fis$input[[ix2]]
  o1 = fis$output[[ox1]]

  x = seq(i1$range[1], i1$range[2], length = 30)
  y = seq(i2$range[1], i2$range[2], length = 30)
  m = as.matrix(expand.grid(x, y))

  o = evalfis(m, fis)
  z = matrix(o[, ox1], 30, 30, byrow = F)

  plot_ly(x = ~x, y = ~y, z = ~z, type = "surface") %>%
    layout(scene = list(xaxis = list(title = i1$name),
                        yaxis = list(title = i2$name),
                        zaxis = list(title = o1$name)))
}

gensurf_plotly(fis)

In order to implement Larsen Model, we need to specify andMethod and orMethod as ‘prod’ for product. This ensures that the antecedents are combined correctly per the Larsen Model.

Code 
fis = newfis('tipper', andMethod = 'prod',orMethod = 'prod')

fis = addvar(fis, 'input', 'service', c(0, 10))
fis = addvar(fis, 'input', 'food', c(0, 10))
fis = addvar(fis, 'output', 'tip', c(0, 0.25))

# define membership functions
# for food quality
fis = addmf(fis, 'input', varIndex = 1, 'bad', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 1, 'decent',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 1, 'great',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for service rating
  fis = addmf(fis, 'input', varIndex = 2, 'poor', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 2, 'good',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 2, 'excellent',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for tip 
fis = addmf(fis, 'output', varIndex = 1, 'low', mfType = 'gaussmf', 
            mfParams = c(0.05, 0.0833))
fis = addmf(fis, 'output', varIndex = 1, 'medium', mfType = 'gaussmf', 
            mfParams = c(0.05, 0.125))
fis = addmf(fis, 'output', varIndex = 1, 'high',    mfType = 'gaussmf', 
            mfParams = c(0.05, 0.1667))

# define fuzzy rules
rules = rbind(c(3,3,3,1,2), c(0,2,2,1,1), c(1,1,1,1,1))
fis = addrule(fis, rules)
# fuzzy rules using linguistic variables
showrule(fis)
  1. If (service is great) or (food is excellent) then (tip is high) (1)
  2. If (food is good) then (tip is medium) (1)
  3. If (service is bad) and (food is poor) then (tip is low) (1)
Code 
# evaluate
result = evalfis(c(food_input,service_input), fis)
cat('Tip =', round(100*result,2),'%')

Tip = 12.95 %

Code 
# surface plot
gensurf_plotly(fis)

For implementing the TSK model, we need to make the following changes:

  • We specify fisType = ‘tsk’ in newfis() command to specify that we are creating a TSK model.

  • We mention ‘singleton.fuzzification’ to ensure that the inputs are dealt as fuzzy singleton.

  • Lastly, we change the output membership functions to ‘linearmf’ and specify the values of the linear relationship. For example, c(10, 0.5, 0.5) implies, tip = 10 + 0.5*food + 0.5*service for medium tip.

Code 
fis = newfis('tipper', fisType = 'tsk')

fis = addvar(fis, 'input', 'service', c(0, 10), 'singleton.fuzzification')
fis = addvar(fis, 'input', 'food', c(0, 10), 'singleton.fuzzification')

fis = addvar(fis, 'output', 'tip', c(0, 0.25))

# define membership functions
# for food quality
fis = addmf(fis, 'input', varIndex = 1, 'bad', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 1, 'decent',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 1, 'great',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for service rating
  fis = addmf(fis, 'input', varIndex = 2, 'poor', mfType = 'gaussmf', 
            mfParams = c(2, 3))
fis = addmf(fis, 'input', varIndex = 2, 'good',  mfType = 'gaussmf', 
            mfParams = c(2, 5))
fis = addmf(fis, 'input', varIndex = 2, 'excellent',  mfType = 'gaussmf', 
            mfParams = c(2, 7))

# for tip 
fis = addmf(fis, 'output', 1, 'low', 'linearmf', c(0, 0.5, 0.5))
fis = addmf(fis, 'output', 1, 'medium', 'linearmf', c(10, 0.5, 0.5))
fis = addmf(fis, 'output', 1, 'high', 'linearmf', c(20, 0.5, 0.5))

# define fuzzy rules
# if excellent service OR great food, then tip = 20 + 0.5*food + 0.5*service
# if good service, then tip = 10 + 0.5*food + 0.5*service
# if poor service AND bad food, then tip = 0.5*food + 0.5*service
rules = rbind(c(3,3,3,1,2), c(0,2,2,1,1), c(1,1,1,1,1))
fis = addrule(fis, rules)
# fuzzy rules using linguistic variables
showrule(fis)
  1. If (service is great) or (food is excellent) then (tip is high) (1)
  2. If (food is good) then (tip is medium) (1)
  3. If (service is bad) and (food is poor) then (tip is low) (1)
Code 
# evaluate
result = evalfis(c(food_input,service_input), fis)
cat('Tip =', round(result,2),'%')

Tip = 17.81 %

Code 
# surface plot
gensurf_plotly(fis)

Understanding Surface Plots

Surface plots are a way to visualise 3-dimensional data where x- and y-axis represent the inputs service rating and food quality and z-axis represents the tip output. To read the plots, we look at the color scale (to understand the intensity of output), contours and gradients (to see how rapidly the output changes with respect to inputs), peaks and valleys (to see strong rules and interactions between input variables).

The Mamdani Surface plot is relatively smooth but with distinct plateaus, which is typical for Mamdani models. These plateaus suggests that there are areas where the output remains constant over a range of input values, indicative of the max-min inference and centroid defuzzification.

The Larsen Surface plot is smoother compared to Mamdani, which is characteristic of the Larsen Model as it uses product operation in rules’ implication, leading to a more graded and less terraced effect. This suggests a more proportional relationship between the inputs and the output, rather than a more rigid categorization seen in the Mamdani model.

The first-order TSK Surface plot shows a very linear relationship which is characteristic of the first-order TSK model. The linearity in the surface indicates a direct and proportional influence of input changes on the output, with potentially less interpretability but more precision and analytical tractability.

Each model’s behavior is largely determined by how the rules are applied and how the outputs are generated from the inputs. The Mamdani and Larsen models are more interpretative with gradual transitions, while the TSK model is more mathematical and precise.

Subsethood & Interval Data

Up to this point, we’ve approached fuzzification by treating the inputs as fuzzy singletons. Now let’s explore other ways of fuzzifying them & introduce interval inputs to enrich our analysis. For instance, lets define service rating as an interval from 3 to 5 and food quality rating from 5 to 7.

Code 
service_input_mf = function(a, b){
  mean = (a+b)/2
  # ensuring that 99% of the distribution is contained inside the interval
  sigma = (b-a)/6 
  exp(-0.5*(service_domain - mean)^2/sigma^2)
}

food_input_mf = function(a, b){
  mean = (a+b)/2
  sigma = (b-a)/6
  exp(-0.5*(food_domain - mean)^2/sigma^2)
}

service_interval_mf = function(a, b){
  # calculate firing strength based on subset-hood
  mf1 = sum(pmin(service_input_mf(a,b), 
                 service.poor(service_domain)))/sum(service_input_mf(a,b))
  mf2 = sum(pmin(service_input_mf(a,b), 
                 service.good(service_domain)))/sum(service_input_mf(a,b))
  mf3 = sum(pmin(service_input_mf(a,b), 
                 service.ex(service_domain)))/sum(service_input_mf(a,b))
  c(mf1, mf2, mf3)
}

food_interval_mf = function(a, b){
  # calculate firing strength based on subset-hood
  mf1 = sum(pmin(food_input_mf(a,b), 
                 food.bad(food_domain)))/sum(food_input_mf(a,b))
  mf2 = sum(pmin(food_input_mf(a,b), 
                 food.decent(food_domain)))/sum(food_input_mf(a,b))
  mf3 = sum(pmin(food_input_mf(a,b), 
                 food.great(food_domain)))/sum(food_input_mf(a,b))
  c(mf1, mf2, mf3)
}
cat('Membership degrees for service rating between 3 to 5 are:', round(service_interval_mf(3, 5), 4))

Membership degrees for service rating between 3 to 5 are: 0.6774 0.987 8e-04

Code 
cat(' and for food quality between 5 to 7 are:', round(food_interval_mf(3, 5), 4))

and for food quality between 5 to 7 are: 0.6774 0.987 8e-04

Code 
# w1 = max(service.ex(service_input), food.great(food_input))
s.w1 = max(service_interval_mf(3, 5)[3], food_interval_mf(5,7)[3])
s.w2 = service_interval_mf(3, 5)[2]
s.w3 = min(service_interval_mf(3, 5)[1], food_interval_mf(5,7)[1])
cat('Firing strength of Rule 1 =',s.w1,', of Rule 2 =',s.w2,'and of Rule 3 =',s.w3)

Firing strength of Rule 1 = 0.677389 , of Rule 2 = 0.9869633 and of Rule 3 = 0.0007839419

Code 
# shape of output fuzzy set 
final_tip.low = pmin(s.w3, tip.low(tip_domain))
final_tip.med = pmin(s.w2, tip.med(tip_domain))
final_tip.high = pmin(s.w1, tip.high(tip_domain))
final = pmax(final_tip.low, final_tip.med, final_tip.high)

# centroid defuzzification
centroid_value = round(sum(tip_domain*final)/sum(final),3)
plot(tip_domain, final, type='l', col='red', xlab='Tip', 
     ylab='Membership Value', 
     main=paste('Tip Output, Centroid value :',100*centroid_value,'%'),
     lwd=2, ylim=c(0, 1))
abline(v=centroid_value, lty=2, lwd=2, col='red')
legend('topright',c('Centroid'),lty=2,lwd=2,col='red',bty='n')

Conclusion

This article is part of a comprehensive series on Fuzzy Logic and Systems using R, laying the groundwork for understanding advanced concepts and applications in this field.

For further exploration, you can access other articles in this series:

  1. Introduction to Fuzzy Logic in R

  2. Fuzzy Logic in R

  3. Fuzzy Clustering in R

  4. Fuzzy Time Series in R

  5. Fuzzy Intelligent Agents

The work in this article is inspired by the teachings of my Professors at the University of Nottingham. Their guidance and expertise have greatly influenced the content and direction of these articles. For further insights into their research and contributions, you can visit their University of Nottingham profiles:

These articles aim to delve deeper into Fuzzy Logic concepts and their practical implementations, building upon the foundation laid by our esteemed professors. Stay tuned for more valuable insights and applications in this exciting field.