Package 'RoughSets'

Description

This part contains global explanations about the implementation and use of the RoughSets package. The package RoughSets attempts to provide a complete tool to model and analyze information systems based on rough set theory (RST) and fuzzy rough set theory (FRST). From fundamental point of view, this package allows to construct rough sets by defining lower and upper approximations. Furthermore, recent methods for tackling common tasks in data mining, such as data preprocessing (e.g., discretization, feature selection, missing value completion, and instance selection), rule induction, and prediction classes or decision values of new datasets are available as well.

Details

There are two main parts considered in this package which are RST and FRST. RST was introduced by (Pawlak, 1982; Pawlak, 1991) which provides sophisticated mathematical tools to model and analyze information systems that involve uncertainty and imprecision. By employing indiscernibility relation among objects, RST does not require additional parameters to extract information. The detailed explanation about fundamental concepts of RST can be read in Section A.Introduction-RoughSets. Secondly, FRST, an extension of RST, was introduced by (Dubois and Prade, 1990) as a combination between fuzzy sets proposed by (Zadeh, 1965) and RST. This concept allows to analyze continuous attributes without performing discretization on data first. Basic concepts of FRST can be seen in B.Introduction-FuzzyRoughSets.

Based on the above concepts, many methods have been proposed and applied for dealing with several different domains. In order to solve the problems, methods employ the indiscernibility relation and lower and upper approximation concepts. All methods that have been implemented in this package will be explained by grouping based on their domains. The following is a list of domains considered in this package:

• Basic concepts: This part, we can divide into four different tasks which are indiscernibility relation, lower and upper approximations, positive region and discernibility matrix. All of those tasks have been explained briefly in Section A.Introduction-RoughSets and

  B.Introduction-FuzzyRoughSets.

• Discretization: It is used to convert real-valued attributes into nominal/symbolic ones in an information system. In RST point of view, this task attempts to maintain the discernibility between objects.

• Feature selection: It is a process for finding a subset of features which have the same quality as the complete feature set. In other words, its purpose is to select the significant features and eliminate the dispensible ones. It is a useful and necessary process when we are facing datasets containing large numbers of features. From RST and FRST perspective, feature selection refers to searching superreducts and reducts. The detailed information about reducts can be read in A.Introduction-RoughSets and B.Introduction-FuzzyRoughSets.

• Instance selection: This process is aimed to remove noisy, superfluous, or inconsistent instances from training datasets but retain consistent ones. In other words, good accuracy of classification is achieved by removing instances which do not give positive contributions.

• Prediction/classification: This task is used to predict decision values of a new dataset (test data). We consider implementing some methods to perform this task, such as fuzzy-rough nearest neighbor approaches, etc.

• Rule induction: This task refers to generate IF - THEN rules. The rule represents knowledge which is contained in a dataset. One advantage of building rules is that naturally the model is easy to interpret. Then, predicted values over new datasets can be determined by considering the rules.

As we mentioned before, we have embedded many well-known algorithms or techniques for handling the above domains. The algorithms were considered since experimentally it has been proven that they were able to tackle complex tasks. They are implemented as functions that were organized to work with the same data structures. So, users can perform various approaches for a particular task easily and then compare their results. In order to be recognized quickly, generally we have chosen the names of the functions with some conventions. The names contain three parts which are prefix, suffix, and middle that are separated by a point. The following is a description of each part.

• prefix: There are some different prefixes for names of functions expressing a kind of task to be performed. The function names with prefix BC refer to basic concepts which means that the functions are created for implementing the basic concepts of RST and FRST. While prefix D refers to discretization, FS, IS, RI, MV, and C refer to feature selection, instance selection, rule induction, missing value completion, and classifier based on nearest neighbor domains. Furthermore, SF and X mean that functions are used as supporting functions which are not related directly with RST and FRST and auxiliary functions which are called as a parameter.

• suffix: It is located at the end of names. There are two types available: RST and FRST. RST represents rough set theory while FRST shows that the function is applied to fuzzy rough set theory. Additionally, some functions that do not have RST or FRST suffix are used for both theories.

• middle: All other words in the middle of the names are used to express the actual name of a particular method/algorithm or functionality. In this case, it could consist of more than one word separated by points.

For instance, the function BC.IND.relation.RST is used to calculate the indiscernibility relation which is one of the basic concepts of RST. Other functions that have names not based on the above rules are S3 functions e.g., summary and predict which are used to summarize objects and predict new data, respectively.

The following description explains domains and their algorithms implemented in the package:

1. The implementations of RST: This part outlines some considered algorihtms/methods based on RST. The approaches can be classified based on their tasks as follows:

   1. The basic concepts: The following is a list showing tasks and their implementations as functions.

      • Indiscernibility relation: It is a relation determining whether two objects are indiscernible by some attributes. It is implemented in BC.IND.relation.RST.

      • Lower and upper approximations: These approximations show whether objects can be classified with certainty or not. It is implemented in BC.LU.approximation.RST.

      • Positive region: It is used to determine objects that are included in positive region and the degree of dependency. It is implemented in BC.positive.reg.RST.

      • Discernibility matrix: It is used to create a discernibility matrix showing attributes that discern each pair of objects. It is implemented in BC.discernibility.mat.RST.

   2. Discretization: There are a few methods included in the package:

      • D.global.discernibility.heuristic.RST: It implements the global discernibility algorithm which is computing globally semi-optimal cuts using the maximum discernibility heuristic.

      • D.discretize.quantiles.RST: It is a function used for computing cuts of the "quantile-based" discretization into $n$ intervals.

      • D.discretize.equal.intervals.RST: It is a function used for computing cuts of the "equal interval size" discretization into $n$ intervals.

      The output of these functions is a list of cut values which are the values for converting real to nominal values. So, in order to generate a new decision table according to the cut values, we need to call SF.applyDecTable. Additionally, we have implemented D.discretization.RST as a wrapper function collecting all methods considered to perform discretization tasks.

   3. Feature selection: According to its output, it can be classified into the following groups:

      • Feature subset: It refers to a superreduct which is not necessarily minimal. In other words, the methods in this group might generate just a subset of attributes.

        • QuickReduct algorithm: It has been implemented in FS.quickreduct.RST.

        • Superreduct generation: It is based on some criteria: entropy, gini index, discernibility measure, size of positive region.

          It is implemented in FS.greedy.heuristic.superreduct.RST.

        Furthermore, we provide a wrapper function FS.feature.subset.computation in order to give a user interface for many methods of RST and FRST that are included in this group.

      • Reduct: The following are methods that produce a single decision reduct:

        • Reduct generation based on criteria: It is based on different criteria which are entropy, gini index, discernibility measure, size of positive region. It has been implemented in FS.greedy.heuristic.reduct.RST.

        • Permutation reduct: It is based on a permutation schema over all attributes. It has been implemented in FS.permutation.heuristic.reduct.RST.

        Furthermore, we provide a wrapper function FS.reduct.computation in order to give a user interface toward many methods of RST and FRST that are included in this group.

      • All reducts: In order to generate all reducts, we execute FS.all.reducts.computation. However, before doing that, we need to call BC.discernibility.mat.RST for constructing a decision-relative discernibility matrix

      It should be noted that the outputs of the functions are decision reducts. So, for generating a new decision table according to the decision reduct, we need to call SF.applyDecTable.

   4. Rule induction: We provide several functions used to generate rules, as follows:

      • The function RI.indiscernibilityBasedRules.RST: This function requires the output of the feature selection functions.

      • The function RI.CN2Rules.RST: It is a rule induction method based on the CN2 algorithm.

      • The function RI.LEM2Rules.RST: It implements a rule induction method based on the LEM2 algorithm.

      • The function RI.AQRules.RST: It is a rule induction based on the AQ-style algorithm.

      After obtaining the rules, we execute predict.RuleSetRST considering our rules and given newdata/testing data to obtain predicted values/classes.

