Define the CP

Description

In general, CP corresponds with specific parts of the analyzed phenomenon at a certain degree of granularity. To create a computational model of the analyzed phenomenon, the designer analyzes the everyday use of natural language about the monitored phenomenon with the aim of identifying different parts (units of information or granules) based on his/her subjective perceptions. According with Zadeh (1996), a granule is a clump of elements which are drawn together by indistinguishability, similarity, proximity or functionality. The GLMP handles granules by using CPs.

Usage

cp(name, a, b = NULL, r = NULL)

Arguments

Value

The generated CP = list(a, w, r, b, wb) where w and wb are vectors with the validity degrees (wi and wbi in [0,1]) of the linguistic expressions in a and b respectively. These vectors are initialized with 0.

Examples

myCP <-cp("myCP", c("bad", "good", "very good"))
myCP <- cp("myCP", c("bad", "good", "very good"), c("low", "moderate", "high"))
myCP <- cp("myCP", c("bad", "good", "very good"), r=c(1,0.8,0.9))
myCP <- cp("myCP", c("bad", "good", "very good"), c("low", "moderate", "high"), c(1,0.8,0.9))

Define the data structure

Description

Data structure provides the GLMP input. It constructor receives the input values and the method that defines the data structure, i.e., the set of preprocesing techniques.

Usage

data_structure(input, method)

Arguments

Value

The generated data_structure = list(input, method)

Examples

values <- matrix(c(34,11,9,32), ncol=2)

my_method <- function (input){
 output <- c(mean(input[,1]), mean(input[,2]))
 output
}
 my_data_structure <- data_structure(values,my_method)

Define generic calculation of fuzzy membership degrees

Description

It is a generic function in charge of computing fuzzy membership degrees. Namely, it identifies the specific membership function to consider and run the related method for computing the membership degree for a given input value. It takes as input an object (trapezoid_mf, triangle_mf and fuzzy_partitions) and the related input values

Usage

degree_mf(shape, input)

Arguments

Value

the membership degree for a given input values.

Examples

w <- degree_mf(triangle_mf(450,450,550),450)

w <- degree_mf(fuzzy_partitions(triangle_mf(450,450,550),
                                triangle_mf(450,550,600),
                                trapezoid_mf(550,600,800,1000),
                                triangle_mf(800,1000,1300),
                                trapezoid_mf(1000,1300,1500,1500)),450)

Define the fuzzy parititions

Description

It is a constructor of fuzzy partitions, it defines a set of membership functions. It takes as input a set of trapezoid_mf or triangle_mf or objects in the shape_mf class.

Usage

fuzzy_partitions(...)

Arguments

Value

