NAG Library Function Document

nag_binary_factor (g11sac)

nag_binary_factor (g11sac) fits a latent variable model (with a single factor) to data consisting of a set of measurements on individuals in the form of binary-valued sequences (generally referred to as score patterns). Various measures of goodness-of-fit are calculated along with the factor (theta) scores.

2 Specification

#include <nag.h>

#include <nagg11.h>

void

nag_binary_factor (Nag_OrderType order, Integer p, Integer n, Nag_Boolean gprob, Integer ns, Nag_Boolean x[], Integer pdx, Integer irl[], double a[], double c[], Integer iprint, const char *outfile, double cgetol, Integer maxit, Nag_Boolean chisqr, Integer *niter, double alpha[], double pigam[], double cm[], Integer pdcm, double g[], double expp[], Integer pde, double obs[], double exf[], double y[], Integer iob[], double *rlogl, double *chi, Integer *idf, double *siglev, NagError *fail)

3 Description

Given a set of

p

dichotomous variables

\tilde{x} = {(x_{1}, x_{2}, \dots, x_{p})}^{'}

, where

^{'}

denotes vector or matrix transpose, the objective is to investigate whether the association between them can be adequately explained by a latent variable model of the form (see Bartholomew (1980) and Bartholomew (1987))

G \{π_{i} (θ)\} = α_{i 0} + α_{i 1} θ .

(1)

The

x_{i}

are called item responses and take the value

0

1

θ

denotes the latent variable assumed to have a standard Normal distribution over a population of individuals to be tested on

p

items. Call

π_{i} (θ) = P (x_{i} = 1 ∣ θ)

the item response function: it represents the probability that an individual with latent ability

θ

will produce a positive response (1) to item

i

α_{i 0}

and

α_{i 1}

are item parameters which can assume any real values. The set of parameters,

α_{i 1}

, for

i = 1, 2, \dots, p

, being coefficients of the unobserved variable

θ

, can be interpreted as ‘factor loadings’.

G

is a function selected by you as either

Φ^{- 1}

or logit, mapping the interval

(0, 1)

onto the whole real line. Data from a random sample of

n

individuals takes the form of the matrices

X

and

R

defined below:

X_{s \times p} = [\begin{array}{l} x_{11}^{} & x_{12} & \dots & x_{1 p} \\ x_{21} & x_{22} & \dots & x_{2 p} \\ ⋮ & ⋮ & ⋮ \\ x_{s 1} & x_{s 2} & \dots & x_{s p} \end{array}] = [\begin{array}{l} {\tilde{x}}_{1} \\ {\tilde{x}}_{2} \\ ⋮ \\ {\tilde{x}}_{s} \end{array}], R_{s \times 1} = [\begin{array}{l} r_{1}^{} \\ r_{2} \\ ⋮ \\ r_{s} \end{array}]

where

{\tilde{x}}_{l} = (x_{l 1}, x_{l 2}, \dots, x_{l p})

denotes the

l

th score pattern in the sample,

r_{l}

the frequency with which

{\tilde{x}}_{l}

occurs and

s

the number of different score patterns observed. (Thus

\sum_{l = 1}^{s} r_{l} = n

). It can be shown that the log-likelihood function is proportional to

\sum_{l = 1}^{s} r_{l} \log P_{l},

where

P_{l} = P (\tilde{x} = {\tilde{x}}_{l}) = \int_{- \infty}^{\infty} P (\tilde{x} = {\tilde{x}}_{l} ∣ θ) ϕ (θ) d θ

(2)

(

ϕ (θ)

being the probability density function of a standard Normal random variable).

P_{l}

denotes the unconditional probability of observing score pattern

{\tilde{x}}_{l}

. The integral in (2) is approximated using Gauss–Hermite quadrature. If we take

G (z) = logit z = \log (\frac{z}{1 - z})

in (1) and reparameterise as follows,

\begin{array}{lcl} α_{i} & = & α_{i 1}, \\ π_{i} & = & {logit}^{- 1} α_{i 0}, \end{array}

then (1) reduces to the logit model (see Bartholomew (1980))

π_{i} (θ) = \frac{π_{i}}{π_{i} + (1 - π_{i}) \exp (- α_{i} θ)} .

If we take

G (z) = Φ^{- 1} (z)

(where

Φ

is the cumulative distribution function of a standard Normal random variable) and reparameterise as follows,

\begin{array}{lcl} α_{i} & = & \frac{α_{i 1}}{\sqrt{(1 + α_{i 1}^{2})}} \\ γ_{i} & = & \frac{- α_{i 0}}{\sqrt{(1 + α_{i 1}^{2})}} \end{array},

then (1) reduces to the probit model (see Bock and Aitkin (1981))

π_{i} (θ) = ϕ (\frac{α_{i} θ - γ_{i}}{\sqrt{(1 - α_{i}^{2})}}) .

An E-M algorithm (see Bock and Aitkin (1981)) is used to maximize the log-likelihood function. The number of quadrature points used is set initially to

10

and once convergence is attained increased to

20

The theta score of an individual responding in score pattern

{\tilde{x}}_{l}

is computed as the posterior mean, i.e.,

E (θ ∣ {\tilde{x}}_{l})

. For the logit model the component score

X_{l} = \sum_{j = 1}^{p} α_{j} x_{l j}

is also calculated. (Note that in calculating the theta scores and measures of goodness-of-fit nag_binary_factor (g11sac) automatically reverses the coding on item

j

α_{j} < 0

; it is assumed in the model that a response at the one level is showing a higher measure of latent ability than a response at the zero level.)

The frequency distribution of score patterns is required as input data. If your data is in the form of individual score patterns (uncounted), then nag_binary_factor_service (g11sbc) may be used to calculate the frequency distribution.

4 References

Bartholomew D J (1980) Factor analysis for categorical data (with Discussion) J. Roy. Statist. Soc. Ser. B 42 293–321

Bartholomew D J (1987) Latent Variable Models and Factor Analysis Griffin

Bock R D and Aitkin M (1981) Marginal maximum likelihood estimation of item parameters: Application of an E-M algorithm Psychometrika 46 443–459

5 Arguments

1: $order$ – Nag_OrderTypeInput

On entry: the order argument specifies the two-dimensional storage scheme being used, i.e., row-major ordering or column-major ordering. C language defined storage is specified by

order = Nag_RowMajor

. See Section 3.2.1.3 in the Essential Introduction for a more detailed explanation of the use of this argument.

Constraint:

order = Nag_RowMajor

Nag_ColMajor

2: $p$ – IntegerInput

On entry:

p

, the number of dichotomous variables.

Constraint:

p \geq 3

3: $n$ – IntegerInput

On entry:

n

, the number of individuals in the sample.

Constraint:

n \geq 7

4: $gprob$ – Nag_BooleanInput

On entry: must be set equal to Nag_TRUE if

G (z) = Φ^{- 1} (z)

and Nag_FALSE if

G (z) = logit z

5: $ns$ – IntegerInput

On entry: ns must be set equal to the number of different score patterns in the sample,

s

Constraint:

2 \times p < ns \leq \min (2^{p}, n)

6: $x [\dim]$ – Nag_BooleanInput/Output

Note: the dimension, dim, of the array x must be at least

$\max (1, pdx \times p)$ when $order = Nag_ColMajor$ ;
$\max (1, ns \times pdx)$ when $order = Nag_RowMajor$ .

Where

X (l, j)

appears in this document, it refers to the array element

$x [(j - 1) \times pdx + l - 1]$ when $order = Nag_ColMajor$ ;
$x [(l - 1) \times pdx + j - 1]$ when $order = Nag_RowMajor$ .

On entry: the first

s

rows of x must contain the

s

different score patterns. The

l

th row of x must contain the

l

th score pattern with

X (l, j)

set equal to Nag_TRUE if

x_{l j} = 1

and Nag_FALSE if

x_{l j} = 0

. All rows of x must be distinct.

On exit: given a valid parameter set then the first

s

rows of x still contain the

s

different score patterns. However, the following points should be noted:

(i)	If the estimated factor loading for the $j$ th item is negative then that item is re-coded, i.e., $0$ s and $1$ s (or Nag_TRUE and Nag_FALSE) in the $j$ th column of x are interchanged.
(ii)	The rows of x will be reordered so that the theta scores corresponding to rows of x are in increasing order of magnitude.

7: $pdx$ – IntegerInput

On entry: the stride separating row or column elements (depending on the value of order) in the array x.

Constraints:

if $order = Nag_ColMajor$ , $pdx \geq ns$ ;
if $order = Nag_RowMajor$ , $pdx \geq p$ .

8: $irl [ns]$ – IntegerInput/Output

On entry: the

i

th component of irl must be set equal to the frequency with which the

i

th row of x occurs.

Constraints:

$irl [i - 1] \geq 0$ , for $i = 1, 2, \dots, s$ ;
$\sum_{i = 0}^{s - 1} irl [i - 1] = n$ .

On exit: given a valid parameter set then the first

s

components of irl are reordered as are the rows of x.

9: $a [p]$ – doubleInput/Output

On entry:

a [j - 1]

must be set equal to an initial estimate of

α_{j 1}

. In order to avoid divergence problems with the E-M algorithm you are strongly advised to set all the $a [j - 1]$ to $0.5$ .

On exit:

a [j - 1]

contains the latest estimate of

α_{j 1}

, for

j = 1, 2, \dots, p

. (Because of possible recoding all elements of a will be positive.)

10: $c [p]$ – doubleInput/Output

On entry:

c [j - 1]

must be set equal to an initial estimate of

α_{j 0}

. In order to avoid divergence problems with the E-M algorithm you are strongly advised to set all the $c [j - 1]$ to $0.0$ .

On exit:

c [j - 1]

contains the latest estimate of

α_{j 0}

, for

j = 1, 2, \dots, p

11: $iprint$ – IntegerInput

On entry: the frequency with which the maximum likelihood search function is to be monitored.

$iprint > 0$: The search is monitored once every iprint iterations, and when the number of quadrature points is increased, and again at the final solution point.
$iprint = 0$: The search is monitored once at the final point.
$iprint < 0$: The search is not monitored at all.

iprint should normally be set to a small positive number.

Suggested value:

iprint = 1

12: $outfile$ – const char *Input

On entry: the name of a file to which diagnostic output will be directed. If outfile is NULL the diagnostic output will be directed to standard output.

13: $cgetol$ – doubleInput

On entry: the accuracy to which the solution is required.

If cgetol is set to

10^{- l}

and on exit

fail . code =

NE_NOERROR or NE_ZERO_DF, then all elements of the gradient vector will be smaller than

10^{- l}

in absolute value. For most practical purposes the value

10^{- 4}

should suffice. You should be wary of setting cgetol too small since the convergence criterion may then have become too strict for the machine to handle.

If cgetol has been set to a value which is less than the square root of the machine precision,

ε

, then nag_binary_factor (g11sac) will use the value

\sqrt{ε}

instead.

14: $maxit$ – IntegerInput

On entry: the maximum number of iterations to be made in the maximum likelihood search. There will be an error exit (see Section 6) if the search function has not converged in maxit iterations.

Suggested value:

maxit = 1000

Constraint:

maxit \geq 1

15: $chisqr$ – Nag_BooleanInput

On entry: if chisqr is set equal to Nag_TRUE, then a likelihood ratio statistic will be calculated (see chi).

If chisqr is set equal to Nag_FALSE, no such statistic will be calculated.

16: $niter$ – Integer *Output

On exit: given a valid parameter set then niter contains the number of iterations performed by the maximum likelihood search function.

17: $alpha [p]$ – doubleOutput

On exit: given a valid parameter set then

alpha [j - 1]

contains the latest estimate of

α_{j}

. (Because of possible recoding all elements of alpha will be positive.)

18: $pigam [p]$ – doubleOutput

On exit: given a valid parameter set then

pigam [j - 1]

contains the latest estimate of either

π_{j}

gprob = Nag_FALSE

(logit model) or

γ_{j}

gprob = Nag_TRUE

(probit model).

19: $cm [\dim]$ – doubleOutput

Note: the dimension, dim, of the array cm must be at least

pdcm \times 2 \times p

Where

CM (i, j)

appears in this document, it refers to the array element

if $order = Nag_ColMajor$ , $cm [(j - 1) \times pdcm + i - 1]$ ;
if $order = Nag_RowMajor$ , $cm [(i - 1) \times pdcm + j - 1]$ .

On exit: given a valid parameter set then the strict lower triangle of cm contains the correlation matrix of the parameter estimates held in alpha and pigam on exit. The diagonal elements of cm contain the standard errors. Thus:

$CM (2 \times i - 1, 2 \times i - 1)$	=	standard error $(alpha [i - 1])$
$CM (2 \times i, 2 \times i)$	=	standard error $(pigam [i - 1])$
$CM (2 \times i, 2 \times i - 1)$	=	correlation $(pigam [i - 1], alpha [i - 1])$ ,

for

i = 1, 2, \dots, p

;

$CM (2 \times i - 1, 2 \times j - 1)$	=	correlation $(alpha [i - 1], alpha [j - 1])$
$CM (2 \times i, 2 \times j)$	=	correlation $(pigam [i - 1], pigam [j - 1])$
$CM (2 \times i - 1, 2 \times j)$	=	correlation $(alpha [i - 1], pigam [j - 1])$
$CM (2 \times i, 2 \times j - 1)$	=	correlation $(alpha [j - 1], pigam [i - 1])$ ,

for

j = 1, 2, \dots, i - 1

If the second derivative matrix cannot be computed then all the elements of cm are returned as zero.

20: $pdcm$ – IntegerInput

On entry: the stride separating row or column elements (depending on the value of order) of the matrix

C

in the array cm.

Constraint:

pdcm \geq 2 \times p

21: $g [2 \times p]$ – doubleOutput

On exit: given a valid parameter set then g contains the estimated gradient vector corresponding to the final point held in the arrays alpha and pigam.

g [2 \times j - 2]

contains the derivative of the log-likelihood with respect to

alpha [j - 1]

, for

j = 1, 2, \dots, p

g [2 \times j - 1]

contains the derivative of the log-likelihood with respect to

pigam [j - 1]

, for

j = 1, 2, \dots, p

22: $expp [\dim]$ – doubleOutput

Note: the dimension, dim, of the array expp must be at least

pde \times p

Where

EXPP (i, j)

appears in this document, it refers to the array element

if $order = Nag_ColMajor$ , $expp [(j - 1) \times pde + i - 1]$ ;
if $order = Nag_RowMajor$ , $expp [(i - 1) \times pde + j - 1]$ .

On exit: given a valid parameter set then

EXPP (i, j)

contains the expected percentage of individuals in the sample who respond positively to items

i

and

j

(

j \leq i

), corresponding to the final point held in the arrays alpha and pigam.

23: $pde$ – IntegerInput

On entry: the stride separating row or column elements (depending on the value of order) of the matrix

E

in the array expp.

Constraint:

pde \geq p

24: $obs [\dim]$ – doubleOutput

Note: the dimension, dim, of the array obs must be at least

pde \times p

Where

OBS (i, j)

appears in this document, it refers to the array element

if $order = Nag_ColMajor$ , $obs [(j - 1) \times pde + i - 1]$ ;
if $order = Nag_RowMajor$ , $obs [(i - 1) \times pde + j - 1]$ .

On exit: given a valid parameter set then

OBS (i, j)

contains the observed percentage of individuals in the sample who responded positively to items

i

and

j

(

j \leq i

25: $exf [ns]$ – doubleOutput

On exit: given a valid parameter set then

exf [l - 1]

contains the expected frequency of the

l

th score pattern (

l

th row of x), corresponding to the final point held in the arrays alpha and pigam.

26: $y [ns]$ – doubleOutput

On exit: given a valid parameter set then

y [l - 1]

contains the estimated theta score corresponding to the

l

th row of x, for the final point held in the arrays alpha and pigam.

27: $iob [ns]$ – IntegerOutput

On exit: given a valid parameter set then

iob [l - 1]

contains the number of items in the

l

th row of x for which the response was positive (Nag_TRUE).

28: $rlogl$ – double *Output

On exit: given a valid parameter set then rlogl contains the value of the log-likelihood kernel corresponding to the final point held in the arrays alpha and pigam, namely

\sum_{l = 0}^{s - 1} irl [l] \times \log (exf [l] / n) .

29: $chi$ – double *Output

On exit: if chisqr was set equal to Nag_TRUE on entry, then given a valid parameter set, chi will contain the value of the likelihood ratio statistic corresponding to the final parameter estimates held in the arrays alpha and pigam, namely

2 \times \sum_{l = 0}^{s - 1} irl [l] \times \log (exf [l] / irl [l]) .

The summation is over those elements of irl which are positive. If

exf [l - 1]

is less than

5.0

, then adjacent score patterns are pooled (the score patterns in x being first put in order of increasing theta score).

If chisqr has been set equal to Nag_FALSE, then chi is not used.

30: $idf$ – Integer *Output

On exit: if chisqr was set equal to Nag_TRUE on entry, then given a valid parameter set, idf will contain the degrees of freedom associated with the likelihood ratio statistic, chi.

$idf = s_{0} - 2 \times p$	if $s_{0} < 2^{p}$ ;
$idf = s_{0} - 2 \times p - 1$	if $s_{0} = 2^{p}$ ,

where

s_{0}

denotes the number of terms summed to calculate chi (

s_{0} = s

only if there is no pooling).

If chisqr has been set equal to Nag_FALSE, then idf is not used.

31: $siglev$ – double *Output

On exit: if chisqr was set equal to Nag_TRUE on entry, then given a valid parameter set, siglev will contain the significance level of chi based on idf degrees of freedom. If idf is zero or negative then siglev is set to zero.

If chisqr was set equal to Nag_FALSE, then siglev is not used.

32: $fail$ – NagError *Input/Output

The NAG error argument (see Section 3.6 in the Essential Introduction).

6 Error Indicators and Warnings

NE_ALLOC_FAIL: Dynamic memory allocation failed.
See Section 3.2.1.2 in the Essential Introduction for further information.
NE_BAD_PARAM: On entry, argument $〈value〉$ had an illegal value.
NE_INT: On entry, $maxit = 〈value〉$ .
Constraint: $maxit \geq 1$ .

On entry, $n = 〈value〉$ .
Constraint: $n \geq 7$ .

On entry, $p = 〈value〉$ .
Constraint: $p \geq 3$ .

On entry, $pdcm = 〈value〉$ .
Constraint: $pdcm > 0$ .

On entry, $pde = 〈value〉$ .
Constraint: $pde > 0$ .

On entry, $pdx = 〈value〉$ .
Constraint: $pdx > 0$ .
NE_INT_2: On entry, $I = 〈value〉$ and $irl [I - 1] = 〈value〉$ .
Constraint: $irl [I - 1] \geq 0$ .

On entry, $irl [0] + \dots + irl [ns - 1] = 〈value〉$ and $n = 〈value〉$ .
Constraint: $irl [0] + \dots + irl [ns - 1] = n$ .

On entry, $ns = 〈value〉$ and $n = 〈value〉$ .
Constraint: $ns \leq n$ .

On entry, $ns = 〈value〉$ and $p = 〈value〉$ .
Constraint: $ns > 2 \times p$ .

On entry, $ns = 〈value〉$ and $p = 〈value〉$ .
Constraint: $ns \leq 2^{p}$ .

On entry, $pdcm = 〈value〉$ and $p = 〈value〉$ .
Constraint: $pdcm \geq 2 \times p$ .

On entry, $pde = 〈value〉$ and $p = 〈value〉$ .
Constraint: $pde \geq p$

On entry, $pdx = 〈value〉$ and $ns = 〈value〉$ .
Constraint: $pdx \geq ns$ .

On entry, $pdx = 〈value〉$ and $p = 〈value〉$ .
Constraint: $pdx \geq p$ .

On entry, rows $I$ and $J$ of x are identical: $I = 〈value〉$ and $J = 〈value〉$ .
NE_INT_3: On entry, $p = 〈value〉$ , $n = 〈value〉$ and $ns = 〈value〉$ .
Constraint: $2 \times p < ns \leq \min (2^{p}, n)$ .
NE_INTERNAL_ERROR: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.

An unexpected error has been triggered by this function. Please contact NAG.
See Section 3.6.6 in the Essential Introduction for further information.
NE_MAT_INV: Failure to invert Hessian matrix and maxit iterations made: $maxit = 〈value〉$ .

Failure to invert Hessian matrix plus Heywood case encountered.
NE_NO_LICENCE: Your licence key may have expired or may not have been installed correctly.
See Section 3.6.5 in the Essential Introduction for further information.
NE_NOT_CLOSE_FILE: Cannot close file $〈value〉$ .
NE_NOT_WRITE_FILE: Cannot open file $〈value〉$ for writing.
NE_REAL_ARRAY_ELEM_CONS: One of the elements of a has exceeded $10$ in absolute value (Heywood case).
NE_RESPONSE_LEVEL: For at least one of the p items the responses are all at the same level.
NE_TOO_MANY_ITER: maxit iterations have been performed: $maxit = 〈value〉$ .
NE_ZERO_DF: Chi-squared statistic has idf degrees of freedom: $idf = 〈value〉$ .

7 Accuracy

On exit from nag_binary_factor (g11sac) if

fail . code =

NE_NOERROR or NE_ZERO_DF then the following condition will be satisfied:

\max_{0 \leq i \leq 2 \times p - 1} \{|g [i]|\} < cgetol .

fail . code =

NE_MAT_INV or NE_TOO_MANY_ITER on exit (i.e., maxit iterations have been performed but the above condition does not hold), then the elements in a, c, alpha and pigam may still be good approximations to the maximum likelihood estimates. You are advised to inspect the elements of g to see whether this is confirmed.

8 Parallelism and Performance

nag_binary_factor (g11sac) is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.

nag_binary_factor (g11sac) makes calls to BLAS and/or LAPACK routines, which may be threaded within the vendor library used by this implementation. Consult the documentation for the vendor library for further information.

Please consult the X06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this function. Please also consult the Users' Note for your implementation for any additional implementation-specific information.

9 Further Comments

9.1 Timing

The number of iterations required in the maximum likelihood search depends upon the number of observed variables,

p

, and the distance of the starting point you supplied from the solution. The number of multiplications and divisions performed in an iteration is proportional to

p

9.2 Initial Estimates

You are strongly advised to use the recommended starting values for the elements of a and c. Divergence may result from values you supplied even if they are very close to the solution. Divergence may also occur when an item has nearly all its responses at one level.

9.3 Heywood Cases

As in normal factor analysis, Heywood cases can often occur, particularly when

p

is small and

n

not very big. To overcome this difficulty the maximum likelihood search function is terminated when the absolute value of one of the

α_{j 1}

exceeds

10.0

. You have the option of deciding whether to exit from nag_binary_factor (g11sac) (by setting

fail . print = NAGERR_DEFAULT

on entry) or to permit nag_binary_factor (g11sac) to proceed onwards as if it had exited normally from the maximum likelihood search function (see

fail . print = Nag_TRUE

or Nag_FALSE on entry). The elements in a, c, alpha and pigam may still be good approximations to the maximum likelihood estimates. You are advised to inspect the elements g to see whether this is confirmed.

9.4 Goodness of Fit Statistic

When

n

is not very large compared to

s

a goodness-of-fit statistic should not be calculated as many of the expected frequencies will then be less than

5

9.5 First and Second Order Margins

The observed and expected percentages of sample members responding to individual and pairs of items held in the arrays obs and expp on exit can be converted to observed and expected numbers by multiplying all elements of these two arrays by

n / 100.0

10 Example

A program to fit the logit latent variable model to the following data:

Index	Score Pattern	Observed Frequency
$1$	$0000$	$154$
$2$	$1000$	$11$
$3$	$0001$	$42$
$4$	$0100$	$49$
$5$	$1001$	$2$
$6$	$1100$	$10$
$7$	$0101$	$27$
$8$	$0010$	$84$
$9$	$1101$	$10$
$10$	$1010$	$25$
$11$	$0011$	$75$
$12$	$0110$	$129$
$13$	$1011$	$30$
$14$	$1110$	$50$
$15$	$0111$	$181$
$16$	$1111$	$121$
		––––
Total		$1000$

NAG Library Function Documentnag_binary_factor (g11sac)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Timing

9.2 Initial Estimates

9.3 Heywood Cases

9.4 Goodness of Fit Statistic

9.5 First and Second Order Margins

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

NAG Library Function Document

nag_binary_factor (g11sac)