2. The implementations of FRST: As in the RST part, this part contains several algorithms that can be classified into several groups based on their purpose. The following is a description of all methods that have been implemented in functions:

   1. Basic concepts: The following is a list showing tasks and their implementations:

      • Indiscernibility relations: they are fuzzy relations determining to which degree two objects are similar. This package provides several types of relations which are implemented in a single function called BC.IND.relation.FRST. We consider several types of relations e.g., fuzzy equivalence, tolerance, and $T$-similarity relations. These relations can be chosen by assigning type.relation. Additionally, in this function, we provide several options to calculate aggregation e.g., triangular norm operators (e.g., "lukasiewicz", "min", etc) and user-defined operators.

      • Lower and upper approximations: These approximations show to what extent objects can be classified with certainty or not. This task has been implemented in

        BC.LU.approximation.FRST. There are many approaches available in this package that can be selected by assigning the parameter type.LU. The considered methods are implication/t-norm, $\beta$-precision fuzzy rough sets ($\beta$-PFRS), vaguely quantified rough sets (VQRS), fuzzy variable precision rough sets (FVPRS), ordered weighted average (OWA), soft fuzzy rough sets (SFRS), and robust fuzzy rough sets (RFRS). Furthermore, we provide a facility, which is "custom", where users can create their own approximations by defining functions to calculate lower and upper approximations. Many options to calculate implicator and triangular norm are also available.

      • Positive region: It is used to determine the membership degree of each object to the positive region and the degree of dependency. It is implemented in BC.positive.reg.FRST.

      • Discernibility matrix: It is used to construct the decision-relative discernibility matrix. There are some approaches to construct the matrix, e.g., based on standard approach, Gaussian reduction, alpha reduction, and minimal element in discernibility matrix. They have been implemented in BC.discernibility.mat.FRST.

   2. Feature selection: According to the output of functions, we may divide them into three groups: those that produce a superreduct, a set of reducts, or a single reduct. The following is a description of functions based on their types:

      • Feature subset: It refers to methods which produce a superreduct which is not necessarily a reduct. In other words methods in this group might generate just a subset of attributes. The following is a complete list of methods considered in this package:

        • positive region based algorithms: It refers to positive regions, as a way to evaluate attributes to be selected. They are implemented in FS.quickreduct.FRST. Furthermore, we provide several different measures based on the positive region in this function. All methods included in this part employ the QuickReduct algorithm to obtain selected features. In order to choose a particular algorithm, we need to assign parameter type.method in FS.quickreduct.FRST.

        • boundary region based algorithm: This algorithm is based on the membership degree to the fuzzy boundary region. This algorithm has been implemented in FS.quickreduct.FRST.

        Furthermore, we provide a wrapper function FS.feature.subset.computation in order to give a user interface for many methods of RST and FRST.

      • Reduct: It refers to a method that produces a single decision reduct. We provide one algorithm which is the near-optimal reduction proposed by Zhao et al. It is implemented in FS.nearOpt.fvprs.FRST. Furthermore, we provide a wrapper function FS.reduct.computation in order to provide a user interface toward many methods of RST and FRST.

      • All reducts: In order to get all decision reducts, we execute FS.all.reducts.computation. However, before doing that, we firstly execute the BC.discernibility.mat.FRST function for constructing a decision-relative discernibility matrix.

      The output of the above methods is a class containing a decision reduct/feature subset and other descriptions. For generating a new decision table according to the decision reduct, we provide the function SF.applyDecTable.

   3. Rule induction: It is a task used to generate rules representing knowledge of a decision table. Commonly, this process is called learning phase in machine learning. The following methods are considered to generate rules:

      • RI.hybridFS.FRST: It combines fuzzy-rough rule induction and feature selection.

      • RI.GFRS.FRST: It refers to rule induction based on generalized fuzzy rough sets (GFRS).

      After generating rules, we can use them to predict decision values/classes of new data by executing the S3 function predict.RuleSetFRST.

   4. Instance selection: The following functions select instances to improve accuracy by removing noisy, superfluous or inconsistent ones from training datasets.

      • IS.FRIS.FRST: It refers to the fuzzy rough instance selection (FRIS). It evaluates the degree of membership to the positive region of each instance. If an instance's membership degree is less than the threshold, then the instance can be removed.

      • IS.FRPS.FRST: It refers to the fuzzy-rough prototype selection (FRPS). It employs prototype selection (PS) to improve the accuracy of the $k$-nearest neighbor (kNN) method.

      We provide the function SF.applyDecTable that is used to generate a new decision table according to the output of instance selection functions.

   5. Fuzzy-rough nearest neighbors: This part provides methods based on nearest neighbors for predicting decision values/classes of new datasets. In other words, by supplying a decision table as training data we can predict decision values of new data at the same time. We have considered the following methods:

      • C.FRNN.FRST: It refers to the fuzzy-rough nearest neighbors based on Jensen and Cornelis' technique.

      • C.FRNN.O.FRST: It refers to the fuzzy-rough ownership nearest neighbor algorithm based on Sarkar's method.

      • C.POSNN.FRST: The positive region based fuzzy-rough nearest neighbor algorithm based on Verbiest et al's technique.

Furthermore, we provide an additional feature which is missing value completion. Even though algorithms, included in this feature, are not based on RST and FRST, they will be usefull to do data analysis. The following is a list of functions implemented for handling missing values in the data preprocessing step:

• MV.deletionCases: it refers to the approach deleting instances.

• MV.mostCommonValResConcept: it refers to the approach based on the most common value or mean of an attribute restricted to a concept.

• MV.mostCommonVal: it refers to the approach replacing missing attribute values by the attribute mean or common values.

• MV.globalClosestFit: it refers to the approach based on the global closest fit approach.

• MV.conceptClosestFit: it refers to the approach based on the concept closest fit approach.

Additionally, we provide a wrapper function which is MV.missingValueCompletion in order to give a user interface for the methods.

To get started with the package, the user can have a look at the examples included in the documentation on each function. Additionally, to show general usage of the package briefly, we also provide some examples showing general usage in this section.

If you have problems using the package, find a bug, or have suggestions, please contact the package maintainer by email, instead of writing to the general R lists or to other internet forums and mailing lists.

There are many demos that ship with the package. To get a list of them, type:

demo()

Then, to start a demo, type demo(<demo_name_here>). All the demos are presented as R scripts in the package sources in the "demo" subdirectory.

Currently, there are the following demos available:

• Basic concepts of RST and FRST:

  demo(BasicConcept.RST), demo(BasicConcept.FRST),

  demo(DiscernibilityMatrix.RST), demo(DiscernibilityMatrix.FRST).

• Discretization based on RST:

  demo(D.local.discernibility.matrix.RST), demo(D.max.discernibility.matrix.RST),

  demo(D.global.discernibility.heuristic.RST), demo(D.discretize.quantiles.RST),

  demo(D.discretize.equal.intervals.RST).

• Feature selection based on RST:

  demo(FS.permutation.heuristic.reduct.RST), demo(FS.quickreduct.RST),

  demo(FS.greedy.heuristic.reduct.RST), demo(FS.greedy.heuristic.reduct.RST).

• Feature selection based on FRST:

  demo(FS.QuickReduct.FRST.Ex1), demo(FS.QuickReduct.FRST.Ex2),

  demo(FS.QuickReduct.FRST.Ex3), demo(FS.QuickReduct.FRST.Ex4),

  demo(FS.QuickReduct.FRST.Ex5), demo(FS.nearOpt.fvprs.FRST).

• Instance selection based on FRST:

  demo(IS.FRIS.FRST), demo(IS.FRPS.FRST)

• Classification using the Iris dataset:

  demo(FRNN.O.iris), demo(POSNN.iris), demo(FRNN.iris).

• Rule induction based on RST:

  demo(RI.indiscernibilityBasedRules.RST).

• Rule induction based on FRST:

  demo(RI.classification.FRST), demo(RI.regression.FRST).

• Missing value completion: demo(MV.simpleData).

Some decision tables have been embedded in this package which can be seen in RoughSetData.

Finally, you may visit the package webpage http://sci2s.ugr.es/dicits/software/RoughSets, where we provide a more extensive introduction as well as additional explanations of the procedures.

Author(s)

Lala Septem Riza [email protected],

Andrzej Janusz [email protected],

Chris Cornelis [email protected],

Francisco Herrera [email protected],

Dominik Slezak [email protected],

and Jose Manuel Benitez [email protected]

DiCITS Lab, SCI2S group, CITIC-UGR, DECSAI, University of Granada,

http://dicits.ugr.es, http://sci2s.ugr.es

Institute of Mathematics, University of Warsaw.

References

D. Dubois and H. Prade, "Rough Fuzzy Sets and Fuzzy Rough Sets", International Journal of General Systems, vol. 17, p. 91 - 209 (1990).

L.A. Zadeh, "Fuzzy Sets", Information and Control, vol. 8, p. 338 - 353 (1965).

Z. Pawlak, "Rough Sets", International Journal of Computer and Information System, vol. 11, no. 5, p. 341 - 356 (1982).

Z. Pawlak, "Rough Sets: Theoretical Aspects of Reasoning About Data, System Theory, Knowledge Engineering and Problem Solving", vol. 9, Kluwer Academic Publishers, Dordrecht, Netherlands (1991).

Examples

##############################################################
## A.1 Example: Basic concepts of rough set theory
##############################################################
## Using hiring data set, see RoughSetData
data(RoughSetData)
decision.table <- RoughSetData$hiring.dt