the (fuzzy_partitions <- list(...)

Examples

fuzzy_partitions(triangle_mf(450,450,550),
                 triangle_mf(450,550,600),
                 trapezoid_mf(550,600,800, 1000),
                 triangle_mf(800,1000,1300),
                 trapezoid_mf(1000,1300,1500,1500))

Define the fuzzy rule

Description

We define a fuzzy rule using the numbers 1 and 0. rule(0,0,1,0,0, 0,0,1,0,0, 0,0,1,0,0, 0,0,1)

This is an example of fuzzy_rule(0,0,1,0,0,1). In the fuzzy rule the number 1 means that the linguistic expression is included and the number 0 means that the linguistic expression is not included.

Usage

fuzzy_rule(...)

Arguments

Value

the fuzzy_rule <- c(...)

Examples

# For example, the rule "IF CPtemp IS warm THEN CPcomfort IS very comfortable"
#is coded as:

 fuzzy_rule(0,1,0,0,0,1)

# Where, the first three values (0,1,0) correspond with the linguistic
# expressions Atemp=(cold, warm, hot) that define the room temperature (CPtemp).
# The last three values (0,0,1) are related to the linguistic expressions
# Acomfort=(uncomfortable, comfortable and very comfortable) that define
# the room comfort (CPcomfort).
#

Define the fuzzy rules

Description

It is a constructor of fuzzy rules, the arguments are the diferent fuzzy_rule object.

Usage

fuzzy_rules(...)

Arguments

Value

fuzzy_rules <- list(...)

Examples

fuzzy_rules(fuzzy_rule(0,0,1, 0,0,1, 0,0,1),
     fuzzy_rule(1,0,0, 1,0,0, 1,0,0),
     fuzzy_rule(0,1,0, 0,1,0, 0,1,0))

Generate the R code

Description

The function takes as input the path to a XML file that contains a LDCP system. Then it generates its corresponding in R code. This R code is stored in an output file. The output file path is another function parameter.

Usage

generate_code(input, output)

Arguments

Value

If the process ends without error, the user will receive a message that indicates that the code has been generated successfully. Otherwise, the user will receive the detailed list of errors.

Examples

## Not run: generate_code('extdata/comfortableroom','comfortableroom')

## The code has been generated successfully

Define the GLMP

Description

Granular Linguistic Model of Phenomena (GLMP) is a network of cp and pm objects. that allows the designer to model computationally her/his own perceptions. The input data are introduced into the model through 1PMs which interpret the input data and create CPs. Then, 2PMs take several CPs as input and generate 2CPs. Of course, following the same scheme, is possible to add additional upper levels.

The glmp constructor receive as arguments the list of pms and the method with the computational model.

Usage

glmp(pms, method)

Arguments

Value

The generated glmp = list(pm, method)

Examples

## Not run: glmp_method <- function(pm,input){

  pm$pm_depth   <- pm_infer(pm$pm_depth, input[1])
  pm$pm_height  <- pm_infer(pm$pm_height,input[2])
  pm$pm_width   <- pm_infer(pm$pm_width, input[3])

  pm$pm_frame  <- pm_infer(pm$pm_frame, list( pm$pm_depth$y,
                                           pm$pm_height$y,
                                           pm$pm_width$y)
  )
  pm
}

my_glmp <- glmp(list(pm_depth  = pm_depth,
                     pm_height = pm_height,
                     pm_width  = pm_width,
                     pm_frame  = pm_frame),
                glmp_method)
                
## End(Not run)

Make the inference

Description

Make an inference with the fuzzy rules.

Usage

infer_rules(rules, operator, input)

Arguments

Value

A vector that containd the result of the inference.

Examples

## In the example the input of the fuzzy rule correspond with two CPs and each CP has 3
## linguistic variables, e.g, {"bad", "good", "very good"}. The output also
## correspond with a CP with 3 linguistic variables.

 infer_rules(fuzzy_rules(fuzzy_rule(0,0,1, 0,0,1, 0,0,1),
                   fuzzy_rule(1,0,0, 1,0,0, 1,0,0),
                   fuzzy_rule(0,1,0, 0,1,0, 0,1,0)),
             operator(min, max),
             list(c(0,0.5,0.5),c(0.5,0.5,0)))
## [1] 0.0 0.5 0.0

Define the LDCP system

Description

Linguistic Descriptions of Complex Phenomena (LDCP) is a technology focused on modeling complex phenomena, interpreting input data and generating automatic text reports customized to the user needs. #' The ldcp constructor receive as arguments: the data_structure, the glmp and the report_template.

Usage

ldcp(data, glmp, report)

Arguments

Value

The generated system ldcp = list(data, glmp, report)

See Also

cp and pm

Examples

## Not run: my_ldcp <- ldcp(my_data,my_glmp,my_report)

Execute the LDCP system

Description

Execute the ldcp system in order to obtain the linguistic report. This method follows these three sequential steps 1) Data acquisition, 2) Interpretation and 3) Report generation. Data acquisition process gets the input data and prepares the data structure. Then, the data are interpreted using the GLMP. The result is a set of computational perceptions (CP) that are valid to describe these data. Finally, the report generation process generates a linguistic report using the report template and the previous set of CPs.

Usage

ldcp_run(ldcp, input = NULL)

Arguments

Value

The ldcp object that contains the execution results.

Examples

## Not run: my_ldcp <- ldcp_run(my_ldcp)

Define the operator

Description

The operator defines the conjunction and disjunction functions used in the fuzzy rules. It takes as input parameters the function used to implement the conjunction, and the function used to implement the disjunction, e.g., "operator(min, max)", where min and max are functions defined by the R language that calculate the maximum and minimum, respectively, from a set of values received as input. Note that, we implicitly assign to the fuzzy implication operator (THEN) the function given for conjunction

