Package 'MoTBFs'

Description

This function builds a string with the structure of a 'mop' function.

Usage

asMOPString(parameters)

Arguments

Value

A "character" string with a 'mop' structure.

Examples

param <- c(1,2,3,4)
asMOPString(param)

param <- 3.4
asMOPString(param)

Description

This function builds a string with the structure of an 'mte' function.

Usage

asMTEString(parameters, num = 5)

Arguments

Value

A "character" string with an 'mte' structure.

Examples

param <- -5.8
asMTEString(param)

param <- c(5.2,0.3,-3,4)
asMTEString(param)

Description

Computes the Bayesian information criterion value (BIC) of a mixture of truncated basis functions. The BIC score is the log likelihood penalized by the number of parameters of the function and the number of records of the evaluated data.

Usage

BICMoTBF(Px, X)

Arguments

Value

A "numeric" value corresponding to the BIC score.

See Also

univMoTBF

Examples

## Data
X <- rexp(10000)

## Data test
Xtest <- rexp(1000)
Xtest <- Xtest[Xtest>=min(X) & Xtest<=max(X)]

## Learning
f1 <- univMoTBF(X, POTENTIAL_TYPE = "MOP", nparam = 10); f1
f2 <- univMoTBF(X, POTENTIAL_TYPE = "MTE", maxParam = 11); f2

## BIC values
BICMoTBF(Px = f1, X = Xtest)
BICMoTBF(Px = f2, X = Xtest)

Description

Compute the BIC score using more than one probability functions.

Usage

BICMultiFunctions(Px, X)

Arguments

Value

The "numeric" BIC value.

See Also

univMoTBF

Examples

## Data
X <- rnorm(500)
Y <- rnorm(500, mean=1)
data <- data.frame(X=X, Y=Y)
## Data as a "list"
Xlist <- sapply(data, list)

## Learning as a "list"
Plist <- lapply(data, univMoTBF, POTENTIAL_TYPE="MOP")
Plist

## BIC value
BICMultiFunctions(Px=Plist, X=Xlist)

Description

Clean the memory. Delete all the objects in memory and a garbage collection takes place.

Usage

clean(envir = globalenv(), n = 2)

Arguments

Examples

## Run to clean the environment
clean()
clean(n=2)

Description

Extracts the parameters of a joint MoTBF density.

Usage

## S3 method for class 'jointmotbf'
coef(object, ...)

Arguments

Value

A "numeric" vector with the parameters of the function.

See Also

jointmotbf.fit

Examples

## Generate a dataset
data <- data.frame(X1 = rnorm(100), X2 = rnorm(100))

## Joint function
dim <-c(2,4)
P <- jointmotbf.fit(data, dimensions = dim)
P$Time

## Coefficients
coef(P)

Description

It extracts the parameters of the learned mixtures of polynomial models.

Usage

coeffMOP(fx)

coeffPol(fx)

Arguments

Details

coeffMOP() return the coefficients of the terms in the function.

coeffPol() returns the coefficients of the potential of the polynomial basis in the function.

Value

An array with the parameters of the function.

See Also

coef.motbf and univMoTBF

Examples

## 1. EXAMPLE
data <- rchisq(1000, df=5)
fx1 <- univMoTBF(data, POTENTIAL_TYPE = "MOP")
hist(data, prob=TRUE, main="")
plot(fx1, xlim=range(data), col="red", add=TRUE)
coeffMOP(fx1) ## coef(fx1)
coeffPol(fx1)

## 2. EXAMPLE
data <- rexp(1000, rate=1/2)
fx2 <- univMoTBF(data, POTENTIAL_TYPE = "MOP")
hist(data, prob=TRUE, main="")
plot(fx2, xlim=range(data), col="red", add=TRUE)
coeffMOP(fx2) ## coef(fx2)
coeffPol(fx2)

Description

Extracts the parameters of the learned mixtures of truncated basis functions.

Usage

## S3 method for class 'motbf'
coef(object, ...)

Arguments

Value

A numeric vector with the parameters of the function.

See Also

univMoTBF, coeffMOP and coeffMTE

Examples

## Data
X <- rchisq(2000, df = 5)

## Learning
f1 <- univMoTBF(X, POTENTIAL_TYPE = "MOP"); f1
## Coefficients
coef(f1)

## Learning
f2 <- univMoTBF(X, POTENTIAL_TYPE = "MTE", maxParam = 10); f2
## Coefficients
coef(f2)

## Learning
f3 <- univMoTBF(X, POTENTIAL_TYPE = "MOP", nparam=10); f3
## Coefficients
coef(f3)

## Plots
plot(NULL, xlim = range(X), ylim = c(0,0.2), xlab="X", ylab="density")
plot(f1, xlim = range(X), col = 1, add = TRUE)
plot(f2, xlim = range(X), col = 2, add = TRUE)
plot(f3, xlim = range(X), col = 3, add = TRUE)
hist(X, prob = TRUE, add= TRUE)

Description

It extracts the parameters of the learned mixtures of truncated exponential models.

Usage

coeffMTE(fx)

coeffExp(fx)

Arguments

Details

coeffMOP() return the coefficients of the terms in the function.

coeffPol() returns the coefficients of the potential of the exponential basis in the function.

Value

An array with the parameters of the function.

See Also

coef.motbf and univMoTBF

Examples

## 1. EXAMPLE
data <- rnorm(1000, mean=5)
fx1 <- univMoTBF(data, POTENTIAL_TYPE = "MTE")
hist(data, prob=TRUE, main="")
plot(fx1, xlim=range(data), col="red", add=TRUE)
coeffMTE(fx1) ## coef(fx1)
coeffExp(fx1)

## 2. EXAMPLE
data <- rexp(1000, rate=1/2)
fx2 <- univMoTBF(data, POTENTIAL_TYPE = "MTE")
hist(data, prob=TRUE, main="")
plot(fx2, xlim=range(data), col="red", add=TRUE)
coeffMTE(fx2) ## coef(fx2)
coeffExp(fx2)

Description

Converts 'motbf' and 'jointmotbf' objects into character string expressions or executable R functions.

Usage

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

## S3 method for class 'motbf'
as.function(x, ...)

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

## S3 method for class 'jointmotbf'
as.function(x, ...)

Arguments

Value

• as.character: Returns a character string representing the mathematical expression of the object.

• as.function: Returns an executable R function that accepts numeric arguments to evaluate the MoTBF expression.

Examples

## Example 1
X <- rchisq(5000, df = 3)
P <- univMoTBF(X, POTENTIAL_TYPE = "MOP"); P
as.function(P)(10)

## Example 2
data <- data.frame(X = rnorm(100), Y = rexp(100))
dim <- c(3,2)
P <- jointmotbf.fit(data, dimensions = dim)
density <- as.function(P)(data[,1], data[,2])
sum(log(density))

Description

Collection of functions used for learning conditional MoTBFs, computing the internal BIC, selecting the parents that get the best BIC value, and other internal functions required to learn the conditional densities.

Usage

conditionalMethod(
  data,
  nameParents,
  nameChild,
  numIntervals,
  POTENTIAL_TYPE,
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = FALSE
)

conditional(
  data,
  nameParents,
  nameChild,
  domainChild,
  domainParents,
  numIntervals,
  mm,
  POTENTIAL_TYPE,
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = FALSE
)

select(
  data,
  nameParents,
  nameChild,
  domainChild,
  domainParents,
  numIntervals,
  POTENTIAL_TYPE,
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = FALSE
)

learn.tree.Intervals(
  data,
  nameParents,
  nameChild,
  domainParents,
  domainChild,
  numIntervals,
  POTENTIAL_TYPE,
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = FALSE
)

BICscoreMoTBF(conditionalfunction, data, nameParents, nameChild)

Arguments

Details

The main function, conditionalMethod(), fits truncated basis functions for the conditioned variable for each configuration of splits of the parent variables. The domain of the parent variables is splitted in different intervals and univariate functions are fitted in these ranges. The remaining above described functions are internal to the main function.

Value

The main function conditionalMethod returns a list with the name of the parents, the different intervals and the fitted densities

See Also

printConditional

Examples

## Dataset
X <- rnorm(1000)
Y <- rbeta(1000, shape1 = abs(X)/2, shape2 = abs(X)/2)
Z <- rnorm(1000, mean = Y)
data <- data.frame(X = X, Y = Y, Z = Z)