## define considered attributes which are first, second, and
## third attributes
attr.P <- c(1,2,3)

## compute indiscernibility relation
IND <- BC.IND.relation.RST(decision.table, feature.set = attr.P)

## compute lower and upper approximations
roughset <- BC.LU.approximation.RST(decision.table, IND)

## Determine regions
region.RST <- BC.positive.reg.RST(decision.table, roughset)

## The decision-relative discernibility matrix and reduct
disc.mat <- BC.discernibility.mat.RST(decision.table, range.object = NULL)

##############################################################
## A.2 Example: Basic concepts of fuzzy rough set theory
##############################################################
## Using pima7 data set, see RoughSetData
data(RoughSetData)
decision.table <- RoughSetData$pima7.dt

## In this case, let us consider the first and second attributes
conditional.attr <- c(1, 2)

## We are using the "lukasiewicz" t-norm and the "tolerance" relation
## with "eq.1" as fuzzy similarity equation
control.ind <- list(type.aggregation = c("t.tnorm", "lukasiewicz"),
                    type.relation = c("tolerance", "eq.1"))

## Compute fuzzy indiscernibility relation
IND.condAttr <- BC.IND.relation.FRST(decision.table, attributes = conditional.attr,
                            control = control.ind)

## Compute fuzzy lower and upper approximation using type.LU : "implicator.tnorm"
## Define index of decision attribute
decision.attr = c(9)

## Compute fuzzy indiscernibility relation of decision attribute
## We are using "crisp" for type of aggregation and type of relation
control.dec <- list(type.aggregation = c("crisp"), type.relation = "crisp")

IND.decAttr <- BC.IND.relation.FRST(decision.table, attributes = decision.attr,
                            control = control.dec)

## Define control parameter containing type of implicator and t-norm
control <- list(t.implicator = "lukasiewicz", t.tnorm = "lukasiewicz")

## Compute fuzzy lower and upper approximation
FRST.LU <- BC.LU.approximation.FRST(decision.table, IND.condAttr, IND.decAttr,
              type.LU = "implicator.tnorm", control = control)

## Determine fuzzy positive region and its degree of dependency
fuzzy.region <- BC.positive.reg.FRST(decision.table, FRST.LU)

###############################################################
## B Example : Data analysis based on RST and FRST
## In this example, we are using wine dataset for both RST and FRST
###############################################################
## Load the data
## Not run: data(RoughSetData)
dataset <- RoughSetData$wine.dt

## Shuffle the data with set.seed
set.seed(5)
dt.Shuffled <- dataset[sample(nrow(dataset)),]

## Split the data into training and testing
idx <- round(0.8 * nrow(dt.Shuffled))
  wine.tra <-SF.asDecisionTable(dt.Shuffled[1:idx,],
decision.attr = 14, indx.nominal = 14)
  wine.tst <- SF.asDecisionTable(dt.Shuffled[
 (idx+1):nrow(dt.Shuffled), -ncol(dt.Shuffled)])

## DISCRETIZATION
cut.values <- D.discretization.RST(wine.tra,
type.method = "global.discernibility")
d.tra <- SF.applyDecTable(wine.tra, cut.values)
d.tst <- SF.applyDecTable(wine.tst, cut.values)

## FEATURE SELECTION
red.rst <- FS.feature.subset.computation(d.tra,
  method="quickreduct.rst")
fs.tra <- SF.applyDecTable(d.tra, red.rst)

## RULE INDUCTION
rules <- RI.indiscernibilityBasedRules.RST(d.tra,
  red.rst)

## predicting newdata
pred.vals <- predict(rules, d.tst)

#################################################
## Examples: Data analysis using the wine dataset
## 2. Learning and prediction using FRST
#################################################

## FEATURE SELECTION
reduct <- FS.feature.subset.computation(wine.tra,
 method = "quickreduct.frst")

## generate new decision tables
wine.tra.fs <- SF.applyDecTable(wine.tra, reduct)
wine.tst.fs <- SF.applyDecTable(wine.tst, reduct)

## INSTANCE SELECTION
indx <- IS.FRIS.FRST(wine.tra.fs,
 control = list(threshold.tau = 0.2, alpha = 1))

## generate a new decision table
wine.tra.is <- SF.applyDecTable(wine.tra.fs, indx)

## RULE INDUCTION (Rule-based classifiers)
control.ri <- list(
 type.aggregation = c("t.tnorm", "lukasiewicz"),
 type.relation = c("tolerance", "eq.3"),
 t.implicator = "kleene_dienes")

decRules.hybrid <- RI.hybridFS.FRST(wine.tra.is,
  control.ri)

## predicting newdata
predValues.hybrid <- predict(decRules.hybrid,
  wine.tst.fs)

#################################################
## Examples: Data analysis using the wine dataset
## 3. Prediction using fuzzy nearest neighbor classifiers
#################################################

## using FRNN.O
control.frnn.o <- list(m = 2,
  type.membership = "gradual")

predValues.frnn.o <- C.FRNN.O.FRST(wine.tra.is,
  newdata = wine.tst.fs, control = control.frnn.o)

## Using FRNN
control.frnn <- list(type.LU = "implicator.tnorm",k=20,
  type.aggregation = c("t.tnorm", "lukasiewicz"),
  type.relation = c("tolerance", "eq.1"),
  t.implicator = "lukasiewicz")

predValues.frnn <- C.FRNN.FRST(wine.tra.is,
  newdata = wine.tst.fs, control = control.frnn)

## calculating error
real.val <- dt.Shuffled[(idx+1):nrow(dt.Shuffled),
  ncol(dt.Shuffled), drop = FALSE]

err.1 <- 100*sum(pred.vals!=real.val)/nrow(pred.vals)
err.2 <- 100*sum(predValues.hybrid!=real.val)/
  nrow(predValues.hybrid)
err.3 <- 100*sum(predValues.frnn.o!=real.val)/
  nrow(predValues.frnn.o)
err.4 <- 100*sum(predValues.frnn!=real.val)/
  nrow(predValues.frnn)

cat("The percentage error = ", err.1, "\n")
cat("The percentage error = ", err.2, "\n")
cat("The percentage error = ", err.3, "\n")
cat("The percentage error = ", err.4, "\n")
## End(Not run)

Description

Subsetting a set of decision rules.

Usage

## S3 method for class 'RuleSetRST'
x[i, ...]

Arguments

Value

A subset of rules.

Author(s)

Andrzej Janusz

Examples

###########################################################
## Example : Subsetting a set of decision rules
###########################################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

rules <- RI.LEM2Rules.RST(hiring.data)

rules

# taking a subset of rules
rules[1:3]
rules[c(TRUE,FALSE,TRUE,FALSE)]

# replacing a subset of rules
rules2 <- rules
rules2[c(2,4)] <- rules[c(1,3)]
rules2

Description

This part attempts to introduce rough set theory (RST) and its application to data analysis. While the classical RST proposed by Pawlak in 1982 is explained in detail in this section, some recent advancements will be treated in the documentation of the related functions.

Details

In RST, a data set is represented as a table called an information system $\mathcal{A} = (U, A)$, where $U$ is a non-empty set of finite objects known as the universe of discourse (note: it refers to all instances/rows in datasets) and $A$ is a non-empty finite set of attributes, such that $a : U \to V_{a}$ for every $a \in A$. The set $V_{a}$ is the set of values that attribute $a$ may take. Information systems that involve a decision attribute, containing classes for each object, are called decision systems or decision tables. More formally, it is a pair $\mathcal{A} = (U, A \cup \{d\})$, where $d \notin A$ is the decision attribute. The elements of $A$ are called conditional attributes. The information system representing all data in a particular system may contain redundant parts. It could happen because there are the same or indiscernible objects or some superfluous attributes. The indiscernibility relation is a binary relation showing the relation between two objects. This relation is an equivalence relation. Let $\mathcal{A} = (U, A)$ be an information system, then for any $B \subseteq A$ there is an equivalence relation $R_B(x,y)$:

$R_B(x,y)= \{(x,y) \in U^2 | \forall a \in B, a(x) = a(y)\}$

If $(x,y) \in R_B(x,y)$, then $x$ and $y$ are indiscernible by attributes from $B$. The equivalence classes of the $B$-indiscernibility relation are denoted $[x]_{B}$. The indiscernibility relation will be further used to define basic concepts of rough set theory which are lower and upper approximations.

Let $B \subseteq A$ and $X \subseteq U$, $X$ can be approximated using the information contained within $B$ by constructing the $B$-lower and $B$-upper approximations of $X$:

$R_B \downarrow X = \{ x \in U | [x]_{B} \subseteq X \}$

$R_B \uparrow X = \{ x \in U | [x]_{B} \cap X \not= \emptyset \}$

