# Mahalanobis Fixed Point Clusters Computes Mahalanobis fixed point clusters (FPCs), i.e., subsets of the data, which consist exactly of the non-outliers w.r.t. themselves, and may be interpreted as generated from a homogeneous normal population. FPCs may overlap, are not necessarily exhausting and do not need a specification of the number of clusters. Note that while `fixmahal` has lots of parameters, only one (or few) of them have usually to be specified, cf. the examples. The philosophy is to allow much flexibility, but to always provide sensible defaults. ```r fixmahal(dat, n = nrow(as.matrix(dat)), p = ncol(as.matrix(dat)), method = "fuzzy", cgen = "fixed", ca = NA, ca2 = NA, calpha = ifelse(method=="fuzzy",0.95,0.99), calpha2 = 0.995, pointit = TRUE, subset = n, nc1 = 100+20*p, startn = 18+p, mnc = floor(startn/2), mer = ifelse(pointit,0.1,0), distcut = 0.85, maxit = 5*n, iter = n*1e-5, init.group = list(), ind.storage = TRUE, countmode = 100, plot = "none") ## S3 method for class 'mfpc' summary(object, ...) ## S3 method for class 'summary.mfpc' print(x, maxnc=30, ...) ## S3 method for class 'mfpc' plot(x, dat, no, bw=FALSE, main=c("Representative FPC No. ",no), xlab=NULL, ylab=NULL, pch=NULL, col=NULL, ...) ## S3 method for class 'mfpc' fpclusters(object, dat=NA, ca=object$ca, p=object$p, ...) fpmi(dat, n = nrow(as.matrix(dat)), p = ncol(as.matrix(dat)), gv, ca, ca2, method = "ml", plot, maxit = 5*n, iter = n*1e-6) ``` ## Arguments - `dat`: something that can be coerced to a numerical matrix or vector. Data matrix, rows are points, columns are variables. `fpclusters.rfpc` does not need specification of `dat` if `fixmahal` has been run with `ind.storage=TRUE`. - `n`: optional positive integer. Number of cases. - `p`: optional positive integer. Number of independent variables. - `method`: a string. `method="classical"` means 0-1 weighting of observations by Mahalanobis distances and use of the classical normal covariance estimator. `method="ml"` uses the ML-covariance estimator (division by `n` instead of `n-1`) This is used in Hennig and Christlieb (2002). `method` can also be `"mcd"` or `"mve"`, to enforce the use of robust centers and covariance matrices, see `cov.rob`. This is experimental, not recommended at the moment, may be very slowly and requires library `lqs`. The default is `method="fuzzy"`, where weighted means and covariance matrices are used (Hennig, 2005). The weights are computed by `wfu`, i.e., a function that is constant 1 for arguments smaller than `ca`, 0 for arguments larger than `ca2` and continuously linear in between. Convergence is only proven for `method="ml"` up to now. - `cgen`: optional string. `"fixed"` means that the same tuning constant `ca` is used for all iterations. `"auto"` means that `ca` is generated dependently on the size of the current data subset in each iteration by `cmahal`. This is experimental. - `ca`: optional positive number. Tuning constant, specifying required cluster separation. By default determined as `calpha`-quantile of the chisquared distribution with `p` degrees of freedom. - `ca2`: optional positive number. Second tuning constant needed if `method="fuzzy"`. By default determined as `calpha2`-quantile of the chisquared distribution with `p` degrees of freedom. - `calpha`: number between 0 and 1. See `ca`. - `calpha2`: number between 0 and 1, larger than `calpha`. See `ca2`. - `pointit`: optional logical. If `TRUE`, `subset` fixed point algorithms are started from initial configurations, which are built around single points of the dataset, cf. `mahalconf`. Otherwise, initial configurations are only specified by `init.group`. - `subset`: optional positive integer smaller or equal than `n`. Initial configurations for the fixed point algorithm (cf. `mahalconf`) are built from a subset of `subset` points from the data. No effect if `pointit=FALSE`. Default: all points. - `nc1`: optional positive integer. Tuning constant needed by `cmahal` to generate `ca` automatically. Only needed for `cgen="auto"`. - `startn`: optional positive integer. Size of the initial configurations. The default value is chosen to prevent that small meaningless FPCs are found, but it should be decreased if clusters of size smaller than the default value are of interest. - `mnc`: optional positive integer. Minimum size of clusters to be reported. - `mer`: optional nonnegative number. FPCs (groups of them, respectively, see details) are only reported as stable if the ratio of the number of their findings to their number of points exceeds `mer`. This holds under `pointit=TRUE` and `subset=n`. For `subset=3`, the optimal separating projection computed by `batcoord` is shown. `fpclusters.mfpc` produces a list of indicator vectors for the representative FPCs of stable groups. `fpmi` is called by `fixmahal` for a single fixed point algorithm and will usually not be executed alone. ## Returns `fixmahal` returns an object of class `mfpc`. This is a list containing the components `nc, g, means, covs, nfound, er, tsc, ncoll, skc, grto, imatrix,smatrix, stn, stfound, ser, sfpc, ssig, sto, struc, n, p, method, cgen,ca, ca2, cvec, calpha, pointit, subset, mnc, startn, mer, distcut`. `summary.mfpc` returns an object of class `summary.mfpc`. This is a list containing the components `means, covs, stn, stfound, sn, ser, tskip, skc, tsc, sim, ca, ca2,calpha, mer, method, cgen, pointit`. `fpclusters.mfpc` returns a list of indicator vectors for the representative FPCs of stable groups. `fpmi` returns a list with the components `mg, covg, md, gv, coll, method, ca`. - **nc**: integer. Number of FPCs. - **g**: list of logical vectors. Indicator vectors of FPCs. `FALSE` if `ind.storage=FALSE`. - **means**: list of numerical vectors. Means of FPCs. In `summary.mfpc`, only for representative FPCs of stable groups and sorted according to `ser`. - **covs**: list of numerical matrices. Covariance matrices of FPCs. In `summary.mfpc`, only for representative FPCs of stable groups and sorted according to `ser`. - **nfound**: vector of integers. Number of findings for the FPCs. - **er**: numerical vector. Ratio of number of findings of FPCs to their size. Under `pointit=TRUE`, this can be taken as a measure of stability of FPCs. - **tsc**: integer. Number of algorithm runs leading to too small or too seldom found FPCs. - **ncoll**: integer. Number of algorithm runs where collinear covariance matrices occurred. - **skc**: integer. Number of skipped clusters. - **grto**: vector of integers. Numbers of FPCs to which algorithm runs led, which were started by `init.group`. - **imatrix**: vector of integers. Size of intersection between FPCs. See `sseg`. - **smatrix**: numerical vector. Similarities between FPCs. See `sseg`. - **stn**: integer. Number of representative FPCs of stable groups. In `summary.mfpc`, sorted according to `ser`. - **stfound**: vector of integers. Number of findings of members of all groups of FPCs. In `summary.mfpc`, sorted according to `ser`. - **ser**: numerical vector. Ratio of number of findings of groups of FPCs to their size. Under `pointit=TRUE`, this can be taken as a measure of stability of FPCs. In `summary.mfpc`, sorted from largest to smallest. - **sfpc**: vector of integers. Numbers of representative FPCs of all groups. - **ssig**: vector of integers of length `stn`. Numbers of representative FPCs of the stable groups. - **sto**: vector of integers. Numbers of groups ordered according to largest `ser`. - **struc**: vector of integers. Number of group an FPC belongs to. - **n**: see arguments. - **p**: see arguments. - **method**: see arguments. - **cgen**: see arguments. - **ca**: see arguments, if `cgen` has been `"fixed"`. Else numerical vector of length `nc` (see below), giving the final values of `ca` for all FPC. In `fpmi`, tuning constant for the iterated FPC. - **ca2**: see arguments. - **cvec**: numerical vector of length `n` for `cgen="auto"`. The values for the tuning constant `ca` corresponding to the cluster sizes from `1` to `n`. - **calpha**: see arguments. - **pointit**: see arguments. - **subset**: see arguments. - **mnc**: see arguments. - **startn**: see arguments. - **mer**: see arguments. - **distcut**: see arguments. - **sn**: vector of integers. Number of points of representative FPCs. - **tskip**: integer. Number of algorithm runs leading to skipped FPCs. - **sim**: vector of integers. Size of intersections between representative FPCs of stable groups. See `sseg`. - **mg**: mean vector. - **covg**: covariance matrix. - **md**: Mahalanobis distances. - **gv**: logical (numerical, respectively, if `method="fuzzy"`) indicator vector of iterated FPC. - **coll**: logical. `TRUE` means that singular covariance matrices occurred during the iterations. ## References Hennig, C. (2002) Fixed point clusters for linear regression: computation and comparison, **Journal of Classification** 19, 249-276. Hennig, C. (2005) Fuzzy and Crisp Mahalanobis Fixed Point Clusters, in Baier, D., Decker, R., and Schmidt-Thieme, L. (eds.): **Data Analysis and Decision Support**. Springer, Heidelberg, 47-56. Hennig, C. and Christlieb, N. (2002) Validating visual clusters in large datasets: Fixed point clusters of spectral features, **Computational Statistics and Data Analysis** 40, 723-739. ## Author(s) Christian Hennig christian.hennig@unibo.it [https://www.unibo.it/sitoweb/christian.hennig/en/](https://www.unibo.it/sitoweb/christian.hennig/en/) ## See Also `fixreg` for linear regression fixed point clusters. `mahalconf`, `wfu`, `cmahal` for computation of initial configurations, weights, tuning constants. `sseg` for indexing the similarity/intersection vectors computed by `fixmahal`. `batcoord`, `cov.rob`, `solvecov`, `cov.wml`, `plotcluster` for computation of projections, (inverted) covariance matrices, plotting. `rFace` for generation of example data, see below. ## Examples ```r options(digits=2) set.seed(20000) face <- rFace(400,dMoNo=2,dNoEy=0, p=3) # The first example uses grouping information via init.group. initg <- list() grface <- as.integer(attr(face,"grouping")) for (i in 1:5) initg[[i]] <- (grface==i) ff0 <- fixmahal(face, pointit=FALSE, init.group=initg) summary(ff0) cff0 <- fpclusters(ff0) plot(face, col=1+cff0[[1]]) plot(face, col=1+cff0[[4]]) # Why does this come out as a cluster? plot(ff0, face, 4) # A bit clearer... # Without grouping information, examples need more time: # ff1 <- fixmahal(face) # summary(ff1) # cff1 <- fpclusters(ff1) # plot(face, col=1+cff1[[1]]) # plot(face, col=1+cff1[[6]]) # Why does this come out as a cluster? # plot(ff1, face, 6) # A bit clearer... # ff2 <- fixmahal(face,method="ml") # summary(ff2) # ff3 <- fixmahal(face,method="ml",calpha=0.95,subset=50) # summary(ff3) ## ...fast, but lots of clusters. mer=0.3 may be useful here. # set.seed(3000) # face2 <- rFace(400,dMoNo=2,dNoEy=0) # ff5 <- fixmahal(face2) # summary(ff5) ## misses right eye of face data; with p=6, ## initial configurations are too large for 40 point clusters # ff6 <- fixmahal(face2, startn=30) # summary(ff6) # cff6 <- fpclusters(ff6) # plot(face2, col=1+cff6[[3]]) # plot(ff6, face2, 3) # x <- c(1,2,3,6,6,7,8,120) # ff8 <- fixmahal(x) # summary(ff8) # ...dataset a bit too small for the defaults... # ff9 <- fixmahal(x, mnc=3, startn=3) # summary(ff9) ```

fixmahal function