Usage

operator(conjunction, disjunction)

Arguments

Value

the opertator object my_op <- list(conjunction, disjunction).

Examples

operator <- operator(min, max)

Define the PM

Description

Perception Mapping (PM) is used to create and aggregate cp objects. Each PM receives a set of inputs (cp objects or numerical values) which are aggregated into a single CP.

Usage

pm(u = NULL, y, g, t = NULL)

Arguments

Value

The generated pm = list(u,y,g,t)

See Also

cp

Examples

## Not run: cp_depth <- cp("cp_depth",c("far",
                            "bit far",
                            "good",
                            "close",
                            "very close"))

g_depth <- function(u,y){
  y$w <- degree_mf(fuzzy_partitions(triangle_mf(450,450,550),
                                 triangle_mf( 450,550,600),
                                 trapezoid_mf(550,600,800, 1000),
                                 triangle_mf( 800,1000,1300),
                                 trapezoid_mf( 1000,1300,1500,1500)),u)
  y
}

pm_depth  <- pm(y=cp_depth, g=g_depth)

########################### HEIGHT DEFINITION ###########################################
cp_height <- cp("cp_height", c("high",
                             "average high",
                             "centered",
                             "average low",
                             "low"))

g_height <- function(u,y){
  y$w <- degree_mf(fuzzy_partitions(trapezoid_mf(-1000,-1000,-600,-400),
                                               triangle_mf(-600,-400,0),
                                               trapezoid_mf(-400,0,200,400),
                                               triangle_mf(200,400,600),
                                               trapezoid_mf(400,600,1000,1000)),u)
  y
}

pm_height <- pm(y=cp_height, g=g_height)

########################### WIDTH DEFINITION ###########################################
cp_width <- cp("cp_width",  c("left",
                               "average left",
                                "centered",
                                "average right",
                                 "right"))

g_width <- function(u,y){
  y$w <- degree_mf(fuzzy_partitions(triangle_mf(-1000,-600,-400),
                                               triangle_mf(-600,-400,0),
                                              triangle_mf(-400,0,400),
                                               triangle_mf(0,400,600),
                                               triangle_mf(400,600,1000,1000)),
                              u)
  y
}

pm_width  <- pm(y=cp_width,  g=g_width)

########################### FRAME DEFINITION ###########################################
cp_frame <- cp("cp_frame", c("bad",
                             "middle",
                             "good"))

g_frame <- function(u,y){

  operator <- operator(min, max)

  y$w<- infer_rules(fuzzy_rules( fuzzy_rule(0,0,1,0,0, 0,0,1,0,0, 0,0,1,0,0, 0,0,1),
                           fuzzy_rule(1,1,1,1,1, 1,1,1,1,1, 1,1,0,1,1, 1,0,0),
                           fuzzy_rule(1,1,1,1,1, 1,0,0,0,1, 0,0,1,0,0, 1,0,0),
                           fuzzy_rule(1,0,0,0,1, 1,1,1,1,1, 0,0,1,0,0, 1,0,0),
                           fuzzy_rule(0,1,0,1,0, 0,1,0,1,0, 0,0,1,0,0, 0,1,0)),
                     operator,
                     list(u[[1]]$w,u[[2]]$w,u[[3]]$w))

  y
}

t_frame <- function(y){

  templates <- c("It has been taken a bad framed photo",
                 "It has been taken a middle framed photo",
                 "It has been taken a good framed photo")

  return( templates[which.max(y$w)])
}

pm_frame <-  pm(y=cp_frame, g=g_frame, t=t_frame)

## End(Not run)

Call the g function

Description

It call the g function in order to make the inference, i.e., map inputs u to output y.

Usage

pm_infer(pm, u = NULL)

Arguments

Value

the pm obtained after calling g.

See Also

cp

Examples

cp_depth <- cp("cp_depth", c("far",
                           "bit far",
                           "good",
                           "close",
                           "very close"))