The tuple $\langle R_B \downarrow X, R_B \uparrow X \rangle$ is called a rough set. The objects in $R_B \downarrow X$ mean that they can be with certainty classified as members of $X$ on the basis of knowledge in $B$, while the objects in $R_B \uparrow X$ can be only classified as possible members of $X$ on the basis of knowledge in $B$.

In a decision system, for $X$ we use decision concepts (equivalence classes of decision attribute) $[x]_d$. We can define $B$-lower and $B$-upper approximations as follows.

$R_B \downarrow [x]_d = \{ x \in U | [x]_{B} \subseteq [x]_d \}$

$R_B \uparrow [x]_d = \{ x \in U | [x]_{B} \cap [x]_d \not= \emptyset \}$

The positive, negative and boundary of $B$ regions can be defined as:

$POS_{B} = \bigcup_{x \in U } R_B \downarrow [x]_d$

The boundary region, $BND_{B}$, is the set of objects that can possibly, but not certainly, be classified.

$BND_{B} = \bigcup_{x \in U} R_B \uparrow [x]_d - \bigcup_{x \in U} R_B \downarrow [x]_d$

Furthermore, we can calculate the degree of dependency of the decision on a set of attributes. The decision attribute $d$ depends totally on a set of attributes $B$, denoted $B \Rightarrow d$, if all attribute values from $d$ are uniquely determined by values of attributes from $B$. It can be defined as follows. For $B \subseteq A$, it is said that $d$ depends on $B$ in a degree of dependency $\gamma_{B} = \frac{|POS_{B}|}{|U|}$.

A decision reduct is a set $B \subseteq A$ such that $\gamma_{B} = \gamma_{A}$ and $\gamma_{B'} < \gamma_{B}$ for every $B' \subset B$. One algorithm to determine all reducts is by constructing the decision-relative discernibility matrix. The discernibility matrix $M(\mathcal{A})$ is an $n \times n$ matrix $(c_{ij})$ where

$c_{ij} = \{a \in A: a(x_i) \neq a(x_j) \}$ if $d(x_i) \neq d(x_j)$ and

$c_{ij} = \oslash$ otherwise

The discernibility function $f_{\mathcal{A}}$ for a decision system $\mathcal{A}$ is a boolean function of $m$ boolean variables $\bar{a}_1, \ldots, \bar{a}_m$ corresponding to the attributes $a_1, \ldots, a_m$ respectively, and defined by

$f_{\mathcal{A}}(\bar{a_1}, \ldots, \bar{a_m}) = \wedge \{\vee \bar{c}_{ij}: 1 \le j < i \le n, c_{ij} \neq \oslash \}$

where $\bar{c}_{ij}= \{ \bar{a}: a \in c_{ij}\}$. The decision reducts of $A$ are then the prime implicants of the function $f_{\mathcal{A}}$. The complete explanation of the algorithm can be seen in (Skowron and Rauszer, 1992).

The implementations of the RST concepts can be seen in BC.IND.relation.RST,

BC.LU.approximation.RST, BC.positive.reg.RST, and

BC.discernibility.mat.RST.

References

A. Skowron and C. Rauszer, "The Discernibility Matrices and Functions in Information Systems", in: R. Slowinski (Ed.), Intelligent Decision Support: Handbook of Applications and Advances of Rough Sets Theory, Kluwer Academic Publishers, Dordrecht, Netherland, p. 331 - 362 (1992).

Z. Pawlak, "Rough Sets", International Journal of Computer and Information System, vol. 11, no.5, p. 341 - 356 (1982).

Z. Pawlak, "Rough Sets: Theoretical Aspects of Reasoning about Data, System Theory, Knowledge Engineering and Problem Solving", vol. 9, Kluwer Academic Publishers, Dordrecht, Netherlands (1991).

Description

A function for converting a set of rules into their character representation.

Usage

## S3 method for class 'RuleSetRST'
as.character(x, ...)

Arguments

Value

Converts rules from a set into their character representation.

Author(s)

Andrzej Janusz

Examples

###########################################################
## Example : Converting a set of decision rules
###########################################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

rules <- RI.LEM2Rules.RST(hiring.data)

as.character(rules)

Description

A function for converting a set of rules into a list.

Usage

## S3 method for class 'RuleSetRST'
as.list(x, ...)

Arguments

Value

Converts rules from a set into a list.

Author(s)

Andrzej Janusz

Examples

###########################################################
## Example : Converting a set of decision rules
###########################################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

rules <- RI.LEM2Rules.RST(hiring.data)

as.list(rules)

Description

This part introduces briefly fuzzy rough set theory (FRST) and its application to data analysis. Since recently there are a lot of FRST variants that have been proposed by researchers, in this introduction, we only provide some basic concepts of FRST based on (Radzikowska and Kerre, 2002).

Details

Just like in RST (see A.Introduction-RoughSets), a data set is represented as a table called an information system $\mathcal{A} = (U, A)$, where $U$ is a non-empty set of finite objects as the universe of discourse (note: it refers to all instances/experiments/rows in datasets) and $A$ is a non-empty finite set of attributes, such that $a : U \to V_{a}$ for every $a \in A$. The set $V_{a}$ is the set of values that attribute $a$ may take. Information systems that involve a decision attribute, containing classes or decision values of each objects, are called decision systems (or said as decision tables). More formally, it is a pair $\mathcal{A} = (U, A \cup \{d\})$, where $d \notin A$ is the decision attribute. The elements of $A$ are called conditional attributes. However, different from RST, FRST has several ways to express indiscernibility.

Fuzzy indiscernibility relation (FIR) is used for any fuzzy relation that determines the degree to which two objects are indiscernible. We consider some special cases of FIR.

• fuzzy tolerance relation: this relation has properties which are reflexive and symmetric where

  reflexive: $R(x,x) = 1$

  symmetric: $R(x,y) = R(y,x)$

• similarity relation (also called fuzzy equivalence relation): this relation has properties not only reflexive and symmetric but also transitive defined as

  $min(R(x,y), R(y,z)) \le R(x,z)$

• $\mathcal{T}$-similarity relation (also called fuzzy $\mathcal{T}$-equivalence relation): this relation is a fuzzy tolerance relation that is also $\mathcal{T}$-transitive.

  $\mathcal{T}(R(x,y), R(y,z)) \le R(x,z)$, for a given triangular norm $\mathcal{T}$.

The following equations are the tolerance relations on a quantitative attribute $a$, $R_a$, proposed by (Jensen and Shen, 2009).

• eq.1: $R_a(x,y) = 1 - \frac{|a(x) - a(y)|}{|a_{max} - a_{min}|}$

• eq.2: $R_a(x,y) = exp(-\frac{(a(x) - a(y))^2}{2 \sigma_a^2})$

• eq.3: $R_a(x,y) = max(min(\frac{a(y) - a(x) + \sigma_a}{\sigma_a}, \frac{a(x) - a(y) + \sigma_a}{\sigma_a}), 0)$

where $\sigma_{a}^2$ is the variance of feature $a$ and $a_{min}$ and $a_{max}$ are the minimal and maximal values of data supplied by user. Additionally, other relations have been implemented in BC.IND.relation.FRST

For a qualitative (i.e., nominal) attribute $a$, the classical manner of discerning objects is used, i.e., $R_a(x,y) = 1$ if $a(x) = a(y)$ and $R_a(x,y) = 0$, otherwise. We can then define, for any subset $B$ of $A$, the fuzzy $B$-indiscernibility relation by

$R_B(x,y) = \mathcal{T}(R_a(x,y))$,

where $\mathcal{T}$ is a t-norm operator, for instance minimum, product and Lukasiewicz t-norm. In general, $\mathcal{T}$ can be replaced by any aggregation operator, like e.g., the average.

In the context of FRST, according to (Radzikowska and Kerre, 2002) lower and upper approximation are generalized by means of an implicator $\mathcal{I}$ and a t-norm $\mathcal{T}$. The following are the fuzzy $B$-lower and $B$-upper approximations of a fuzzy set $A$ in $U$

$(R_B \downarrow A)(y) = inf_{x \in U} \mathcal{I}(R_B(x,y), A(x))$

$(R_B \uparrow A)(y) = sup_{x \in U} \mathcal{T}(R_B(x,y), A(x))$

The underlying meaning is that $R_B \downarrow A$ is the set of elements necessarily satisfying the concept (strong membership), while $R_B \uparrow A$ is the set of elements possibly belonging to the concept (weak membership). Many other ways to define the approximations can be found in BC.LU.approximation.FRST. Mainly, these were designed to deal with noise in the data and to make the approximations more robust.

Based on fuzzy $B$-indiscernibility relations, we define the fuzzy $B$-positive region by, for $y \in X$,

$POS_B(y) = (\cup_{x \in U} R_B \downarrow R_dx)(y)$

We can define the degree of dependency of $d$ on $B$, $\gamma_{B}$ by

$\gamma_{B} = \frac{|POS_{B}|}{|U|} = \frac{\sum_{x \in U} POS_{B}(x)}{|U|}$

A decision reduct is a set $B \subseteq A$ such that $\gamma_{B} = \gamma_{A}$ and $\gamma_{B'} = \gamma_{B}$ for every $B' \subset B$.

As we know from rough set concepts (See A.Introduction-RoughSets), we are able to calculate the decision reducts by constructing the decision-relative discernibility matrix. Based on (Tsang et al, 2008), the discernibility matrix can be defined as follows. The discernibility matrix is an $n \times n$ matrix $(c_{ij})$ where for $i,j = 1, \ldots, n$

1) $c_{ij}= \{a \in A : 1 - R_{a}(x_i, x_j) \ge \lambda_i\}$ if $\lambda_j < \lambda_i$.

2) $c_{ij}={\oslash}$, otherwise.

