matrixpls (version 0.4.0)

weight.optim: Optimized weights

Description

Calculates a set of weights to minimize an optimization criterion

Usage

weight.optim(S, model, W.mod, parameterEstimator = params.regression,
  optimCriterion = optim.maximizeInnerR2, method = "BFGS", ...,
  validateInput = TRUE, standardize = TRUE)

Arguments

S

Covariance matrix of the data.

model

There are two options for this argument: 1. lavaan script or lavaan parameter table, or 2. a list containing three matrices inner, reflective, and formative defining the free regression paths in the model.

W.mod

An optional numeric matrix representing the weight patter and starting weights (i.e. the how the indicators are combined to form the composite variables). If this argument is not specified, the weight patter is defined based on the relationships in the

parameterEstimator

A function that takes three or more arguments, the data covariance matrix S, model specification model, and weights W and returns a named vector of parameter estimates. The default is

optimCriterion

A function that taking an object of class class matrixpls and returning a scalar. The default is optim.maximizeInnerR2

method

The minimization algorithm to be used. See optim for details. Default is "BFGS".

...

All other arguments are passed through to optim and parameterEstimator.

validateInput

A boolean indicating whether the arguments should be validated.

standardize

TRUE (default) or FALSE indicating whether S should be converted to a correlation matrix.

Value

• An object of class "matrixplsweights", which is a matrix containing the weights with the following attributes:
• iterations
  Number of iterations performed
• converged
  A boolean indicating if the algorithm converged
• history
  A data.frame containing the weights for each iteration

Details

weight.optim calculates indicator weights by optimizing the indicator weights against the criterion function using optim. The algoritmh works by first estimating the model with the starting weights. The resulting matrixpls object is passed to the optimCriterion function, which evaluates the optimization criterion for the weights. The weights are adjusted and new estimates are calculated until the optimization criterion converges.

Model can be specified in the lavaan format or the native matrixpls format. The native model format is a list of three binary matrices, inner, reflective, and formative specifying the free parameters of a model: inner (l x l) specifies the regressions between composites, reflective (k x l) specifies the regressions of observed data on composites, and formative (l x k) specifies the regressions of composites on the observed data. Here k is the number of observed variables and l is the number of composites.

If the model is specified in lavaan format, the native format model is derived from this model by assigning all regressions between latent variables to inner, all factor loadings to reflective, and all regressions of latent variables on observed variables to formative. Regressions between observed variables and all free covariances are ignored. All parameters that are specified in the model will be treated as free parameters. If model is specified in lavaan syntax, the model that is passed to the parameterEstimator will be that model and not the native format model.

The original papers about Partial Least Squares, as well as many of the current PLS implementations, impose restrictions on the matrices inner, reflective, and formative: inner must be a lower triangular matrix, reflective must have exactly one non-zero value on each row and must have at least one non-zero value on each column, and formative must only contain zeros. Some PLS implementations allow formative to contain non-zero values, but impose a restriction that the sum of reflective and t(formative) must satisfy the original restrictions of reflective. The only restrictions that matrixpls imposes on inner, reflective, and formative is that these must be binary matrices and that the diagonal of inner must be zeros.

The argument W.mod is a (l x k) matrix that indicates how the indicators are combined to form the composites. The original papers about Partial Least Squares as well as all current PLS implementations define this as t(reflective) | formative, which means that the weight patter must match the model specified in reflective and formative. Matrixpls does not require that W.mod needs to match reflective and formative, but accepts any numeric matrix. If this argument is not specified, W.mod is defined as t(reflective) | formative.

See Also

Optimization criteria: optim.maximizeInnerR2

Other Weight algorithms: weight.fixed; weight.pls

Examples

library(plspm)

# Run the customer satisfaction examle form plspm

# load dataset satisfaction
data(satisfaction)
# inner model matrix
IMAG = c(0,0,0,0,0,0)
EXPE = c(1,0,0,0,0,0)
QUAL = c(0,1,0,0,0,0)
VAL = c(0,1,1,0,0,0)
SAT = c(1,1,1,1,0,0)
LOY = c(1,0,0,0,1,0)
inner = rbind(IMAG, EXPE, QUAL, VAL, SAT, LOY)
colnames(inner) <- rownames(inner)

# Reflective model
list(1:5, 6:10, 11:15, 16:19, 20:23, 24:27)

reflective<- matrix(
  c(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1),
  27,6, dimnames = list(colnames(satisfaction)[1:27],colnames(inner)))

# empty formative model

formative <- matrix(0, 6, 27, dimnames = list(colnames(inner), colnames(satisfaction)[1:27]))

# Estimation using covariance matrix
model <- list(inner = inner,
              reflective = reflective,
              formative = formative)

S <- cov(satisfaction[,1:27])

matrixpls.ModeA <- matrixpls(S, model)
matrixpls.ModeB <- matrixpls(S, model, outerEstimators = outer.modeB)
matrixpls.MaxR2 <- matrixpls(S, model, weightFunction = weight.optim)

# Compare the R2s from the different estimations

R2s <- cbind(R2(matrixpls.ModeA), R2(matrixpls.ModeB), R2(matrixpls.MaxR2))
print(R2s)
apply(R2s,2,mean)