Description Usage Arguments Details Value Author(s) References See Also Examples
View source: R/BasicFuzzyRoughSets.R
This is a function implementing a fundamental concept of FRST: fuzzy lower and upper approximations. Many options have been considered for determining lower and upper approximations, such as techniques based on implicator and tnorm functions proposed by (Radzikowska and Kerre, 2002).
1 2  BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "implicator.tnorm", control = list())

decision.table 
a 
IND.condAttr 
a 
IND.decAttr 
a 
type.LU 
a string representing a chosen method to calculate lower and upper approximations. See the explanation in Section 
control 
a list of other parameters. In order to understand how to express the

Fuzzy lower and upper approximations as explained in B.IntroductionFuzzyRoughSets
are used
to define to what extent the set of elements can be classified into a certain class strongly or weakly. We can perform various methods by choosing the parameter type.LU
.
The following is a list of all type.LU
values:
"implicator.tnorm"
: It means implicator/tnorm based model proposed by (Radzikowska and Kerre, 2002).
The explanation has been given in B.IntroductionFuzzyRoughSets
.
Other parameters in control
related with this approach are t.tnorm
and t.implicator
.
In other words, when we are using "implicator.tnorm"
as type.LU
,
we should consider parameters t.tnorm
and t.implicator
.
The possible values of these parameters can be seen in the description of parameters.
"vqrs"
: It means vaguely quantified rough sets proposed by
(Cornelis et al, 2007). Basically, this concept proposed to replace fuzzy lower and upper approximations
based on Radzikowska and Kerre's technique (see B.IntroductionFuzzyRoughSets
)
with the following equations, respectively.
(R_{Q_u} \downarrow A)(y) = Q_u(\frac{R_y \cap A}{R_y})
(R_{Q_l} \uparrow A)(y) = Q_l(\frac{R_y \cap A}{R_y})
where the quantifier Q_u and Q_l represent the terms most
and some
.
"owa"
: It refers to ordered weighted average based fuzzy rough sets.
This method was introduced by (Cornelis et al, 2010) and computes the approximations
by an aggregation process proposed by (Yager, 1988). The OWAbased lower and upper approximations of
A under R with weight vectors W_l and W_u are defined as
(R \downarrow W_l A)(y) = OW A_{W_l}\langle I(R(x, y), A(y))\rangle
(R \uparrow W_u A)(y) = OW A_{W_u}\langle T(R(x, y), A(y))\rangle
We provide two ways to define the weight vectors as follows:
m.owa
: Let m.owa be m and m ≤ n, this model is defined by
W_l = <w_i^l> = w_{n+1i}^l = \frac{2^{mi}}{2^{m}1} for i = 1,…, m and 0 for i = m + 1, …, n
W_u = <w_i^u> = w_i^u = \frac{2^{m  i}}{2^{m}  1} for i = 1, …, m and 0 for i = m + 1, …, n
where n is the number of data.
custom
: In this case, users define the own weight vector.
It should be noted that the weight vectors <w_i> should satisfy w_i \in [0, 1] and
their summation is 1.
"fvprs"
: It refers to fuzzy variable precision rough sets (FVPRS) introduced by
(Zhao et al, 2009). It is a combination between variable precision rough sets (VPRS)
and FRST. This function implements the construction of lower and upper approximations as follows.
(R_{α} \downarrow A)(y) = inf_{A(y) ≤ α} \mathcal{I}(R(x,y), α) \wedge inf_{A(y) > α} \mathcal{I}(R(x,y), A(y))
(R_{α} \uparrow A)(y) = sup_{A(y) ≥ N(α)} \mathcal{T}(R(x,y), N(α)) \vee sup_{A(y) < N(α)} \mathcal{T}(R(x,y), A(y))
where α, \mathcal{I} and \mathcal{T} are the variable precision parameter, implicator and tnorm operators, respectively.
"rfrs"
: It refers to robust fuzzy rough sets (RFRS) proposed by (Hu et al, 2012).
This package provides six types of RFRS which are ktrimmed minimum, kmean minimum, kmedian minimum,
ktrimmed maximum, kmean maximum, and kmedian maximum.
Basically, these methods are a special case of ordered weighted average (OWA) where they consider
the weight vectors as follows.
"k.trimmed.min"
: w_i^l = 1 for i = n  k and w_i^l = 0 otherwise.
"k.mean.min"
: w_i^l = 1/k for i > n  k and w_i^l = 0 otherwise.
"k.median.min"
: w_i^l = 1 if k odd, i = n  (k1)/2 and w_i^l = 1/2 if k even, i = n  k/2
and w_i^l = 0 otherwise.
"k.trimmed.max"
: w_i^u = 1 for i = k + 1 and w_i^u = 0 otherwise.
"k.mean.max"
: w_i^u = 1/k for i < k + 1 and w_i^u = 0 otherwise.
"k.median.max"
: w_i^u = 1 if k odd, i = (k + 1)/2 and w_i^u = 1/2 if k even, i = k/2 + 1
or w_i^u = 0 otherwise.
"beta.pfrs"
: It refers to βprecision fuzzy rough sets (βPFRS) proposed by
(Salido and Murakami, 2003). This algorithm uses βprecision quasi\mathcal{T}norm and
βprecision quasi\mathcal{T}conorm. The following are the βprecision versions of fuzzy lower and upper approximations of a fuzzy set A in U
(R_B \downarrow A)(y) = T_{β_{x \in U}} \mathcal{I}(R_B(x,y), A(x))
(R_B \uparrow A)(y) = S_{β_{x \in U}} \mathcal{T}(R_B(x,y), A(x))
where T_{β} and S_{β} are βprecision quasi\mathcal{T}norm and βprecision quasi\mathcal{T}conorm. Given a tnorm \mathcal{T}, a tconorm S, β \in [0,1] and n \in N \setminus \{0, 1\}, the corresponding βprecision quasitnorm T_{β} and βprecision\mathcal{T}conorm S_{β} of order n are [0,1]^n \to [0,1] mappings such that for all x = (x_1,...,x_n) in [0,1]^n,
T_{β}(x) = \mathcal{T}(y_1,...,y_{nm}),
S_{β}(x) = \mathcal{T}(z_1,...,z_{np}),
where y_i is the i^{th} greatest element of x and z_i is the i^{th} smallest element of x, and
m = max(i \in \{0,...,n\}i ≤ (1β)∑_{j=1}^{n}x_j),
p = max(i \in \{0,...,n\}i ≤ (1β)∑_{j=1}^{n}(a  x_j)).
In this package we use min
and max
for \mathcal{T}norm and \mathcal{T}conorm, respectively.
"custom"
: It refers to userdefined lower and upper approximations. An example can be seen in Section Examples
.
The parameter type.LU
, which is explained above, is related with parameter control
.
In other words, when choosing a specific value of type.LU
, we should take into account to set values of related components in control
.
The components that are considered depend on what kind of lower and upper approximations are used.
So, we do not need to assign all components for a particular approach but only components related with type.LU
.
The following is a list showing the components of each approaches.
type.LU = "implicator.tnorm"
:
control < list(t.implicator, t.tnorm)
type.LU = "vqrs"
:
control < list(q.some, q.most, type.aggregation, t.tnorm)
type.LU = "owa"
:
control < list(t.implicator, t.tnorm, m.owa)
or
control < list(t.implicator, t.tnorm, w.owa)
type.LU = "fvprs"
:
control < list(t.implicator, t.tnorm, alpha)
type.LU = "beta.pfrs"
:
control < list(t.implicator, t.tnorm, beta.quasi)
type.LU = "rfrs"
:
control < list(t.implicator, t.tnorm, type.rfrs, k.rfrs)
type.LU = "custom"
:
control < list(t.implicator, t.tnorm, FUN.lower, FUN.upper)
The description of the components can be seen in the control
parameter.
In Section Examples
, we provide two examples showing different cases which are
when we have to handle a nominal decision attribute and a continuous one.
It should be noted that this function depends on BC.IND.relation.FRST
which is a function used to calculate the fuzzy indiscernibility relation as input data.
So, it is obvious that before performing this function, users must execute BC.IND.relation.FRST
first.
A class "LowerUpperApproximation"
representing fuzzy rough set (fuzzy lower and upper approximations). It contains the following components:
fuzzy.lower
: a list showing the lower approximation classified
based on decision concepts for each index of objects. The value refers to
the degree of objects included in the lower approximation.
In case the decision attribute is continuous, the result is in a data frame
with dimension (number of objects x number of objects) and the value on position (i,j)
shows the membership of object i to the lower approximation of the similarity class of object j.
fuzzy.upper
: a list showing the upper approximation classified
based on decision concepts for each index of objects. The value refers to
the degree of objects included in the upper approximation.
In case the decision attribute is continuous values, the result is in data frame
with dimension (number of objects x number of objects) and the value on position (i,j)
shows the membership of object i to the upper approximation of the similarity class of object j.
type.LU
: a string representing the type of lower and upper approximation approaches.
type.model
: a string showing the type of model which is used. In this case, it is "FRST"
which means fuzzy rough set theory.
Lala Septem Riza
A. M. Radzikowska and E. E. Kerre, "A Comparative Study of Fuzzy Rough Sets", Fuzzy Sets and Systems, vol. 126, p. 137  156 (2002).
C. Cornelis, M. De Cock, and A. Radzikowska, "Vaguely Quantified Rough Sets", Proceedings of 11th International Conference on Rough Sets, Fuzzy Sets, Data Mining and Granular Computing (RSFDGrC2007), Lecture Notes in Artificial Intelligence 4482, p. 87  94 (2007).
C. Cornelis, N. Verbiest, and R. Jensen, "Ordered Weighted Average Based Fuzzy Rough Sets", Proceedings of the 5th International Conference on Rough Sets and Knowledge Technology (RSKT 2010), p. 78  85 (2010).
J. M. F. Salido and S. Murakami, "Rough Set Analysis of a General Type of Fuzzy Data Using Transitive Aggregations of Fuzzy Similarity Relations", Fuzzy Sets Syst., vol. 139, p. 635  660 (2003).
Q. Hu, L. Zhang, S. An, D. Zhang, and D. Yu, "On Robust Fuzzy Rough Set Models", IEEE Trans. on Fuzzy Systems, vol. 20, no. 4, p. 636  651 (2012).
R. Jensen and Q. Shen, "New Approaches to FuzzyRough Feature Selection", IEEE Trans. on Fuzzy Systems, vol. 19, no. 4, p. 824  838 (2009).
R. R. Yager, "On Ordered Weighted Averaging Aggregation Operators in Multicriteria Decision Making", IEEE Transactions on Systems, Man, and Cybernetics, vol. 18, p. 183  190 (1988).
S. Y. Zhao, E. C. C. Tsang, and D. G. Chen, "The Model of Fuzzy Variable Precision Rough Sets", IEEE Trans. Fuzzy Systems, vol. 17, no. 2, p. 451  467 (2009).
BC.IND.relation.RST
, BC.LU.approximation.RST
,
and BC.positive.reg.FRST
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124  ###########################################################
## 1. Example: Decision table contains nominal decision attribute
## we are using the same dataset and indiscernibility
## relation along this example.
###########################################################
dt.ex1 < data.frame(c(0.4, 0.4, 0.3, 0.3, 0.2, 0.2),
c(0.3, 0.2, 0.4, 0.3, 0.3, 0),
c(0.5, 0.1, 0.3, 0, 0, 0),
c("no", "yes", "no", "yes", "yes", "no"))
colnames(dt.ex1) < c("a", "b", "c", "d")
decision.table < SF.asDecisionTable(dataset = dt.ex1, decision.attr = 4)
## let us consider the first and second attributes
## only as conditional attributes
condAttr < c(1, 2)
## let us consider the fourth attribute as decision attribute
decAttr < c(4)
#### calculate fuzzy indiscernibility relation ####
control.ind < list(type.aggregation = c("t.tnorm", "lukasiewicz"),
type.relation = c("tolerance", "eq.1"))
control.dec < list(type.aggregation = c("crisp"), type.relation = "crisp")
## fuzzy indiscernibility relation of conditional attribute
IND.condAttr < BC.IND.relation.FRST(decision.table, attributes = condAttr,
control = control.ind)
## fuzzy indiscernibility relation of decision attribute
IND.decAttr < BC.IND.relation.FRST(decision.table, attributes = decAttr,
control = control.dec)
#### Calculate fuzzy lower and upper approximation using type.LU : "implicator.tnorm" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz")
FRST.LU < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "implicator.tnorm", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "vqrs" ####
control < list(q.some = c(0.1, 0.6), q.most = c(0.2, 1), t.tnorm = "lukasiewicz")
FRST.VQRS < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "vqrs", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "owa" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz", m.owa = 3)
FRST.OWA.1 < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "owa", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU :
#### "owa" with customized function
#### In this case, we are using the same weight vector as
#### previous one with m.owa = 3
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz",
w.owa = c(0, 0, 0, 0.14, 0.29, 0.57))
FRST.OWA.2 < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "owa", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "fvprs" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz", alpha = 0.05)
FRST.fvprs < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "fvprs", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "rfrs" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz",
type.rfrs = "k.trimmed.min", k.rfrs = 0)
FRST.rfrs < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "rfrs", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "beta.pfrs" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz", beta.quasi = 0.05)
FRST.beta.pfrs < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "beta.pfrs", control = control)
#### Calculate fuzzy lower and upper approximation using type.LU : "custom" ####
## In this case, we calculate approximations randomly.
f.lower < function(x){
return(min(runif(1, min = 0, max = 1) * x))
}
f.upper < function(x){
return(max(runif(1, min = 0, max = 1) * x))
}
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz", FUN.lower = f.lower,
FUN.upper = f.upper)
FRST.custom < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "custom", control = control)
#### In this case, we use custom function for triangular norm and implicator operator
## For example, let us define our implicator and tnorm operator as follows.
imp.lower < function(antecedent, consequent){
return(max(1  antecedent, consequent))
}
tnorm.upper < function(x, y){
return (x * y)
}
control.custom < list(t.implicator = imp.lower, t.tnorm = tnorm.upper)
FRST.LU.custom < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "implicator.tnorm", control = control.custom)
###########################################################
## 2. Example: Decision table contains a continuous decision attribute.
## It should be noted that in this example, we are using
## the same dataset and indiscernibility relation.
## We only show one method but for other approaches
## the procedure is analogous to the previous example
###########################################################
## In this case, we are using housing dataset containing 7 objects
data(RoughSetData)
decision.table < RoughSetData$housing7.dt
## let us consider the first and second conditional attributes only,
## and the decision attribute at 14.
cond.attributes < c(1, 2)
dec.attributes < c(14)
control.ind < list(type.aggregation = c("t.tnorm", "lukasiewicz"),
type.relation = c("tolerance", "eq.1"))
IND.condAttr < BC.IND.relation.FRST(decision.table, attributes = cond.attributes,
control = control.ind)
IND.decAttr < BC.IND.relation.FRST(decision.table, attributes = dec.attributes,
control = control.ind)
#### Calculate fuzzy lower and upper approximation using type.LU : "implicator.tnorm" ####
control < list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz")
FRST.LU < BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
type.LU = "implicator.tnorm", control = control)

Loading required package: Rcpp
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.