with $\lambda_i = (R_A \downarrow R_{d}x_{i})(x_i)$ and $\lambda_j = (R_A \downarrow R_{d}x_{j})(x_{j})$

Other approaches of discernibility matrix can be read at BC.discernibility.mat.FRST.

The other implementations of the FRST concepts can be seen at BC.IND.relation.FRST,

BC.LU.approximation.FRST, and BC.positive.reg.FRST.

References

A. M. Radzikowska and E. E. Kerre, "A Comparative Study of Fuzzy Rough Sets", Fuzzy Sets and Systems, vol. 126, p. 137 - 156 (2002).

D. Dubois and H. Prade, "Rough Fuzzy Sets and Fuzzy Rough Sets", International Journal of General Systems, vol. 17, p. 91 - 209 (1990).

E. C. C. Tsang, D. G. Chen, D. S. Yeung, X. Z. Wang, and J. W. T. Lee, "Attributes Reduction Using Fuzzy Rough Sets", IEEE Trans. Fuzzy Syst., vol. 16, no. 5, p. 1130 - 1141 (2008).

L. A. Zadeh, "Fuzzy Sets", Information and Control, vol. 8, p. 338 - 353 (1965).

R. Jensen and Q. Shen, "New Approaches to Fuzzy-Rough Feature Selection", IEEE Trans. on Fuzzy Systems, vol. 19, no. 4, p. 824 - 838 (2009).

Z. Pawlak, "Rough Sets", International Journal of Computer and Information Sciences, vol. 11, no. 5, p. 341 - 356 (1982).

Description

This function implements a fundamental part of RST: computation of a boundary region and the degree of dependency. This function can be used as a basic building block for development of other RST-based methods. A more detailed explanation of this notion can be found in A.Introduction-RoughSets.

Usage

BC.boundary.reg.RST(decision.table, roughset)

Arguments

Value

An object of a class "BoundaryRegion" which is a list with the following components:

• boundary.reg: an integer vector containing indices of data instances belonging to the boundary region,

• degree.dependency: a numeric value giving the degree of dependency,

• type.model: a varacter vector identifying the utilized model. In this case, it is "RST" which means the rough set theory.

Author(s)

Dariusz Jankowski, Andrzej Janusz

References

Z. Pawlak, "Rough Sets", International Journal of Computer and Information Sciences, vol. 11, no. 5, p. 341 - 356 (1982).

See Also

BC.IND.relation.RST, BC.LU.approximation.RST, BC.LU.approximation.FRST

Examples

########################################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

## We select a single attribute for computation of indiscernibility classes:
A <- c(2)

## compute the indiscernibility classes:
IND.A <- BC.IND.relation.RST(hiring.data, feature.set = A)

## compute the lower and upper approximation:
roughset <- BC.LU.approximation.RST(hiring.data, IND.A)

## get the boundary region:
pos.boundary = BC.boundary.reg.RST(hiring.data, roughset)
pos.boundary

Description

This is a function that is used to build the decision-relative discernibility matrix based on FRST. It is a matrix whose elements contain discernible attributes among pairs of objects. By means of this matrix, we are able to produce all decision reducts of the given decision system.

Usage

BC.discernibility.mat.FRST(
  decision.table,
  type.discernibility = "standard.red",
  control = list()
)

Arguments

Details

In this function, we provide several approaches in order to generate the decision-relative discernibility matrix. Theoretically, all reducts are found by constructing the matrix that contains elements showing discernible attributes among objects. The discernible attributes are determined by a specific condition which depends on the selected algorithm. A particular approach can be executed by selecting a value of the parameter type.discernibility. The following shows the different values of the parameter type.discernibility corresponding approaches considered in this function.

• "standard.red": It is adopted from (Tsang et al, 2008)'s approach. The concept has been explained briefly in B.Introduction-FuzzyRoughSets. In order to use this algorithm, we assign the control parameter with the following components:

  control = list(type.aggregation, type.relation, type.LU, t.implicator)

  The detailed description of the components can be seen in BC.IND.relation.FRST and

  BC.LU.approximation.FRST. Furthermore, in this case the authors suggest to use the "min" t-norm (i.e., type.aggregation = c("t.tnorm", "min")) and the implicator operator "kleene_dienes" (i.e., t.implicator = "kleene_dienes").

• "alpha.red": It is based on (Zhao et al, 2009)'s approach where all reductions will be found by building an $\alpha$-discernibility matrix. This matrix contains elements which are defined by

  1) if $x_i$ and $x_j$ belong to different decision concept,

  $c_{ij} = \{R : \mathcal{T}(R(x_i, x_j), \lambda) \le \alpha \}$,

  where $\lambda = (R_{\alpha} \downarrow A)(u)$ which is lower approximation of FVPRS (See BC.LU.approximation.FRST).

  2) $c_{ij}={\oslash}$, otherwise.

  To generate the discernibility matrix based on this approach, we use the control parameter with the following components:

  control = list(type.aggregation, type.relation, t.implicator, alpha.precision)

  where the lower approximation $\lambda$ is fixed to type.LU = "fvprs". The detailed description of the components can be seen in BC.IND.relation.FRST and BC.LU.approximation.FRST. Furthermore, in this case the authors suggest to use $\mathcal{T}$-similarity relation

  e.g., type.relation = c("transitive.closure", "eq.3"),

  the "lukasiewicz" t-norm (i.e., type.aggregation = c("t.tnorm", "lukasiewicz")), and alpha.precision from 0 to 0.5.

• "gaussian.red": It is based on (Chen et al, 2011)'s approach. The discernibility matrix contains elements which are defined by:

  1) if $x_i$ and $x_j$ belong to different decision concept,

  $c_{ij}= \{R : R(x_i, x_j) \le \sqrt{1 - \lambda^2(x_i)}\}$,

  where $\lambda = inf_{u \in U}\mathcal{I}_{cos}(R(x_i, u), A(u)) - \epsilon$. To generate fuzzy relation $R$ , we use the fixed parameters as follows:

  t.tnorm = "t.cos" and type.relation = c("transitive.kernel", "gaussian").

  2) $c_{ij}={\oslash}$, otherwise.

  In this case, we need to define control parameter as follows.

  control <- list(epsilon)

  It should be noted that when having nominal values on all attributes then epsilon ($\epsilon$) should be 0.

• "min.element": It is based on (Chen et al, 2012)'s approach where we only consider finding the minimal element of the discernibility matrix by introducing the binary relation $DIS(R)$ the relative discernibility relation of conditional attribute $R$ with respect to decision attribute $d$, which is computed as

  $DIS(R) = \{(x_i, x_j) \in U \times U: 1 - R(x_i, x_j) > \lambda_i, x_j \notin [x_i]_d\}$,

  where $\lambda_i = (Sim(R) \downarrow [x_i]_d)(x_i)$ with $Sim(R)$ a fuzzy equivalence relation. In other words, this algorithm does not need to build the discernibility matrix. To generate the fuzzy relation $R$ and lower approximation $\lambda$, we use the control parameter with the following components:

  control = list(type.aggregation, type.relation, type.LU, t.implicator).

  The detailed description of the components can be seen in BC.IND.relation.FRST and

  BC.LU.approximation.FRST.

Value

A class "DiscernibilityMatrix" containing the following components:

• disc.mat: a matrix showing the decision-relative discernibility matrix $M(\mathcal{A})$ which contains $n \times n$ where $n$ is the number of objects. It will be printed when choosing

  show.discernibilityMatrix = TRUE.

• disc.list: the decision-relative discernibility represented in a list.

• discernibility.type: a string showing the chosen type of discernibility methods.

• type.model: in this case, it is "FRST".