## Conditional Method
parents <- c("X","Y")
child <- "Z"
intervals <- 2

potential <- "MTE"
fMTE <- conditionalMethod(data, nameParents = parents, nameChild = child, 
numIntervals = intervals, POTENTIAL_TYPE = potential)
printConditional(fMTE)

##############################################################################

potential <- "MOP"
fMOP <- conditionalMethod(data, nameParents = parents, nameChild = child,
numIntervals = intervals, POTENTIAL_TYPE = potential, maxParam = 15)
printConditional(fMOP)

##############################################################################

##############################################################################
## Internal functions: Not needed to run #####################################
##############################################################################

domainP <- lapply(parents, function(i)range(data[,i]))
names(domainP) = parents
domainC <- range(data[, child])
t <- conditional(data, nameParents = parents, nameChild = child,
domainParents = domainP, domainChild = domainC, numIntervals = intervals,
mm = NULL, POTENTIAL_TYPE = potential)
printConditional(t)
selection <- select(data, nameParents = parents, nameChild = child,
domainParents = domainP, domainChild = domainC, numIntervals = intervals,
POTENTIAL_TYPE = potential)
parent1 <- selection$parent; parent1
domainParent1 <- range(data[,parent1])
treeParent1 <- learn.tree.Intervals(data, nameParents = parent1,
nameChild = child, domainParents = domainParent1, domainChild = domainC,
numIntervals = intervals, POTENTIAL_TYPE = potential)
BICscoreMoTBF(treeParent1, data, nameParents = parent1, nameChild = child)


###############################################################################
###############################################################################

Description

Computes the confusion matrix for a given fitted model object.

Usage

confusionMatrix(x, ...)

## S3 method for class 'motbf_fit_cv'
confusionMatrix(x, digits = 4, ...)

Arguments

Value

A matrix or table containing the confusion matrix.

Description

Collection of functions for discretizing, standardizing, converting factors to characters and other usufull methods for pre-processing datasets.

Usage

whichDiscrete(dataset, discreteVariables)

discreteVariables_as.character(dataset, discreteVariables)

standardizeDataset(dataset)

discretizeVariablesEWdis(dataset, numIntervals, factor = FALSE, binary = FALSE)

discreteVariablesStates(namevariables, discreteData)

nstates(DiscreteVariablesStates)

quantileIntervals(X, numIntervals)

scaleData(dataset, scale)

Arguments

Details

whichDiscrete() selects the position of the discrete variables.

discreteVariables_as.character() transforms the values of the discrete variables into character values.

standardizeDataset() standardizes all the variables in a data set.

discretizeVariablesEWdis() discretizes the continuous variables in a dataset using equal width binning.

discreteVariablesStates() extracts the states of the qualitative variables.

nstates() computes the number of different values of the discrete variables.

quantileIntervals() gets the quantiles of a variable taking into account the number of intervals into which its domain is splitted.

Examples

## dataset: 2 continuous variables, 1 discrete variable.
data <- data.frame(X = rnorm(100),Y = rexp(100,1/2), Z = as.factor(rep(c("s","a"), 50)))
disVar <- "Z" ## Discrete variable
class(data[,disVar]) ## factor

data <- discreteVariables_as.character(dataset = data, discreteVariables = disVar)
class(data[,disVar]) ## character

whichDiscrete(dataset = data, discreteVariables = "Z")

standData <- standardizeDataset(dataset = data)

disData <- discretizeVariablesEWdis(dataset = data, numIntervals = 3)

l <- discreteVariablesStates(namevariables = names(data), discreteData = disData)

nstates(DiscreteVariablesStates = l)

## Continuous variables
quantileIntervals(X = data[,1], numIntervals = 4)
quantileIntervals(X = data[,2], numIntervals = 10)

Description

Compute the derivative of an "motbf" object with 'mop' subclass.

Usage

derivMOP(fx)

Arguments

Value

The derivative which is also an "motbf" function.

See Also

univMoTBF for learning and derivMoTBF for general "motbf" models.

Examples