g_depth <- function(u,y){
   y$w <- degree_mf(fuzzy_partitions(triangle_mf(450,450,550),
                                              triangle_mf( 450,550,600),
                                              trapezoid_mf(550,600,800, 1000),
                                              triangle_mf( 800,1000,1300),
                                              trapezoid_mf( 1000,1300,1500,1500)),u)
 y
}

pm_depth  <- pm(y=cp_depth, g=g_depth)
pm_depth   <- pm_infer(pm_depth, 650)

Define the pm of a multidimensional cp

Description

It is a set of pms that infer a multidimensional cp.

Usage

pm_multidimensional(...)

Arguments

Value

The generated pm_multidimensional <- list(...)

Generate the report of y

Description

It call the t function in order to generate the linguistic descriptions that better describe the output y.

Usage

pm_report(pm)

Arguments

Value

the description obtained after calling t.

Examples

cp_frame <- cp("cp_frame", c("bad",
                           "middle",
                           "good"))

                           g_frame <- function(u,y){

operator <- operator(min, max)

  y$w<- infer_rules(fuzzy_rules( fuzzy_rule(0,0,1,0,0, 0,0,1,0,0, 0,0,1,0,0, 0,0,1),
                           fuzzy_rule(1,1,1,1,1, 1,1,1,1,1, 1,1,0,1,1, 1,0,0),
                           fuzzy_rule(1,1,1,1,1, 1,0,0,0,1, 0,0,1,0,0, 1,0,0),
                           fuzzy_rule(1,0,0,0,1, 1,1,1,1,1, 0,0,1,0,0, 1,0,0),
                           fuzzy_rule(0,1,0,1,0, 0,1,0,1,0, 0,0,1,0,0, 0,1,0)),
                     operator,
                     list(u[[1]]$w,u[[2]]$w,u[[3]]$w))

  y
}

t_frame <- function(y){

 templates <- c("It has been taken a bad framed photo",
                 "It has been taken a middle framed photo",
                 "It has been taken a good framed photo")

  return( templates[which.max(y$w)])
}

pm_frame <-  pm(y=cp_frame, g=g_frame, t=t_frame)
pm_report(pm_frame)

Define the report template

Description

The text generation algorithm contains the programming code capable of generating the appropriate report to each specific user. Algorithms must select and order the linguistic expressions to generate the text included in the report. #' The report_template constructor receive as arguments the list of properties and the method (programming code) capable of generating the appropriate report.

Usage

report_template(properties = NULL, method, description = NULL)

Arguments

Value

The generated report_template= list(properties, method,description)

Examples

properties = NULL
report_method <- function(properties,pm){
  pm_report(pm$pm_frame)
}
my_report <- report_template(properties,
                    report_method)

Define the trapezoid membership function

Description

It is a constructor of trapezoidal shapes. They take as input the numerical values which define the anchor points in membership functions.

Usage

trapezoid_mf(a, b, c, d)

Arguments

Value

the (trapezoid_mf <- list(a,b,c,d))

Examples

trapezoid_mf(0, 1, 2, 3)

Define the triangle membership function

Description

It is a constructor of triangular shapes. They take as input the numerical values which define the anchor points in membership functions.

Usage

triangle_mf(a, b, c)

Arguments

Value

the (triangle_mf <- list(a,b,c))

Examples

triangle_mf(0, 1, 2)

Validate the XML file

Description

The function takes as input the path to a XML file that contains a LDCP system. Then it validates the LDCP system.

Usage

validate_xml(xmlfile, schema = NULL)

Arguments

Value

If the process ends without error, the user will receive the message that indicates that the XML is valid. Otherwise, the user will receive the detailed list of errors.

Examples

## Not run: validate_xml('extdata/comfortableroom.xml')

## The xml is valid

XML to rLDCP

Description

The function takes as input the path to a XML file that contains a LDCP system. Then it validates the LDCP system and generates its corresponding in R code. This R code is stored in an output file. The output file path is another function parameter.

Usage

xml2rldcp(input, output)

Arguments

Value

If the process ends without error, the user will receive two messages: one indicates that the XML is valid and the other indicates that the code has been generated successfully. Otherwise, the user will receive the detailed list of errors.

Examples

## Not run: xml2rldcp('extdata/comfortableroom.xml','comfortableroom.R')

## The xml is valid
## The code has been generated successfully