Author(s)

Lala Septem Riza

References

D. Chen, L. Zhang, S. Zhao, Q. Hu, and P. Zhu, "A Novel Algorithm for Finding Reducts with Fuzzy Rough Sets", IEEE Trans. on Fuzzy Systems, vol. 20, no. 2, p. 385 - 389 (2012).

D. G. Chen, Q. H. Hu, and Y. P. Yang, "Parameterized Attribute Reduction with Gaussian Kernel Based Fuzzy Rough Sets", Information Sciences, vol. 181, no. 23, p. 5169 - 5179 (2011).

E. C. C. Tsang, D. G. Chen, D. S. Yeung, X. Z. Wang, and J. W. T. Lee, "Attributes Reduction Using Fuzzy Rough Sets", IEEE Trans. Fuzzy Syst., vol. 16, no. 5, p. 1130 - 1141 (2008).

S. Zhao, E. C. C. Tsang, and D. Chen, "The Model of Fuzzy Variable Precision Rough Sets", IEEE Trans. on Fuzzy Systems, vol. 17, no. 2, p. 451 - 467 (2009).

See Also

BC.discernibility.mat.RST, BC.LU.approximation.RST, and BC.LU.approximation.FRST

Examples

#######################################################################
## Example 1: Constructing the decision-relative discernibility matrix
## In this case, we are using The simple Pima dataset containing 7 rows. 
#######################################################################
data(RoughSetData)
decision.table <- RoughSetData$pima7.dt 

## using "standard.red"
control.1 <- list(type.relation = c("tolerance", "eq.1"), 
                type.aggregation = c("t.tnorm", "min"), 
                t.implicator = "kleene_dienes", type.LU = "implicator.tnorm")
res.1 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "standard.red", 
                                    control = control.1)

## using "gaussian.red"
control.2 <- list(epsilon = 0)
res.2 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "gaussian.red",
                                    control = control.2)

## using "alpha.red"
control.3 <- list(type.relation = c("tolerance", "eq.1"), 
                type.aggregation = c("t.tnorm", "min"),
                t.implicator = "lukasiewicz", alpha.precision = 0.05)
res.3 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "alpha.red", 
                                    control = control.3)

## using "min.element"
control.4 <- list(type.relation = c("tolerance", "eq.1"), 
                type.aggregation = c("t.tnorm", "lukasiewicz"),
                t.implicator = "lukasiewicz", type.LU = "implicator.tnorm")
res.4 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "min.element", 
                                    control = control.4)

#######################################################################
## Example 2: Constructing the decision-relative discernibility matrix
## In this case, we are using the Hiring dataset containing nominal values
#######################################################################
## Not run: data(RoughSetData)
decision.table <- RoughSetData$hiring.dt 

control.1 <- list(type.relation = c("crisp"), 
                type.aggregation = c("crisp"),
                t.implicator = "lukasiewicz", type.LU = "implicator.tnorm")
res.1 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "standard.red", 
                                    control = control.1)

control.2 <- list(epsilon = 0)
res.2 <- BC.discernibility.mat.FRST(decision.table, type.discernibility = "gaussian.red",
                                    control = control.2)
## End(Not run)

Description

This function implements a fundamental part of RST: a decision-relative discernibility matrix. This notion was proposed by (Skowron and Rauszer, 1992) as a middle-step in many RST algorithms for computaion of reducts, discretization and rule induction. A more detailed explanation of this notion can be found in A.Introduction-RoughSets.

Usage

BC.discernibility.mat.RST(
  decision.table,
  range.object = NULL,
  return.matrix = FALSE,
  attach.data = FALSE
)

Arguments

Value

An object of a class DiscernibilityMatrix which has the following components:

• disc.mat: the decision-relative discernibility matrix which for pairs of objects from different decision classes stores names of attributes which can be used to discern between them. Only pairs of objects from different decision classes are considered. For other pairs the disc.mat contains NA values. Moreover, since the classical discernibility matrix is symmetric only the pairs from the lower triangular part are considered.

• disc.list: a list containing unique clauses from the CNF representation of the discernibility function,

• dec.table: an object of a class DecisionTable, which was used to compute the discernibility matrix,

• discernibility.type: a type of discernibility relation used in the computations,

• type.model: a character vector identifying the type of model which was used. In this case, it is "RST" which means the rough set theory.

Author(s)

Lala Septem Riza and Andrzej Janusz

References

A. Skowron and C. Rauszer, "The Discernibility Matrices and Functions in Information Systems", in: R. Słowinski (Ed.), Intelligent Decision Support: Handbook of Applications and Advances of Rough Sets Theory, Kluwer Academic Publishers, Dordrecht, Netherland, p. 331 - 362 (1992).

See Also

BC.IND.relation.RST, BC.LU.approximation.RST, BC.LU.approximation.FRST and BC.discernibility.mat.FRST

Examples

#######################################################################
## Example 1: Constructing the decision-relative discernibility matrix
#######################################################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

## building the decision-relation discernibility matrix
disc.matrix <- BC.discernibility.mat.RST(hiring.data, return.matrix = TRUE)
disc.matrix

Description

This function implements a positive decision-relative discernibility matrix. This notion was proposed by (Sikora et al.) as a middle-step in many RST algorithms for computaion of reducts, discretization and rule induction in a case when the discernibility of objects from the positive class by positive attribute values is more desirable than by the negative ones. The implementation currently works only for binary decision system (all attributes, including the decision must be binary and the positive value is marked by "1").

Usage

BC.discernibility.positive.mat.RST(
  decision.table,
  return.matrix = FALSE,
  attach.data = FALSE
)

Arguments

Value

An object of a class DiscernibilityMatrix which has the following components:

• disc.mat: the decision-relative discernibility matrix which for pairs of objects from different decision classes stores names of attributes which can be used to discern between them. Only pairs of objects from different decision classes are considered. For other pairs the disc.mat contains NA values. Moreover, since the classical discernibility matrix is symmetric only the pairs from the lower triangular part are considered.

• disc.list: a list containing unique clauses from the CNF representation of the discernibility function,

• dec.table: an object of a class DecisionTable, which was used to compute the discernibility matrix,

• discernibility.type: a type of discernibility relation used in the computations,

• type.model: a character vector identifying the type of model which was used. In this case, it is "RST" which means the rough set theory.

Author(s)

Andrzej Janusz and Dominik Slezak

References

TO BE ADDED

See Also

BC.IND.relation.RST, BC.LU.approximation.RST, BC.LU.approximation.FRST and BC.discernibility.mat.FRST

Examples

###############################################################################
## Example 1: Constructing the positive decision-relative discernibility matrix
###############################################################################
data(RoughSetData)
binary.dt <- RoughSetData$binary.dt

## building the decision-relation discernibility matrix
disc.matrix <- BC.discernibility.positive.mat.RST(binary.dt, return.matrix = TRUE)
disc.matrix$disc.mat

## compute all classical reducts
classic.reducts <- FS.all.reducts.computation(BC.discernibility.mat.RST(binary.dt))
head(classic.reducts$decision.reduct)
cat("A total number of reducts found: ", 
    length(classic.reducts$decision.reduct), "\n", sep = "")
classic.reducts$core

## compute all positive reducts
positive.reducts <- FS.all.reducts.computation(disc.matrix)
head(positive.reducts$decision.reduct)
cat("A total number of positive reducts found: ", 
    length(positive.reducts$decision.reduct), "\n", sep = "")
print("The core:")
positive.reducts$core

Description

This is a function used to implement a fundamental concept of FRST which is fuzzy indiscernibility relations. It is used for any fuzzy relations that determine the degree to which two objects are indiscernibility. The detailed description about basic concepts of FRST can be found in B.Introduction-FuzzyRoughSets.

Usage

BC.IND.relation.FRST(decision.table, attributes = NULL, control = list())

Arguments

Details

Briefly, the indiscernibility relation is a relation that shows a degree of similarity among the objects. For example, $R(x_i, x_j) = 0$ means the object $x_i$ is completely different from $x_j$, and otherwise if $R(x_i, x_j) = 1$, while between those values we consider a degree of similarity. To calculate this relation, several methods have been implemented in this function which are approaches based on fuzzy tolerance, equivalence and $T$-equivalence relations. The fuzzy tolerance relations proposed by (Jensen and Shen, 2009) include three equations while (Hu, 2004) proposed five $T_{cos}$-transitive kernel functions as fuzzy $T$-equivalence relations. The simple algorithm of fuzzy equivalence relation is implemented as well. Furthermore, we facilitate users to define their own equation for similarity relation.

To calculate a particular relation, we should pay attention to several components in the parameter control. The main component in the control parameter is type.relation that defines what kind of approach we are going to use. The detailed explanation about the parameters and their equations is as follows:

• "tolerance": It refers to fuzzy tolerance relations proposed by (Jensen and Shen, 2009). In order to represent the "tolerance" relation, we must set type.relation as follows:

  type.relation = c("tolerance", <chosen equation>)

  where the chosen equation called as t.similarity is one of the "eq.1", "eq.2", and "eq.3" equations which have been explained in B.Introduction-FuzzyRoughSets.

• "transitive.kernel": It refers to the relations employing kernel functions (Genton, 2001). In order to represent the relation, we must set the type.relation parameter as follows.

  type.relation = c("transitive.kernel", <chosen equation>, <delta>)

  where the chosen equation is one of five following equations (called t.similarity):

  • "gaussian": It means Gaussian kernel which is $R_G(x,y) = \exp (-\frac{|x - y|^2}{\delta})$

  • "exponential": It means exponential kernel which is $R_E(x,y) = \exp(-\frac{|x - y|}{\delta})$

  • "rational": It means rational quadratic kernel which is $R_R(x,y) = 1 - \frac{|x - y|^2}{|x - y|^2 + \delta}$

  • "circular": It means circular kernel which is if $|x - y| < \delta$, $R_C(x,y) = \frac{2}{\pi}\arccos(\frac{|x - y|}{\delta}) - \frac{2}{\pi}\frac{|x - y|}{\delta}\sqrt{1 - (\frac{|x - y|}{\delta})^2}$

  • "spherical": It means spherical kernel which is if $|x - y| < \delta$, $R_S(x,y) = 1 - \frac{3}{2}\frac{|x - y|}{\delta} + \frac{1}{2}(\frac{|x - y|}{\delta})^3$

  and delta is a specified value. For example: let us assume we are going to use "transitive.kernel" as the fuzzy relation, "gaussian" as its equation and the delta is 0.2. So, we assign the type.relation parameter as follows:

  type.relation = c("transitive.kernel", "gaussian", 0.2)

  If we omit the delta parameter then we are using "gaussian" defined as $R_E(x,y) = \exp(-\frac{|x - y|}{2\sigma^2})$, where $\sigma$ is the variance. Furthermore, when using this relation, usually we set

  type.aggregation = c("t.tnorm", "t.cos").

• "kernel.frst": It refers to $T$-equivalence relation proposed by (Hu, 2004). In order to represent the relation, we must set type.relation parameter as follows.

  type.relation = c("kernel.frst", <chosen equation>, <delta>)

  where the chosen equation is one of the kernel functions, but they have different names corresponding to previous ones: "gaussian.kernel", "exponential.kernel", "rational.kernel", "circular.kernel", and "spherical.kernel". And delta is a specified value. For example: let us assume we are going to use "gaussian.kernel" as its equation and the delta is 0.2. So, we assign the type.relation parameter as follows:

  type.relation = c("kernel.frst", "gaussian.kernel", 0.2)

  In this case, we do not need to define type of aggregation. Furthemore, regarding the distance used in the equations if objects $x$ and $y$ contains mixed values (nominal and continuous) then we use the Gower distance and we use the euclidean distance for continuous only.

• "transitive.closure": It refers to similarity relation (also called fuzzy equivalence relation). We consider a simple algorithm to calculate this relation as follows:

  Input: a fuzzy relation R

  Output: a min-transitive fuzzy relation $R^m$

  Algorithm:

  1. For every x, y: compute

  $R'(x,y) = max(R(x,y), max_{z \in U}min(R(x,z), R(z,y)))$

  2. If $R' \not= R$, then $R \gets R'$ and go to 1, else $R^m \gets R'$

  For interested readers, other algorithms can be seen in (Naessens et al, 2002). Let "eq.1" be the $R$ fuzzy relations, to define it as parameter is

  type.relation = c("transitive.closure", "eq.1"). We can also use other equations that have been explained in "tolerance" and "transitive.kernel".

• "crisp": It uses crisp equality for all attributes and we set the parameter type.relation = "crisp". In this case, we only have $R(x_i, x_j) = 0$ which means the object $x_i$ is completely different from $x_j$, and otherwise if $R(x_i, x_j) = 1$.

• "custom": this value means that we define our own equation for the indiscernibility relation. The equation should be defined in parameter FUN.relation.

  type.relation = c("custom", <FUN.relation>)

  The function FUN.relation should consist of three arguments which are decision.table, x, and y, where x and y represent two objects which we want to compare. It should be noted that the user must ensure that the values of this equation are always between 0 and 1. An example can be seen in Section Examples.

Beside the above type.relation, we provide several options of values for the type.aggregation parameter. The following is a description about it.

• type.aggregation = c("crisp"): It uses crisp equality for all attributes.

• type.aggregation = c("t.tnorm", <t.tnorm operator>): It means we are using "t.tnorm" aggregation which is a triangular norm operator with a specified operator t.tnorm as follows:

  • "min": standard t-norm i.e., $min(x_1, x_2)$.

  • "hamacher": hamacher product i.e., $(x_1 * x_2)/(x_1 + x_2 - x_1 * x_2)$.

  • "yager": yager class i.e., $1 - min(1, ((1 - x_1) + (1 - x_2)))$.

  • "product": product t-norm i.e., $(x_1 * x_2)$.

  • "lukasiewicz": lukasiewicz's t-norm (default) i.e., $max(x_2 + x_1 - 1, 0)$.

  • "t.cos": $T_{cos}$t-norm i.e., $max(x_1 * x_2 - \sqrt{1 - x_1^2}\sqrt{1 - x_2^2, 0})$.

  • FUN.tnorm: It is a user-defined function for "t.tnorm". It has to have two arguments, for example:

    FUN.tnorm <- function(left.side, right.side)

    if ((left.side + right.side) > 1)

    return(min(left.side, right.side))

    else return(0)

  The default value is type.aggregation = c("t.tnorm", "lukasiewicz").

• type.aggregation = c("custom", <FUN.agg>): It is used to define our own function for a type of aggregations. <FUN.agg> is a function having one argument representing data that is produced by fuzzy similarity equation calculation. The data is a list of one or many matrices which depend on the number of considered attributes and has dimension: the number of object $\times$ the number of object. For example:

  FUN.agg <- function(data) return(Reduce("+", data)/length(data))

  which is a function to calculate average along all attributes. Then, we can set type.aggregation as follows:

  type.aggregation = c("general.custom", <FUN.agg>). An example can be seen in Section Examples.

Furthermore, the use of this function has been illustrated in Section Examples. Finally, this function is important since it is a basic function needed by other functions, such as BC.LU.approximation.FRST and BC.positive.reg.FRST for calculating lower and upper approximation and determining positive regions.

Value

A class "IndiscernibilityRelation" which contains

• IND.relation: a matrix representing the indiscernibility relation over all objects.

• type.relation: a vector representing the type of relation.

• type.aggregation: a vector representing the type of aggregation operator.

• type.model: a string showing the type of model which is used. In this case it is "FRST" which means fuzzy rough set theory.

Author(s)

Lala Septem Riza

References

M. Genton, "Classes of Kernels for Machine Learning: a Statistics Perspective", J. Machine Learning Research, vol. 2, p. 299 - 312 (2001).

H. Naessens, H. De Meyer, and B. De Baets, "Algorithms for the Computation of T-Transitive Closures", IEEE Trans. on Fuzzy Systems, vol. 10, No. 4, p. 541 - 551 (2002).

R. Jensen and Q. Shen, "New Approaches to Fuzzy-Rough Feature Selection", IEEE Trans. on Fuzzy Systems, vol. 19, no. 4, p. 824 - 838 (2009).

Q. Hu, D. Yu, W. Pedrycz, and D. Chen, "Kernelized Fuzzy Rough Sets and Their Applications", IEEE Trans. Knowledge Data Eng., vol. 23, no. 11, p. 1649 - 1471 (2011).

See Also

BC.LU.approximation.FRST, BC.IND.relation.RST, BC.LU.approximation.RST,

and BC.positive.reg.FRST

Examples

###########################################################
## Example 1: Dataset containing nominal values for 
## all attributes.
###########################################################
## Decision table is represented as data frame
dt.ex1 <- data.frame(c(1,0,2,1,1,2,2,0), c(0, 1,0, 1,0,2,1,1), 
                        c(2,1,0,0,2,0,1,1), c(2,1,1,2,0,1,1,0), c(0,2,1,2,1,1,2,1))
colnames(dt.ex1) <- c("aa", "bb", "cc", "dd", "ee")
decision.table <- SF.asDecisionTable(dataset = dt.ex1, decision.attr = 5, 
      indx.nominal = c(1:5))

## In this case, we only consider the second and third attributes.
attributes <- c(2, 3)