## 1. EXAMPLE
X <- rexp(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MOP")
derivMOP(Px)

## 2. EXAMPLE
X <- rnorm(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MOP")
derivMOP(Px)

## Not run: 
## 3. EXAMPLE
X <- rnorm(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MTE")
derivMOP(Px)
## Error in derivMOP(Px): fx is an 'motbf' function but not 'mop' subclass.
class(Px)
subclass(Px)

## End(Not run)

Description

Compute the derivative of a one-dimensional mixture of truncated basis function.

Usage

derivMoTBF(fx)

Arguments

Value

The derivative of the MoTBF function, which is also an object of class "motbf".

See Also

univMoTBF, derivMOP and derivMTE

Examples

## 1. EXAMPLE
X <- rexp(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MOP")
derivMoTBF(Px)

## 2. EXAMPLE
X <- rnorm(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MOP")
derivMoTBF(Px)

## 3. EXAMPLE
X <- rchisq(1000, df = 3)
Px <- univMoTBF(X, POTENTIAL_TYPE="MTE")
derivMoTBF(Px)

## Not run: 
## 4. EXAMPLE
Px <- "x+2"
class(Px)
derivMoTBF(Px)
## Error in derivMoTBF(Px): "fx is not an 'motbf' function."

## End(Not run)

Description

Compute the derivative of an "motbf" object with 'mte' subclass.

Usage

derivMTE(fx)

Arguments

Value

The derivative which is also an "motbf" function.

See Also

univMoTBF for learning and derivMoTBF for general "motbf" models.

Examples

## 1. EXAMPLE
X <- rexp(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MTE")
derivMTE(Px)

## 2. EXAMPLE
X <- rnorm(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MTE")
derivMTE(Px)

## Not run: 
## 3. EXAMPLE
X <- rnorm(1000)
Px <- univMoTBF(X, POTENTIAL_TYPE="MOP")
derivMTE(Px)
## Error in derivMTE(Px): fx is an 'motbf' function but not 'mte' subclass.
class(Px)
subclass(Px)

## End(Not run)

Description

Get the dimension of "motbf" and "jointmotbf" densities. This function is deprecated; use "getMotbfDim" instead.

Usage

dimensionFunction(P)

Arguments

Value

Dimension of the function.

See Also

univMoTBF and jointMoTBF

Description

This function returns the states of all discrete node from a list obtained from motbf.fit.

Usage

discreteStatesFromBN(bn)

Arguments

Value

discreteStatesFromBN returns a list of length equal to the number of discrete nodes in the network. Each element of the list corresponds to a node and contains a character vector indicating the states of the node.

Examples

## Create a dataset
  # Continuous variables
  x <- rnorm(100)
  y <- rnorm(100)
  
  # Discrete variable
  z <- sample(letters[1:2],size = 100, replace = TRUE)
  
  data <- data.frame(C1 = x, C2 = y, D1 = z, stringsAsFactors = FALSE)
  
## Get DAG
  dag <- LearningHC(data)

## Learn a BN
  bn <- motbf.fit(dag, data, POTENTIAL_TYPE = "MTE")

## Get the states of the discrete nodes

  discreteStatesFromBN(bn)

Description

This data set contains information of Escherichia coli. It is a bacterium of the genus Escherichia that is commonly found in the lower intestine of warm-blooded organism.

Format

A data frame with 336 rows, 8 variables and the class.

Details

Sequence Name

Accession number for the SWISS-PROT database.

mcg

McGeoch's method for signal sequence recognition.

gvh

Von Heijne's method for signal sequence recognition.

lip

Von Heijne's Signal Peptidase II consensus sequence score. Binary attribute.

chg

Presence of charge on N-terminus of predicted lipoproteins. Binary attribute.

aac

Score of discriminant analysis of the amino acid content of outer membrane and periplasmic proteins.

alm1

Score of the ALOM membrane spanning region prediction program.

alm2

Score of ALOM program after excluding putative cleavable signal regions from the sequence.

Class

Class variable. 8 possibles states.

Source

http://archive.ics.uci.edu/ml/datasets/Ecoli

Description

Evaluates a univariate ("mop", "mte") or joint distribution ("jointmotbf") at a specific point.

Usage

eval.motbf(P, values)

Arguments

Value

If all the variables in the equation are evaluated, then a "numeric" value is returned. Otherwise, an "univmotbf" object or a "jointmotbf" object is returned.

Examples

#' ## 1. EXAMPLE
## Dataset with 2 variables
X <- data.frame(rnorm(100), rexp(100))

## Joint function
dim <- c(3,3) # dim <- c(5,4)
P <- jointmotbf.fit(X, dimensions = dim)

## Evaluation
val <- list(x = -1.5, y = 3)
eval.motbf(P, values = val)
val <- list(x = -1.5)
eval.motbf(P, values = val)
val <- list(y = 3)
eval.motbf(P, values = val)

##############################################################################
## MORE EXAMPLES #############################################################
############################################################################## 

## Dataset with 3 variables
X <- data.frame(x = rnorm(100), y = rexp(100), z = rnorm(100, 1))

## Joint function
dim <- c(2,1,3)
P <- jointmotbf.fit(X, dimensions = dim)
P

## Evaluation
val <- list(x = 0.8, y = -2.1, z = 1.2)
eval.motbf(P, values = val)
val <- list(x = 0.8, y = 1.2)
eval.motbf(P, values = val)
val <- list(y = -2.1)
eval.motbf(P, values = val)

Description

Evaluates a "jointmotbf" object at a specific point. This function is deprecated; use "eval.mop" instead.

Usage

evalJointFunction(P, values)

Arguments

Value

If all the variables in the equation are evaluated then a "numeric" value is returned. Otherwise, an "motbf" object or a "jointmotbf" object is returned.

Description

Computes the expected value (mean) of a Mixture of Polynomials (MoP) function over its domain.

Usage

expectedValueMOP(fx)

Arguments

Value

A numeric value representing the expected value of the distribution.

Description

Computes the expected value (mean) of a Mixture of Truncated Exponentials (MTE) function over its domain.

Usage

expectedValueMTE(fx)

Arguments

Value

A numeric value representing the expected value of the distribution.

Description

This function returns the conditional probability function of a node given an MoTBF-bayesian network and the value of its parents.

Usage

findConditional(node, bn, evi = NULL)

Arguments

Value

A list containing the conditional distribution of the target variable.

Examples

## Dataset
  data("ecoli", package = "MoTBFs")
  data <- ecoli[,-c(1,9)]

## Get directed acyclic graph
  dag <- LearningHC(data)
  
## Learn bayesian network
  bn <- MoTBFs_Learning(dag, data = data, numIntervals = 4, POTENTIAL_TYPE = "MTE")
  
## Specify the evidence set and node of interest
  evi <- data.frame(lip = "0.48", alm1 = 0.55, gvh = 1, stringsAsFactors=FALSE)
  node = "alm2"
  
## Get the conditional distribution
  findConditional(node, bn, evi)

Description

Generate a prior dataset taking in to account the relationships between the varibles in a given network.

Usage

generateNormalPriorData(graph, data, size, means, deviations = NULL)

Arguments

Value

A normal prior data set of class "data.frame".

See Also

rnormMultiv

Examples

## Data
data(ecoli)
data <- ecoli[,-c(1,9)] ## remove sequece.name and class
X <- TrainingandTestData(data, percentage_test = 0.95)
Xtraining <- X$Training
Xtest <- X$Test

## DAG
dag <- LearningHC(data)
plot(dag)

## Means and desviations
colnames(data)

m <- sapply(data, function(x){ifelse(is.numeric(x), mean(x),NA)})
d <- sapply(data, function(x){ifelse(is.numeric(x), sd(x),NA)})


## Prior Dataset
n <- 5600
priorData <- generateNormalPriorData(dag, data = Xtraining, size = n, means = m)
summary(priorData)
ncol(priorData)
nrow(priorData)
class(priorData)

Description

get_approx_posterior() returns an approximation to the posterior probability distribution of a target variable given a set of observed variables. The inference process is based on sample generation. See details.

Usage

get_approx_posterior(
  bn,
  target,
  evidence = NULL,
  size = 100,
  parallel = FALSE,
  ...
)

Arguments

Details

If any node is observed, i.e., argument evidence is not NULL, samples are generated from the Bayesian network using the likelihood weighting algorithm. Otherwise, i.e., no node is observed, samples are generated using the forward sampling algorithm.

Value

A list of two elements: 1) the posterior probability distribution of the target variable, and 2) a data.frame with the generated sample, whose weights are attached as an attribute called weights (if evidence is not NULL).

References

Henrion, M. (1988). Propagating uncertainty in Bayesian networks by probabilistic logic sampling. In Machine Intelligence and Pattern Recognition (Vol. 5, pp. 149-163). North-Holland.

Examples

## Dataset
  data("ecoli", package = "MoTBFs")
  data <- ecoli[,-c(1,9)]

## Get directed acyclic graph
  dag <- LearningHC(data)
  
## Learn bayesian network
  bn <- motbf.fit(dag, data = data, numIntervals = 4, POTENTIAL_TYPE = "MOP")
  
## Specify the evidence set and target variable
  obs <- data.frame(lip = "0.48", alm1 = 0.55, gvh = 1, stringsAsFactors=FALSE)
  node <- "alm2"
  
## Get the posterior distribution of 'node' given "evidence" and the generated sample
  get_approx_posterior(bn, target = node, evidence = obs, size = 10, maxParam = 15)

Description

Compute the parents of each variable in the graph.

Usage

getChildParentsFromGraph(graph, nameVars = NULL)

Arguments

Value

A list where each element is a vector containing the name of a variable and its parents in the graph.

Examples

## Data
data(ecoli)
ecoli <- ecoli[,-1] ## Sequence Name

## DAG1
dag1 <- LearningHC(ecoli)
dag1
plot(dag1)
getChildParentsFromGraph(dag1)

## DAG2
dag2 <- LearningHC(ecoli, numIntervals = 10)
dag2
plot(dag2)
getChildParentsFromGraph(dag2)

Description

Compute the coefficients for the linear opinion pool

Usage

getCoefficients(fPI, rangeNewPriorData, fD, data, domain, coeffversion)

Arguments

Details

coeffversion can be: "1" coef1 and coef2 are the sum of the probabilities of one of the function over the sum of all probabilities, respectively; "2" coef1 and coef2 are the solution of a linear optimization problem which tries to maximize the sum 1 for each row of probabilities; "3" coef1 and coef2 are the difference of the log-likelihood of the evaluated model and a random uniform model over the sum of both differences, respectively; "4" coef1 and coef2 are the difference of the log-likelihood of the evaluated model and a ramdom positive MoTBF model over the sum of both differences, respectively.

Value

A "numeric" value of length 2 giving the coefficients which are the weigth of the two function to combine.

See Also

learnMoTBFpriorInformation

Examples

## Data
X <- rnorm(15)

## Prior Data
priordata <- rnorm(5000)

## Learning
confident <- 5
type <- "MOP"
f <- learnMoTBFpriorInformation(priorData = priordata, data = X, s = confident,
POTENTIAL_TYPE = type, returnAll = TRUE)
attributes(f)
 
## Coefficients: linear opinion pool
getCoefficients(fPI = f$priorFunction, rangeNewPriorData = f$domain, fD = f$dataFunction, 
data = X, domain = range(X), coeffversion = 4)

getCoefficients(fPI = f$priorFunction, rangeNewPriorData = f$domain, fD = f$dataFunction, 
data = X, domain = range(X), coeffversion = 1)

getCoefficients(fPI = f$priorFunction, rangeNewPriorData = f$domain, fD = f$dataFunction, 
data = X, domain = range(X), coeffversion = 3)

getCoefficients(fPI = f$priorFunction, rangeNewPriorData = f$domain, fD = f$dataFunction, 
data = X, domain = range(X), coeffversion = 2)

Description

Get the Directed acyclic graph (DAG) from a Bayesian network (BN)

Usage

getDAG(bn)

Arguments

Value

An object of class bn (same class as in bnlearn package).

Description

Get the dimension of "motbf" and "jointmotbf" densities.

Usage

getMotbfDim(P)

Arguments

Value

Dimension of the function.

See Also

univMoTBF and jointmotbf.fit

Examples

## 1. EXAMPLE 
## Data
X <- rnorm(2000)

## Univariate function
f <- univMoTBF(X, POTENTIAL_TYPE = "MOP")
getMotbfDim(f)

## 2. EXAMPLE 
## Dataset with 2 variables
X <- data.frame(x = rnorm(100), y = rnorm(100))

## Joint function
dim <- c(2,3)
P <- jointmotbf.fit(X, dimensions = dim)

## Dimension of the joint function
getMotbfDim(P)

Description

Get the names of the variables involved in a "univmotbf" or jointmotbf object.

Usage

getMotbfVar(P)

Arguments

Value

A "character" vector with the names of the variables in the function.

Examples

# 1. EXAMPLE
## Generate a dataset
data <- data.frame(X1 = rnorm(100), X2 = rnorm(100))

## Joint function
dim <-c(3,2)
P <- jointmotbf.fit(data, dimensions = dim)
P

## Variables
getMotbfVar(P)

##############################################################################
## MORE EXAMPLES #############################################################
##############################################################################

## Generate a dataset
data <- data.frame(X1 = rnorm(100), X2 = rnorm(100), X3 = rnorm(100))

## Joint function
dim <- c(2,1,3)
P <- jointmotbf.fit(data, dimensions = dim)

## Variables
getMotbfVar(P)

Description

Generates a non normalized (i.e. not integrating to 1) positive MoTBF function.

Usage

getNonNormalisedRandomMoTBF(degree, POTENTIAL_TYPE = "MOP")

Arguments

Value

A "numeric" vector of length 2 giving the coefficients.

Examples

getNonNormalisedRandomMoTBF(8, POTENTIAL_TYPE = "MOP")
getNonNormalisedRandomMoTBF(11, POTENTIAL_TYPE = "MTE")

Description

Learn the structure of a hybrid Bayesian network, using a fixed method (Naive Bayes, NB), a restricted method (Tree augmented Naive Bayes, TAN), or an unrestricted method (the hill climbing, HC, score-based local search method).

Usage

getStructure(data, method, target = NULL)

Arguments

Details

getStructure() automatically converts non-numeric variables into factors before calling function hc() from the bnlearn package. In the case of TAN, it converts all numeric and non-numeric variables into factors (using 4 equal width intervals) before calling tree.bayes() from the bnlearn package.

Value

The output is a "bn" object containing the learned graph.

See Also

hc

Examples

## Data
data(ecoli)
ecoli <- ecoli[,-1] ## Sequence Name

## DAG1
dag1 <- getStructure(ecoli, method = "HC")
dag1
plot(dag1)

## DAG2
dag2 <- getStructure(ecoli, method = "TAN", target = "mcg")
dag2
plot(dag2)

Description

Compute the BIC score and the loglikelihood from the fitted MoTBFs functions in a hybrid Bayesian network, i.e., from objects of class motbf.fit.

Usage

logLikelihood.MoTBFBN(object, data)

BiC.MoTBFBN(object, data)

Arguments

Value

A numeric value giving the log-likelihood of the BN.

See Also

MoTBFs_Learning

Examples

## Dataset Ecoli
require(MoTBFs)
data(ecoli)
data <- ecoli[,-c(1)] ## remove variable sequence

## Directed acyclic graph
dag <- LearningHC(data)

## Learning BN
intervals <- 3
potential <- "MOP"
P1 <- MoTBFs_Learning(graph = dag, data = data, POTENTIAL_TYPE=potential,
numIntervals = intervals, maxParam = 5)
logLikelihood.MoTBFBN(P1, data) ##BIC$LogLikelihood
BIC <- BiC.MoTBFBN(P1, data)
BIC$BIC

## Learning BN
intervals <- 2
potential <- "MTE"
P2 <- MoTBFs_Learning(graph = dag, data = data, POTENTIAL_TYPE=potential,
numIntervals = intervals, maxParam = 10)
logLikelihood.MoTBFBN(P2, data) ##BIC$LogLikelihood
BIC <- BiC.MoTBFBN(P2, data)
BIC$BIC

Description

Integrate a "jointmotbf" object over an non defined domain. It is able to get the integral of a joint function over a set of variables or over all the variables in the function. This function is deprecated; use "integrate.motbf" instead.

Usage

integralJointMoTBF(P, var = NULL)

Arguments

Value

A multiintegral of a joint function of class "jointmotbf".

Description

Method to calculate the non-defined integral of an "motbf" object of 'mop' subclass. This function is deprecated; use "integrate.motbf" instead.

Usage

integralMOP(fx)

Arguments

Value

The non-defined integral of the function.

See Also

univMoTBF for learning and integralMoTBF for a more complete function to get defined and non-defined integrals of class "motbf".

Description

Compute the integral of a one-dimensional mixture of truncated basis function over a bounded or unbounded interval. This function is deprecated; use "integrate.motbf" instead.

Usage

integralMoTBF(fx, min = NULL, max = NULL)

Arguments

Details

If the limits of the interval, min and max are NULL, then the output is the expression of the indefinite integral. If only 'min' contains a numeric value, then the expression of the integral is evaluated at this point.

Value

integralMoTBF() returns either the indefinite integral of the MoTBF function, which is also an object of class "motbf", or the definite integral, wich is a "numeric" value.

See Also

univMoTBF, integralMOP and integralMTE

Description

Method to calculate the non-defined integral of an "motbf" object of 'mte' subclass. This function is deprecated; use "integrate.motbf" instead.

Usage

integralMTE(fx)

Arguments

Value

The non-defined integral of the function.

See Also

univMoTBF for learning and integralMoTBF for a more complete function to get defined and non-defined integrals of class "motbf".

Description

Compute the integral of a one-dimensional mixture of truncated basis function (objects of class "mop" or "mte") over a bounded or unbounded interval, or compute the indefinite integral of a joint function (object of class "jointmotbf") over a subset of variables or over all the variables in the function.

Usage

integrate.motbf(f, ...)

Arguments

Details

This function is a wrapper of internal functions integrateMOP(), integrateMTE() and integrateJointmotbf().

If f is of class "mop" or "mte", valid optional arguments are 'lower' (the lower integration limit) and 'upper' (the upper integration limit), which represent the limits of the interval to compute the definite integral. If 'lower' and 'upper' are not specified, then the output is the expression of the indefinite integral.

On the other hand, if f is of class "jointmotbf", the only valid optional argument is 'var', which is a "character" vector containing the name of the variables that will be integrated out. If not specified, then all the variables are integrated out.

Note that integrate.motfb() deprecates the following functions, included in previous versions of the package: integralMTE, integralMOP, integralMoTBF and integralJointMoTBF.

Value

If f is of class "mop" or "mte", integrate.motfb() returns either the indefinite integral of the MoTBF function, which is also an object of classes "motbf", "univmotbf", and either "mop" or "mte"); or the definite integral, which is a "numeric" value. If f is of class "jointmotbf", integrate.motfb() returns a multi-integral of the joint function, which is also of class "jointmotbf".

See Also

univMoTBF and jointMoTBF

Examples

## 1. EXAMPLE
## Univariate MOP integral
X <- rexp(1000)
fx <- univMoTBF(X, POTENTIAL_TYPE = "MOP", scale = FALSE)
integrate.motbf(fx)
integrate.motbf(fx, 2, 6)


## 2. EXAMPLE
## Univariate MOP integral and plot of result
Y <- rnorm(1000)
fy <- univMoTBF(Y, POTENTIAL_TYPE = "MOP")
Fy <- integrate.motbf(fy)
plot(Fy)
integrate.motbf(fy, min(Y), max(Y))

## 3. EXAMPLE
## Univariate MTE integral
Z <- rchisq(1000, df = 3)
fz <- univMoTBF(Z, POTENTIAL_TYPE = "MTE", scale = FALSE)
integrate.motbf(fz)
integrate.motbf(fz, lower = 2, upper = 5)

## Not run: 
## 4. EXAMPLE
Px <- "1+x+5"
class(Px)
integrate.motbf(Px)
## Error in integrate.motbf(Px) : Argument "f" is not of class "motbf"

## End(Not run)

## 5. EXAMPLE: Joint MOP integral
## Dataset with 2 variables
data <- data.frame(x = rnorm(100), y = rnorm(100))

## Joint function
dim <- c(2, 3)
P <- jointmotbf.fit(data, dimensions = dim)

## Integral
integrate.motbf(P)
integrate.motbf(P, var = "x")
integrate.motbf(P, var = "y")

##############################################################################
## MORE EXAMPLES #############################################################
##############################################################################

## Dataset with 3 variables
data <- data.frame(x = rnorm(50), y = rnorm(50), z = rnorm(50))

## Joint function
dim <- c(2,2,3)
P = jointmotbf.fit(data, dimensions = dim)
 
## Integral
integrate.motbf(P)
integrate.motbf(P, var="x")
integrate.motbf(P, var=c("x","z"))

Description

This function allows to check whether a node is discrete or not

Usage

is.discrete(node, bn)

Arguments

Value

is.discrete returns TRUE or FALSE depending on whether the node is discrete or not.

Examples

## Create a dataset
  # Continuous variables
  x <- rnorm(100)
  y <- rnorm(100)
  
  # Discrete variable
  z <- sample(letters[1:2],size = 100, replace = TRUE)
  
  data <- data.frame(C1 = x, C2 = y, D1 = z, stringsAsFactors = FALSE)
  
## Get DAG
  dag <- LearningHC(data)

## Learn BN
  bn <- MoTBFs_Learning(dag, data, POTENTIAL_TYPE = "MTE")

## Check wheter a node is discrete or not

  # Using its name
  is.discrete("D1", bn)
  
  # Using its index position
  is.discrete(3, bn)

Description

Utility functions to check whether an object belongs to a specific MoTBF class, or to identify its underlying subclass ('mop' or 'mte').

Usage

is.motbf(x, class = "motbf")

is.univmotbf(x, class = "univmotbf")

is.jointmotbf(x, class = "jointmotbf")

is.motbf_fit(x, class = "motbf_fit")

is.motbf_fit_cv(x, class = "motbf_fit_cv")

is.mte(x)

is.mop(x)

subclass(fx)

Arguments

Value

• is.*: Logical value (TRUE or FALSE) indicating if the object belongs to the checked class.

• subclass: A character string ("mop" or "mte") specifying the underlying family of the object.

Description

is.observed() checks whether a node belongs to the evidence set or not.

Usage

is.observed(node, evi)

Arguments

Value

This function returns TRUE if "node" is included in "evi", or, otherwise, FALSE.

Examples

## Data frame of the evidence set
  obs <- data.frame(lip = "1", alm2 = 0.5, stringsAsFactors=FALSE)
  
## Check if x is in obs
  is.observed("x", obs)

Description

is.root checks whether a node has parents or not.

Usage

is.root(node, dag)

Arguments

Value

is.root returns TRUE or FALSE depending on whether the node is root or not.

Examples

## Create a dataset
  # Continuous variables
  x <- rnorm(100)
  y <- rnorm(100)
  
  # Discrete variable
  z <- sample(letters[1:2],size = 100, replace = TRUE)
  
  data <- data.frame(C1 = x, C2 = y, D1 = z, stringsAsFactors = FALSE)
  
## Get DAG
  dag <- LearningHC(data)
  
## Check if a node is root
 is.root("C1", dag)

Description

Function for learning joint MoTBFs. The jointmotbf.fit() function is a wrapper of two internal (non-exported) functions: getParamJoint() and fixParamJoint(). The first one gets the parameters by solving a quadratic optimization problem, minimizing the mean squared error between the empirical joint CDF and the estimated CDF. The density is obtained as the derivative of the estimated CDF. The second one, fixParamJoint(), fixes the equation of the joint function using the previously learned parameters and converting this "character" string into an object of class "jointmotbf".

Usage

jointmotbf.fit(
  X,
  ranges = NULL,
  dimensions = NULL,
  fitPoints = 10,
  constraints = 10
)

Arguments

Value

jointmotbf.fit() returns a list with the following elements:

Examples

## 1. EXAMPLE 
## Generate a multinormal dataset
data <- data.frame(X1 = rnorm(100), X2 = rnorm(100))

## Joint learnings
dim <- c(2,3)
P <- jointmotbf.fit(data, dimensions = dim)

P
attributes(P)
class(P)

###############################################################################
## MORE EXAMPLES ##############################################################
###############################################################################

## Generate a dataset
data <- data.frame(X1 = rnorm(100), X2 = rnorm(100), X3 = rnorm(100))

## Joint learnings
dim <- c(3,2,3)
P <- jointmotbf.fit(data, dimensions = dim)
P
attributes(P)
class(P)

Description

Deprecated functions; use "jointmotbf.fit" instead.

Usage

parametersJointMoTBF(X, ranges = NULL, dimensions = NULL)

jointMoTBF(object)

Arguments

Details

Two functions for learning joint MoTBFs. The first one, parametersJointMoTBF(), gets the parameters by solving a quadratic optimization problem, minimizing the mean squared error between the empirical joint CDF and the estimated CDF. The density is obtained as the derivative od the estimated CDF. The second one, jointMoTBF(), fixes the equation of the joint function using the previously learned parameters and converting this "character" string into an object of class "jointmotbf".

Value

parametersJointMoTBF() returns a list with the following elements: Parameters, which contains the computed coefficients of the resulting function; Dimension, which is a "numeric" vector containing the number of coefficients used for each variable; Range contains a "numeric" matrix with the domain of each variable, by columns; Iterations contains the number of iterations needed to solve the problem; Time contains the execution time.

jointMoTBF() returns an object of class "jointmotbf", which is a list whose only visible element is the analytical expression of the learned density. It also contains the other aforementioned elements, which can be retrieved using attributes()

Description

Learn the structure of a hybrid Bayesian network using the hill climbing local search method.

Usage

LearningHC(dataset, numIntervals = NULL)

Arguments

Details

LearningHC() automatically converts non-numeric variables into factors before calling function hc() from the bnlearn package. LearningHC() can also be used to discretize the dataset, using the equal width method, before calling hc().

Value

The output is a "bn" object containing the learned graph.

See Also

hc

Examples

## Data
data(ecoli)
ecoli <- ecoli[,-1] ## Sequence Name

## DAG1
dag1 <- LearningHC(ecoli)
dag1
plot(dag1)

## DAG2
dag2 <- LearningHC(ecoli, numIntervals = 10)
dag2
plot(dag2)

Description

Learns a univariate MoTBF function using prior information.

Usage

learnMoTBFpriorInformation(
  priorData,
  data,
  s,
  POTENTIAL_TYPE,
  domain = range(data),
  coeffversion = 4,
  restrictDomain = TRUE,
  maxParam = NULL,
  returnAll = FALSE,
  scale = TRUE
)

Arguments

Value

If returnAll = TRUE, the function returns a list with the elements

See Also

getCoefficients

Examples

## Data
X <- rnorm(15)

## Prior Data
priordata <- rnorm(5000)

## Test data
test <- rnorm(1000)
testData <- test[test>=min(X)&test<=max(X)]

## Learning
type <- "MOP" 
confident <- 3 ## confident <- 1,2,...,length(X)
f <- learnMoTBFpriorInformation(priorData = priordata, data = X, s = confident,
POTENTIAL_TYPE = type, returnAll = TRUE)
attributes(f)

## Log-likelihood
sum(log(as.function(f$dataFunction)(testData)))
sum(log(as.function(f$posteriorFunction)(testData))) ## best loglikelihood

Description

Computes the marginal densities from a "jointmotbf" object.

Usage

marginal.jointmotbf(P, var)

Arguments

Value

If 'var' is an atomic vector, the marginal distribution of the variable specified in 'var' is computed from the joint distribution and the result is an object of class "univmotbf", i.e., a univariate distribution.

If 'var' contains more than one variable, the joint distribution over this subset is computed, i.e., the variables NOT contained in 'var' are marginalized out and the result is an object of class "jointmotbf".

See Also

jointmotbf.fit and eval.motbf

Examples

## 1. EXAMPLE 
## Dataset with 2 variables
data <- data.frame(x = rnorm(100), y = rnorm(100))

## Joint function
dim <- c(4,3)
P <- jointmotbf.fit(data, dimensions = dim)

## Marginal
marginal.jointmotbf(P, var = "x")
marginal.jointmotbf(P, var = 2)

##############################################################################
## MORE EXAMPLES #############################################################
##############################################################################

## Generate a dataset with 3 variables
data <- data.frame(x = rnorm(100), y = rnorm(100), z = rnorm(100))

## Joint function
dim <- c(2,2,3)
P <- jointmotbf.fit(data, dimensions = dim)

## Marginal
marginal.jointmotbf(P, var = "x")
marginal.jointmotbf(P, var = "y")
marginal.jointmotbf(P, var = c("x", "z"))

Description

Computes the marginal densities from a "jointmotbf" object. This function is deprecated; use "marginal.jointmotbf" instead.

Usage

marginalJointMoTBF(P, var)

Arguments

Value

The marginal of a "jointmotbf" function. The result is an object of class "motbf".

See Also

jointMoTBF and evalJointFunction

Description

These functions fit mixtures of polynomials (MOPs). Least square optimization is used to minimize the quadratic error between the empirical cumulative distribution and the estimated one.

Usage

mop.learning(X, nparam, domain)

bestMOP(X, domain, maxParam = NULL)

Arguments

Details

mop.learning(): The returned value $Function is the only visible element which contains the algebraic expression. Using attributes the name of the others elements are shown and also they can be extracted with $. The summary of the function also shows all these elements.

bestMOP(): The first returned value $bestPx contains the output of the mop.learning() function with the number of parameters which gets the best BIC values, taking into account the BIC score to penalize the functions. It evaluates the two next functions, if the BIC score does not improve then the function with the last best BIC is returned.

Value

mop.lerning() returns a list of n elements:

bestMOP() returns a list including the polynomial function with the best BIC score, the number of parameters and an array with the BIC values of the evaluated functions.

See Also

univMoTBF A complete function for learning MOPs which includes extra options.

Examples

## 1. EXAMPLE 
data <- rnorm(1000)

## MOP with fix number of degrees
fx <- mop.learning(data, nparam=7, domain=range(data))
fx
hist(data, prob=TRUE, main="")
plot(fx, col=2, xlim=range(data), add=TRUE)

## Best MOP in terms of BIC
fMOP <- bestMOP(data, domain=range(data))
attributes(fMOP)
fMOP$bestPx
hist(data, prob=TRUE, main="")
plot(fMOP$bestPx, col=2, xlim=range(data), add=TRUE)

## 2. EXAMPLE
data <- rbeta(4000, shape1=1/2, shape2=1/2)

## MOP with fix number of degrees 
fx <- mop.learning(data, nparam=6, domain=range(data))
fx
hist(data, prob=TRUE, main="")
plot(fx, col=2, xlim=range(data), add=TRUE)

## Best MOP in terms of BIC
fMOP <- bestMOP(data, domain=range(data), maxParam=6)
attributes(fMOP)
fMOP$bestPx
attributes(fMOP$bestPx)
hist(data, prob=TRUE, main="")
plot(fMOP$bestPx, col=2, xlim=range(data), add=TRUE)

Description

Perform a TAN model of class MoTBF based on maximizing the Mutual Information.

Usage

fit_tan(
  target,
  data,
  fit.args = NULL,
  root = NULL,
  all = FALSE,
  mutualInfoCond = NULL,
  parallel = FALSE
)

mutual_information_tan(data, target, fit.args = NULL, parallel = FALSE)

Arguments

Details

The main function, fit_tan(), fits a MoTBF Tree Augmented Naive Bayes model using the specified data.

Value

The main function, fit_tan(), returns an object of class "motbf_fit". When all=TRUE, it returns a list with the Bayesian network and the mutual information matrix used to compute the maximun spanning tree.

Function mutual_information_tan() returns a symmetric numeric matrix of dimensions $k \times k$, where $k$ is the number of predictor variables. Row and column names correspond to the predictor variables, and the entries contain the estimated conditional mutual information values. This matrix is used to compute the TAN model.

Examples

data = iris
data$Species = as.factor(data$Species)
# Fit TAN model for classification
tan = fit_tan("Species",data)

Description

This function checks whether the density functions of a MoTBF-BN are of type MTE or MOP.

Usage

motbf_type(bn)

Arguments

Value

A character string, specifying the subclass of MoTBF, i.e., either MTE or MOP.

Examples

## Dataset
  data("ecoli", package = "MoTBFs")
  data <- ecoli[,-c(1,9)]

## Get directed acyclic graph
  dag <- LearningHC(data)
  
## Learn bayesian network
  bn <- MoTBFs_Learning(dag, data = data, numIntervals = 4, POTENTIAL_TYPE = "MTE") 
  
## Get MoTBF sub-class
  motbf_type(bn)

Description

Random generation for mixtures of truncated basis functions defined in a specific domain. The inverse transform method is used.

Usage

rMoTBF(size, fx, domain = NULL)

inversionMethod(size, fx, domain = NULL, data = NULL)

Arguments

Value

rMoTBF() returns a "numeric" vector containing the simulated values. inversionMethod() returns a list with the simulated values and the results of the two-sample Kolmogorov-Smirnov test, as well as the plot of the CDFs of the original and simulated data.

Examples

## 1. EXAMPLE
## Data
X <- rnorm(1000, mean = 5, sd = 3)

## Learning
f <- univMoTBF(X, POTENTIAL_TYPE="MOP", nparam=10)
plot(f, xlim = f$Domain)

## Random sample
Y <- rMoTBF(size = 500, fx = f)
ks.test(X,Y)

## Plots
hist(Y, prob = TRUE, add = TRUE)


## 2. EXAMPLE 
## Data
X <- rweibull(5000, shape=2)

## Learning
f <- univMoTBF(X, POTENTIAL_TYPE="MOP", nparam=10)
plot(f, xlim = f$Domain)

## Random sample
inv <- inversionMethod(size = 500, fx = f, data = X)
attributes(inv)
inv$test
Y <- inv$sample 

## Plots
plot(f, xlim = f$Domain)
hist(Y, prob = TRUE, add = TRUE)

Description

Perform a k-fold cross validation for Bayesian networks of class MoTBF.

Usage

motbf.cv(
  data,
  dag,
  loss,
  k = 10,
  target = NULL,
  seed = NULL,
  fit.args = NULL,
  loss.args = NULL,
  foldsIndex = NULL,
  ...
)

Arguments

Details

If the basis function is MTE, the loss function is the log-likelihood of the model. On the other hand, if the basis function if MOP, the loss function might be either the predictive error ('pred') or the the log-likelihood of the model ('logl').

Details on the loss argument:

'logl'

The log-likelihood of the model is computed. This measure is available for both basis functions, MTE and MOP.

'pred'

This option is only available for MOPs. The predictive error (root mean squared error) or classification accuracy is computed as the loss function, depending on the nature of the target variable (continuous or discrete, respectively). The program will guess which type the target variable is and compute the corresponding measure.

Details on the loss.args argument. Currently, two arguments can be specified within this list:

'p.test'

Only used if k = 1. This argument specifies the proportion of the data set that goes to the test set (between 0 and 1).

'loss.matrix'

A squared matrix used to compute a weighted classification accuracy for discrete targets. This matrix is multiplied by the confusion matrix element by element, and the resulting matrix is used to compute the classification accuracy. The loss matrix allows to increase the penalty of some user-specified errors. If the loss matrix provided is a constant matrix of ones, the result is the standard classification accuracy. Note that the diagonal of the loss matrix is regarded as a reward, while the off-diagonal is regarded as a cost.

Value

An object of class "motbf.fit.cv". This is a list of "k" elements, each of them containing the results of each fold. More specifically, each element contains:

test

a "data.frame" of the subset used to fit the model.

fitted

an object of class "motbf.fit", i.e., the model fitted.

loss

the loss value computed for the fold. If "pred" is chosen for the argument "loss", then each element of the "motbf.fit.cv" object also contains:

predicted

a vector of predictions for the target variable.

observed

a vector of observed records of the target variable.

Examples

#################
### EXAMPLE 1 ###
#################
## Perform 2-fold cross validation using the default model arguments
## and the log-likelihood as loss function

# Load data
data(ecoli)
ecoli <- ecoli[,-c(1,9)]

# Learn DAG
dag <- LearningHC(ecoli)

# Run cross validation
cv = motbf.cv(data = ecoli, dag, k = 2, loss = 'logl')
cv


#################
### EXAMPLE 2 ###
#################
## Choose different arguments to fit the model parameters
fit.args = list(numIntervals = 3, POTENTIAL_TYPE = 'MOP', maxParam = 4)

# Run cross validation using the classification accuracy as loss function
cv = motbf.cv(data = ecoli, dag, k = 2, loss = 'pred', target = 'lip', 
  fit.args = fit.args)
cv
summary(cv)

#################
### EXAMPLE 3 ###
#################

## Specify a loss matrix to increase the penalty of classification errors
lossFunctionMatrix = matrix(c(c(1,2), c(3, 1)),nrow = 2, ncol = 2, byrow = TRUE)

# Run cross validation using the weighted classification accuracy as loss function
cv = motbf.cv(data = ecoli, dag, k = 2, loss = 'pred', target = 'lip', 
  loss.args = list(loss.matrix = lossFunctionMatrix))
cv
summary(cv)
  
#################
### EXAMPLE 4 ###
#################

# Run cross validation using the root mean squared error as loss function
cv = motbf.cv(data = ecoli, dag, k = 2, loss = 'pred', target = 'mcg')
cv

Description

Learn mixtures of truncated basis functions in a full hybrid network.

Usage

motbf.fit(
  graph,
  data,
  numIntervals = 4,
  POTENTIAL_TYPE = "MOP",
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = TRUE
)

MoTBFs_Learning(
  graph,
  data,
  numIntervals = 4,
  POTENTIAL_TYPE = "MOP",
  maxParam = NULL,
  s = NULL,
  priorData = NULL,
  scale = TRUE
)

Arguments

Details

If the variable is discrete then it computes the probabilities and the size of each leaf. Children that have discrete parents have as many functions as configurations of the parents. Children that have continuous parents have as many functions as the number indicated in the argument "numIntervals" for each parent. Children that have mixed parents, combine both methods. The BIC criterion is used to decide the number of splitting points of the parent domains and to choose the number of basis functions used.

Value

A list of lists. Each list contains two elements

Examples

## Dataset Ecoli
require(MoTBFs)
data(ecoli)
data <- ecoli[,-c(1)] ## remove variable sequence

## Directed acyclic graph
dag <- LearningHC(data)

## Learning BN
intervals <- 3
potential <- "MOP"
bn1 <- motbf.fit(graph = dag, data = data, numIntervals = intervals, 
POTENTIAL_TYPE = potential, maxParam = 5)
bn1

## Learning BN
intervals <- 4
potential <- "MTE"
bn2 <- motbf.fit(graph = dag, data = data, numIntervals = intervals, 
POTENTIAL_TYPE = potential, maxParam = 15)
bn2

Description

Export a discrete BN created with motbf.fit to an object of class "bn" of package bnlearn.

Usage

motbf2bnlearn(bn)

Arguments

Value

An object of class bn.

Description

Export a discrete BN created with motbf.fit to an object of class "grain" of package gRain

Usage

motbf2grain(bn)

Arguments

Value

An object of class grain.

Description

These functions fit mixtures of truncated exponentials (MTEs). Least square optimization is used to minimize the quadratic error between the empirical cumulative distribution function and the estimated one.

Usage

mte.learning(X, nparam, domain)

bestMTE(X, domain, maxParam = NULL)

Arguments

Details

mte.learning(): The returned value $Function is the only visible element which contains the algebraic expression. Using attributes the name of the others elements are shown and also they can be abstract with $. The summary of the function also shows all this elements.

bestMTE(): The first returned value $bestPx contains the output of the mte.learning() function with the number of parameters which gets the best BIC value, taking into account the Bayesian information criterion (BIC) to penalize the functions. It evaluates the two next functions, if the BIC doesn't improve then the function with the last best BIC is returned.

Value

mte.lerning() returns a list of n elements:

bestMTE() returns a list including the MTE function with the best BIC score, the number of parameters, the best BIC value and an array contained the BIC values of the evaluated functions.

See Also

univMoTBF A complete function for learning MoTBFs which includes extra options.

Examples

## 1. EXAMPLE
data <- rchisq(1000, df=3)

## MTE with fix number of parameters
fx <- mte.learning(data, nparam=7, domain=range(data))
hist(data, prob=TRUE, main="")
plot(fx, col=2, xlim=range(data), add=TRUE)

## Best MTE in terms of BIC
fMTE <- bestMTE(data, domain=range(data))
attributes(fMTE)
fMTE$bestPx
hist(data, prob=TRUE, main="")
plot(fMTE$bestPx, col=2, xlim=range(data), add=TRUE)

## 2. EXAMPLE
data <- rexp(1000, rate=1/3)

 ## MTE with fix number of parameters
fx <- mte.learning(data, nparam=8, domain=range(data))
## Message: The nearest function with odd number of coefficients 
hist(data, prob=TRUE, main="")
plot(fx, col=2, xlim=range(data), add=TRUE)

## Best MTE in terms of BIC
fMTE <- bestMTE(data, domain=range(data), maxParam=10)
attributes(fMTE)
fMTE$bestPx
attributes(fMTE$bestPx)
hist(data, prob=TRUE, main="")
plot(fMTE$bestPx, col=2, xlim=range(data), add=TRUE)

Description

Computes the new domain of two datasets.

Usage

newRangePriorData(fPI, priorData, N, domain, s, POTENTIAL_TYPE)

Arguments

Value

A "numeric" array which contains the new domain of the prior function.

Examples

## Data
X <- rnorm(15)

## Prior Data
priordata <- rnorm(5000)

## Learning
type = "MTE" 
fPrior <- univMoTBF(priordata, POTENTIAL_TYPE = type)

## New range
confident <- 5 ## confident <- 1,2,...,length(X)
domain <- range(X)
N <- length(X)
newRange <- newRangePriorData(fPrior, priorData = priordata, N = N,
domain = domain, s = confident, POTENTIAL_TYPE = type)
newRange

Description

Compute the number of variables which are in a jointmotbf object. This function is deprecated; use "getMotbfVar" instead.

Usage

nVariables(P)

Arguments

Value

A "character" vector with the names of the variables in the function.

Description

Draws an 'motbf' function.

Usage

## S3 method for class 'motbf'
plot(x, ...)

## S3 method for class 'univmotbf'
plot(x, xlim = NULL, ylim = NULL, type = "l", add = FALSE, ...)

## S3 method for class 'piecewisemop'
plot(x, xlim = NULL, ylim = NULL, ...)

## S3 method for class 'motbf.fit.node'
plot(x, panels = TRUE, ...)

## S3 method for class 'jointmotbf'
plot(
  x,
  type = "contour",
  ranges = NULL,
  orientation = c(5, -30),
  data = NULL,
  filled = TRUE,
  ticktype = "simple",
  main = NULL,
  ...
)

Arguments

Value

A plot of the specificated function.

Examples

## 1. univmotbf - Example for univariate distributions 
## Data
X <- rexp(2000)

f1 <- univMoTBF(X, POTENTIAL_TYPE = "MOP")
f2 <- univMoTBF(X, POTENTIAL_TYPE = "MTE", maxParam = 10)

## Plots
plot(NULL, xlim = range(X), ylim = c(0,0.8), xlab="X", ylab="density")
plot(f1, xlim = range(X), col = 1, add = TRUE)
plot(f2, xlim = range(X), col = 2, add = TRUE)


## 2. jointmotbf - Example for join distributions 
## Data
X <- data.frame(rnorm(500), rnorm(500))

## Joint function
dim <- c(3,3) 
P <- jointmotbf.fit(X, dimensions = dim)

## Plots
plot(P)
plot(P, type = "perspective", orientation = c(90,0))

Description

Plot conditional MoTBF densities.

Usage

plotConditional(
  conditionalFunction,
  data,
  nameChild = NULL,
  points = FALSE,
  color = NULL,
  ...
)

Arguments

Details

If the number of parents is greater than one, then the error message "It is not possible to plot the conditional function." is reported.

Value

A plot of the conditional density function.

See Also

conditionalMethod

Examples

## Data
X <- rnorm(1000)
Y <- rnorm(1000, mean=X)
data <- data.frame(X=X,Y=Y)
cov(data)

## Conditional Learning
parent <- "X"
child <- "Y"
intervals <- 5
potential <- "MTE"
P <- conditionalMethod(data, nameParents=parent, nameChild=child, 
numIntervals=intervals, POTENTIAL_TYPE=potential)
plotConditional(conditionalFunction=P, data=data)
plotConditional(conditionalFunction=P, data=data, points=TRUE)

Description

Predict from an MoTBF Bayesian Network

Usage

## S3 method for class 'motbf_fit'
predict(
  object,
  target,
  data,
  method = NULL,
  prob = FALSE,
  parallel = FALSE,
  ...
)

Arguments

Description

Delete rows of a dataset which contains anomalous values.

Usage

preprocessedData(data, strangeElements)

Arguments

Description

Print object of class motbf print method for class "motbf".

Print a single node of a BN. This function is called by print.motbf_fit, but not exported.

Print the results of a k-fold cross validation

Usage

## S3 method for class 'motbf'
print(x, ...)

## S3 method for class 'motbf_fit'
print(x, ...)

## S3 method for class 'motbf.fit.node'
print(x, ...)

## S3 method for class 'motbf_fit_cv'
print(x, ...)

## S3 method for class 'univmotbf'
print(x, ...)

## S3 method for class 'piecewisemop'
print(x, ...)

## S3 method for class 'jointmotbf'
print(x, ...)

Arguments

Details

The following classes are created in the MoTBFs package:

motbf

the generic class common to all objects created in the package

univmotbf

the class corresponding to MTE or MOP univariate distributions. An object of class univmotbf is the output of function univMoTBF().

piecewisemop

the class corresponding to MOP univariate distributions defined by multiple sub-functions with different domain. When calling variableElimination(), the output might be of this class.

jointmotbf

the class corresponding to joint distributions. An object of class jointmotbf is the output of function jointMOP()

motbf_fit

the class corresponding to fully fitted Bayesian network models (either discrete, continuous or hybrid). An object of class motbf_fit is the output of function motbf.fit().

motbf.fit.cv

the class corresponding to k-fold cross validation results. An object of class motbf.fit.cv is the output of function motbf.cv().

motbf.fit.node

the class corresponding to a single node of a Bayesian Network.

Examples

## Dataset Ecoli
data(ecoli)
data <- ecoli[,-c(1)] ## remove variable sequence

## Directed acyclic graph
dag <- LearningHC(data)

## Learning BN
P <- motbf.fit(graph = dag, data = data, numIntervals = 3, POTENTIAL_TYPE = "MOP",
maxParam = 15)
P

Description

Print the description of an MoTBF demnsity for one variable conditional on another variable.

Usage

printConditional(conditionalFunction)

Arguments

Value

The results of the conditional function are shown.

See Also

conditionalMethod

Examples

## Data
X <- rexp(500)
Y <- rnorm(500, mean=X)
data <- data.frame(X=X,Y=Y)
cov(data)

## Conditional Learning
parent <- "X"
child <- "Y"
intervals <- 5
potential <- "MOP"
P <- conditionalMethod(data, nameParents=parent, nameChild=child, 
numIntervals=intervals, POTENTIAL_TYPE=potential)
printConditional(P)

Description

Compute the probabilities of a discrete variable from a data set using Laplace correction.

Usage

probDiscreteVariable(x)

Arguments

Details

Laplace correction is used to avoid the zero probability problem, with $\alpha = 1$ as smoothing factor. Therefore, the probability for each state, $\theta_i$, is computed as

$\theta_i = \frac{x_i + 1}{N + K}$

for $i = 0, 1, \ldots, K$, where $x_i$ is the number of records of state $i$, $N$ is the total number of records, and $K$ is the total number of states.

Value

A list of 2 elements:

See Also

discreteVariablesStates

Examples

## Simulate discrete variable
x <- factor(sample(c('yes', 'no', 'maybe'), 500, replace = TRUE), 
  levels = c('yes', 'no', 'maybe'))
 
## Compute probabilities
p <- probDiscreteVariable(x)
p

Description

Compute conditional probability queries from a sample.

Usage

query(sample, event, evidence)

Arguments

Value

The conditional probability: P(event|evidence).

Examples

data("ecoli", package = "MoTBFs")
  dat <- ecoli[,-c(1,4,5,9)]
  
  # Build DAG
  dag <- LearningHC(dat)
  
  # Learn BN parameters
  bn = motbf.fit(dag, dat)
 
 # Get sample from bn
 sam = sample_motbfs(bn, 50)
 
 # Compute P(mcg > 0.6 | aac < 0.8 & alm2 < 0.3)
 query(sam, event = (mcg >0.6), evidence = (aac<0.8 & alm2 <0.3))

Description

The function r.data.frame() initializes a data frame with as many columns as nodes in the MoTBF-network. It also asings each column its data type, i.e., numeric or character. In the case of character columns, the states of the variable are extracted from the "bn" argument and included as levels.

Usage

r.data.frame(bn)

Arguments

Value

An object of class "data.frame", which contains the data type of each column and has no rows.

Examples

## Create a dataset
  # Continuous variables
  x <- rnorm(100)
  y <- rnorm(100)
  
  # Discrete variable
  z <- sample(letters[1:2],size = 100, replace = TRUE)
  
  data <- data.frame(C1 = x, C2 = y, D1 = z, stringsAsFactors = FALSE)
  
## Get DAG
  dag <- LearningHC(data)
  
## Learn a BN
  bn <- motbf.fit(dag, data, POTENTIAL_TYPE = "MTE")
  
## Initialize a data.frame containing 3 columns (x, y and z) with their attributes.
  r.data.frame(bn)

Description

Standardize the numeric columns of a data.frame.

Usage

rescale_data(data, v_mean = NULL, v_sd = NULL)

Arguments

Value

A data.frame with scaled data. Non-numeric columns are also returned in their original position.

Description

A collection of function to reescale an MoTBF function to the original offset and scale. This is useful when data was standardized previously to learning.

Usage

rescaledMoTBFs(fx, data = NULL)

rescaledMOP(fx, data = NULL)

rescaledMTE(fx, data)

ToStringRe_MTE(parameters, data, num = 1)

meanMOP(fx)

rescale_motbf_fit(object, POTENTIAL_TYPE, data)

Arguments

Value

An "motbf" function of the original data.

See Also

univMoTBF

Examples

## 1. EXAMPLE
X <- rchisq(1000, df = 8) ## data
modX <- scale(X) ## scale data

## Learning
f <- univMoTBF(modX, POTENTIAL_TYPE = "MOP", nparam=10) 
plot(f, xlim = range(modX), col=2)
hist(modX, prob = TRUE, add = TRUE)

## Rescale
origF <- rescaledMoTBFs(f, X) 
plot(origF, xlim = range(X), col=2)
hist(X, prob = TRUE, add = TRUE)
expectedValueMOP(origF) 
mean(X)

## 2. EXAMPLE 
X <- rweibull(1000, shape = 20, scale= 10) ## data
modX <- as.numeric(scale(X)) ## scale data

## Learning
f <- univMoTBF(modX, POTENTIAL_TYPE = "MTE", nparam = 9) 
plot(f, xlim = range(modX), col=2, main="")
hist(modX, prob = TRUE, add = TRUE)

## Rescale
origF <- rescaledMoTBFs(f, X) 
plot(origF, xlim = range(X), col=2)
hist(X, prob = TRUE, add = TRUE)
expectedValueMTE(origF)
mean(X)

Description

Generate a multivariate normal data vector taking into account the real data and the relationships with other variables in the dataset.

Usage

rnormMultiv(n, dataParents, dataChild)

Arguments

Value

A "numeric" vector giving the prior data values.

See Also

generateNormalPriorData

Examples

## Data
data(ecoli)
data <- ecoli[,-c(1,9)] ## remove sequece.name and class

## DAG
dag <- LearningHC(data)
plot(dag)
getChildParentsFromGraph(dag)

## 1. Random sample
parents <- "mcg"
child <- "alm1"
n <- 1000
rnormMultiv(n, dataParents = data.frame(data[,parents]), dataChild = data[,child])

## 2. Random sample
parents <- "alm1"
child <- "aac"
n <- 256
rnormMultiv(n, dataParents = data.frame(data[,parents]), dataChild = data[,child])

Description

This function generates a sample from an MoTBF Bayesian network.

Usage

sample_motbfs(bn, n, parallel = FALSE, evidence = NULL)

Arguments

Value

A data.frame containing the generated sample. Is evidence is not NULL, attribute 'w' contains the weight of each sample.

Examples

data("ecoli", package = "MoTBFs")
  dat <- ecoli[,-c(1,4,5,9)]
  
  # Build DAG
  dag <- LearningHC(dat)
  
  # Learn BN parameters
  bn = motbf.fit(dag, dat)
 
 # Get sample from bn
 sam = sample_motbfs(bn, 50)