Description Usage Arguments Details Value Warnings Note Author(s) References See Also Examples
Fits Carroll and Chang's Individual Differences Scaling (INDSCAL) model to 3way dissimilarity or similarity data. Parameters are estimated via alternating least squares with optional constraints.
1 2 3 4 5 6  indscal(X, nfac, nstart = 10, const = NULL, control = NULL,
type = c("dissimilarity", "similarity"),
Bfixed = NULL, Bstart = NULL, Bstruc = NULL, Bmodes = NULL,
Cfixed = NULL, Cstart = NULL, Cstruc = NULL, Cmodes = NULL,
maxit = 500, ctol = 1e4, parallel = FALSE, cl = NULL,
output = c("best", "all"), verbose = TRUE, backfit = FALSE)

X 
Threeway data array with 
nfac 
Number of factors. 
nstart 
Number of random starts. 
const 
Character vector of length 2 giving the constraints for modes B and C (defaults to unconstrained for B and nonnegative for C). See 
control 
List of parameters controlling options for smoothness constraints. This is passed to 
type 
Character indicating if 
Bfixed 
Used to fit model with fixed Mode B weights. 
Bstart 
Starting Mode B weights. Default uses random weights. 
Bstruc 
Structure constraints for Mode B weights. See Note. 
Bmodes 
Mode ranges for Mode B weights (for unimodality constraints). See Note. 
Cfixed 
Used to fit model with fixed Mode C weights. 
Cstart 
Starting Mode C weights. Default uses random weights. 
Cstruc 
Structure constraints for Mode C weights. See Note. 
Cmodes 
Mode ranges for Mode C weights (for unimodality constraints). See Note. 
maxit 
Maximum number of iterations. 
ctol 
Convergence tolerance. 
parallel 
Logical indicating if 
cl 
Cluster created by 
output 
Output the best solution (default) or output all 
verbose 
If 
backfit 
Should backfitting algorithm be used for 
Given a 3way array X = array(x,dim=c(J,J,K))
with X[,,k]
denoting the k
th subject's dissimilarity matrix rating J
objects, the INDSCAL model can be written as
Z[i,j,k] = sum B[i,r]*B[j,r]*C[k,r] + E[i,j,k]

where Z
is the array of scalar products obtained from X
, B = matrix(b,J,R)
are the object weights, C = matrix(c,K,R)
are the nonnegative subject weights, and E = array(e,dim=c(J,J,K))
is the 3way residual array. The summation is for r = seq(1,R)
.
Weight matrices are estimated using an alternating least squares algorithm with optional constraints.
If output="best"
, returns an object of class "indscal"
with the following elements:
B 
Mode B weight matrix. 
C 
Mode C weight matrix. 
SSE 
Sum of Squared Errors. 
Rsq 
Rsquared value. 
GCV 
Generalized CrossValidation. 
edf 
Effective degrees of freedom. 
iter 
Number of iterations. 
cflag 
Convergence flag. See Note. 
const 
See argument 
control 
See argument 
fixed 
Logical vector indicating whether 'fixed' weights were used for each mode. 
struc 
Logical vector indicating whether 'struc' constraints were used for each mode. 
Otherwise returns a list of length nstart
where each element is an object of class "indscal"
.
The algorithm can perform poorly if the number of factors nfac
is set too large.
Structure constraints should be specified with a matrix of logicals (TRUE/FALSE), such that FALSE elements indicate a weight should be constrained to be zero. Default uses unstructured weights, i.e., a matrix of all TRUE values.
When using unimodal constraints, the *modes
inputs can be used to specify the mode search range for each factor. These inputs should be matrices with dimension c(2,nfac)
where the first row gives the minimum mode value and the second row gives the maximum mode value (with respect to the indicies of the given corresponding matrix).
Output cflag
gives convergence information: cflag = 0
if algorithm converged normally, cflag = 1
if maximum iteration limit was reached before convergence, and cflag = 2
if algorithm terminated abnormally due to a problem with the constraints.
Nathaniel E. Helwig <[email protected]>
Carroll, J. D., & Chang, JJ. (1970). Analysis of individual differences in multidimensional scaling via an nway generalization of "EckartYoung" decomposition. Psychometrika, 35, 283319.
The fitted.indscal
function creates the modelimplied fitted values from a fit "indscal"
object.
The resign.indscal
function can be used to resign factors from a fit "indscal"
object.
The rescale.indscal
function can be used to rescale factors from a fit "indscal"
object.
The reorder.indscal
function can be used to reorder factors from a fit "indscal"
object.
The cmls
function (from CMLS package) is called as a part of the alternating least squares algorithm.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88  ########## array example ##########
# create random data array with INDSCAL structure
set.seed(3)
mydim < c(50,5,10)
nf < 2
X < array(0, dim = c(rep(mydim[2],2), mydim[3]))
for(k in 1:mydim[3]) {
X[,,k] < as.matrix(dist(t(matrix(rnorm(prod(mydim[1:2])), mydim[1], mydim[2]))))
}
# fit INDSCAL model
imod < indscal(X, nfac = nf, nstart = 1)
imod
# check solution
Xhat < fitted(imod)
sum((array(apply(X,3,ed2sp), dim = dim(X))  Xhat)^2)
imod$SSE
# reorder and resign factors
imod$B[1:4,]
imod < reorder(imod, 2:1)
imod$B[1:4,]
imod < resign(imod, newsign = c(1,1))
imod$B[1:4,]
sum((array(apply(X,3,ed2sp), dim = dim(X))  Xhat)^2)
imod$SSE
# rescale factors
colSums(imod$B^2)
colSums(imod$C^2)
imod < rescale(imod, mode = "C")
colSums(imod$B^2)
colSums(imod$C^2)
sum((array(apply(X,3,ed2sp), dim = dim(X))  Xhat)^2)
imod$SSE
########## list example ##########
# create random data array with INDSCAL structure
set.seed(4)
mydim < c(100, 8, 20)
nf < 3
X < vector("list", mydim[3])
for(k in 1:mydim[3]) {
X[[k]] < dist(t(matrix(rnorm(prod(mydim[1:2])), mydim[1], mydim[2])))
}
# fit INDSCAL model (orthogonal B, nonnegative C)
imod < indscal(X, nfac = nf, nstart = 1, const = c("orthog", "nonneg"))
imod
# check solution
Xhat < fitted(imod)
sum((array(unlist(lapply(X,ed2sp)), dim = mydim[c(2,2,3)])  Xhat)^2)
imod$SSE
crossprod(imod$B)
## Not run:
########## parallel computation ##########
# create random data array with INDSCAL structure
set.seed(3)
mydim < c(50,5,10)
nf < 2
X < array(0,dim=c(rep(mydim[2],2), mydim[3]))
for(k in 1:mydim[3]) {
X[,,k] < as.matrix(dist(t(matrix(rnorm(prod(mydim[1:2])), mydim[1], mydim[2]))))
}
# fit INDSCAL model (10 random starts  sequential computation)
set.seed(1)
system.time({imod < indscal(X, nfac = nf)})
imod
# fit INDSCAL model (10 random starts  parallel computation)
cl < makeCluster(detectCores())
ce < clusterEvalQ(cl,library(multiway))
clusterSetRNGStream(cl, 1)
system.time({imod < indscal(X, nfac = nf, parallel = TRUE, cl = cl)})
imod
stopCluster(cl)
## End(Not run)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.