## calculate fuzzy indiscernibility relation ##
## in this case, we are using "crisp" as a type of relation and type of aggregation
control.ind <- list(type.relation = c("crisp"), type.aggregation = c("crisp"))
IND <- BC.IND.relation.FRST(decision.table, attributes = attributes, control = control.ind)

###########################################################
## Example 2: Dataset containing real-valued attributes
###########################################################
dt.ex2 <- 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.ex2) <- c("a", "b", "c", "d")
decision.table <- SF.asDecisionTable(dataset = dt.ex2, decision.attr = 4)

## in this case, we only consider the first and second attributes
attributes <- c(1, 2)

## Calculate fuzzy indiscernibility relation 
## in this case, we choose "tolerance" relation and "eq.1" as similarity equation
## and "lukasiewicz" as t-norm of type of aggregation
control.1 <- list(type.aggregation = c("t.tnorm", "lukasiewicz"), 
                    type.relation = c("tolerance", "eq.1"))
IND.1 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.1) 

## Calculate fuzzy indiscernibility relation: transitive.kernel
control.2 <- list(type.aggregation = c("t.tnorm", "t.cos"), 
                    type.relation = c("transitive.kernel", "gaussian", 0.2))
IND.2 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.2) 

## Calculate fuzzy indiscernibility relation: kernel.frst 
control.3 <- list(type.relation = c("kernel.frst", "gaussian.kernel", 0.2))
IND.3 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.3) 

## calculate fuzzy transitive closure
control.4 <- list(type.aggregation = c("t.tnorm", "lukasiewicz"), 
                    type.relation = c("transitive.closure", "eq.1"))
IND.4 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.4) 

## Calculate fuzzy indiscernibility relation: using user-defined relation
## The customized function should have three arguments which are : decision.table 
## and object x, and y.
## This following example shows that we have an equation for similarity equation: 
## 1 - abs(x - y) where x and y are two objects that will be compared.
## In this case, we do not consider decision.table in calculation.
FUN.relation <- function(decision.table, x, y) {
           return(1 - (abs(x - y)))
       }
control.5 <- list(type.aggregation = c("t.tnorm", "lukasiewicz"), 
                     type.relation = c("custom", FUN.relation))
IND.5 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.5) 

## In this case, we calculate aggregation as average of all objects 
## by executing the Reduce function
FUN.average <- function(data){
  	 return(Reduce("+", data)/length(data))
}
control.6 <- list(type.aggregation = c("custom", FUN.average), 
                     type.relation = c("tolerance", "eq.1"))
IND.6 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.6)

## using user-defined tnorms 
FUN.tnorm <- function(left.side, right.side) {
               if ((left.side + right.side) > 1)
                   return(min(left.side, right.side))
               else return(0)}
control.7 <- list(type.aggregation = c("t.tnorm", FUN.tnorm), 
                    type.relation = c("tolerance", "eq.1"))
IND.7 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.7) 

## Calculate fuzzy indiscernibility relation: kernel fuzzy rough set 
control.8 <- list(type.relation = c("kernel.frst", "gaussian.kernel", 0.2))
IND.8 <- BC.IND.relation.FRST(decision.table, attributes = attributes, 
                              control = control.8) 						   
##################################################################
## Example 3: Dataset containing continuous and nominal attributes
## Note. we only consider type.relation = c("tolerance", "eq.1")
## but other approaches have the same way.
##################################################################
data(RoughSetData)
decision.table <- RoughSetData$housing7.dt 

## in this case, we only consider the attribute: 1, 2, 3, 4 
attributes <- c(1,2,3,4)

## Calculate fuzzy indiscernibility relation
control.9 <- list(type.aggregation = c("t.tnorm", "lukasiewicz"),
                    type.relation = c("tolerance", "eq.1"))
IND.9 <- BC.IND.relation.FRST(decision.table, attributes = attributes, control = control.9)

Description

This function implements a fundamental part of RST: the indiscernibility relation. This binary relation indicates whether it is possible to discriminate any given pair of objects from an information system.

This function can be used as a basic building block for development of other RST-based methods. A more detailed explanation of the notion of indiscernibility relation can be found in A.Introduction-RoughSets.

Usage

BC.IND.relation.RST(decision.table, feature.set = NULL)

Arguments

Value

An object of a class "IndiscernibilityRelation" which is a list with the following components:

• IND.relation: a list of indiscernibility classes in the data. Each class is represented by indices of data instances which belong to that class

• type.relation: a character vector representing a type of relation used in computations. Currently, only "equivalence" is provided.

• type.model: a character vector identifying the type of model which is used. In this case, it is "RST" which means the rough set theory.

Author(s)

Andrzej Janusz

References

Z. Pawlak, "Rough Sets", International Journal of Computer and Information Sciences, vol. 11, no. 5, p. 341 - 356 (1982).

See Also

BC.LU.approximation.RST, FS.reduct.computation, FS.feature.subset.computation

Examples

#############################################
data(RoughSetData)
hiring.data <- RoughSetData$hiring.dt

## In this case, we only consider the second and third attribute:
A <- c(2,3)
## We can also compute a decision reduct:
B <- FS.reduct.computation(hiring.data)

## Compute the indiscernibility classes:
IND.A <- BC.IND.relation.RST(hiring.data, feature.set = A)
IND.A

IND.B <- BC.IND.relation.RST(hiring.data, feature.set = B)
IND.B

Description

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 t-norm functions proposed by (Radzikowska and Kerre, 2002).

Usage

BC.LU.approximation.FRST(
  decision.table,
  IND.condAttr,
  IND.decAttr,
  type.LU = "implicator.tnorm",
  control = list()
)

Arguments

Details

Fuzzy lower and upper approximations as explained in B.Introduction-FuzzyRoughSets 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/t-norm based model proposed by (Radzikowska and Kerre, 2002). The explanation has been given in B.Introduction-FuzzyRoughSets. 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.Introduction-FuzzyRoughSets) 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 OWA-based 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 \le n$, this model is defined by

    $W_l = <w_i^l> = w_{n+1-i}^l = \frac{2^{m-i}}{2^{m}-1}$ for $i = 1,\ldots, m$ and $0$ for $i = m + 1, \ldots, n$

    $W_u = <w_i^u> = w_i^u = \frac{2^{m - i}}{2^{m} - 1}$ for $i = 1, \ldots, m$ and $0$ for $i = m + 1, \ldots, 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_{\alpha} \downarrow A)(y) = inf_{A(y) \le \alpha} \mathcal{I}(R(x,y), \alpha) \wedge inf_{A(y) > \alpha} \mathcal{I}(R(x,y), A(y))$

  $(R_{\alpha} \uparrow A)(y) = sup_{A(y) \ge N(\alpha)} \mathcal{T}(R(x,y), N(\alpha)) \vee sup_{A(y) < N(\alpha)} \mathcal{T}(R(x,y), A(y))$

  where $\alpha$, $\mathcal{I}$ and $\mathcal{T}$ are the variable precision parameter, implicator and t-norm 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 k-trimmed minimum, k-mean minimum, k-median minimum, k-trimmed maximum, k-mean maximum, and k-median 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 - (k-1)/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 $\beta$-precision fuzzy rough sets ($\beta$-PFRS) proposed by (Salido and Murakami, 2003). This algorithm uses $\beta$-precision quasi-$\mathcal{T}$-norm and $\beta$-precision quasi-$\mathcal{T}$-conorm. The following are the $\beta$-precision versions of fuzzy lower and upper approximations of a fuzzy set $A$ in $U$

  $(R_B \downarrow A)(y) = T_{\beta_{x \in U}} \mathcal{I}(R_B(x,y), A(x))$

  $(R_B \uparrow A)(y) = S_{\beta_{x \in U}} \mathcal{T}(R_B(x,y), A(x))$

  where $T_{\beta}$ and $S_{\beta}$ are $\beta$-precision quasi-$\mathcal{T}$-norm and $\beta$-precision quasi-$\mathcal{T}$-conorm. Given a t-norm $\mathcal{T}$, a t-conorm $S$, $\beta \in [0,1]$ and $n \in N \setminus \{0, 1\}$, the corresponding $\beta$-precision quasi-t-norm $T_{\beta}$ and $\beta$-precision-$\mathcal{T}$-conorm $S_{\beta}$ 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_{\beta}(x) = \mathcal{T}(y_1,...,y_{n-m})$,

  $S_{\beta}(x) = \mathcal{T}(z_1,...,z_{n-p})$,

  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 \le (1-\beta)\sum_{j=1}^{n}x_j)$,

  $p = max(i \in \{0,...,n\}|i \le (1-\beta)\sum_{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 user-defined lower and upper approximations. An example can be seen in Section Examples.