Package 'e1071' reference manual

Title:	Misc Functions of the Department of Statistics, Probability Theory Group (Formerly: E1071), TU Wien
Description:	Functions for latent class analysis, short time Fourier transform, fuzzy clustering, support vector machines, shortest path computation, bagged clustering, naive Bayes classifier, generalized k-nearest neighbour ...
Authors:	David Meyer [aut, cre] , Evgenia Dimitriadou [aut, cph], Kurt Hornik [aut] , Andreas Weingessel [aut], Friedrich Leisch [aut], Chih-Chung Chang [ctb, cph] (libsvm C++-code), Chih-Chen Lin [ctb, cph] (libsvm C++-code)
Maintainer:	David Meyer <[email protected]>
License:	GPL-2 \| GPL-3
Version:	1.7-14
Built:	2024-05-04 08:19:10 UTC
Source:	CRAN

Fuzzy Cluster Indexes (Validity/Performance Measures)

Description

Calculates the values of several fuzzy validity measures. The values of the indexes can be independently used in order to evaluate and compare clustering partitions or even to determine the number of clusters existing in a data set.

Usage

fclustIndex(y, x, index = "all")

Arguments

`y`	An object of a fuzzy clustering result of class `"fclust"`
`x`	Data matrix
`index`	The validity measures used: `"gath.geva"`, `"xie.beni"`, `"fukuyama.sugeno"`, `"partition.coefficient"`, `"partition.entropy"`, `"proportion.exponent"`, `"separation.index"` and `"all"` for all the indexes.

Details

The validity measures and a short description of them follows, where $N$ is the number of data points, $u_{ij}$ the values of the membership matrix, $v_j$ the centers of the clusters and $k$ te number of clusters.

gath.geva:

Gath and Geva introduced 2 main criteria for comparing and finding optimal partitions based on the heuristics that a better clustering assumes clear separation between the clusters, minimal volume of the clusters and maximal number of data points concentrated in the vicinity of the cluster centroids. These indexes are only for the cmeans clustering algorithm valid. For the first, the “fuzzy hypervolume” we have: $F_{HV}=\sum_{j=1}^{c}{[\det(F_j)]}^{1/2}$ , where $F_j=\frac{\sum_{i=1}^N u_{ij}(x_i-v_j)(x_i-v_j)^T}{\sum_{i=1}^{N}u_{ij}}$ , for the case when the defuzzification parameter is 2. For the second, the “average partition density”: $D_{PA}=\frac{1}{k}\sum_{j=1}^k\frac{S_j}{{[\det(F_j)]}^{1/2}}$ , where $S_j=\sum_{i=1}^N u_{ij}$ . Moreover, the “partition density” which expresses the general partition density according to the physical definition of density is calculated by: $P_D=\frac{S}{F_{HV}}$ , where $S=\sum_{j=1}^k\sum_{i=1}^N u_{ij}$ .

xie.beni:

This index is a function of the data set and the centroids of the clusters. Xie and Beni explained this index by writing it as a ratio of the total variation of the partition and the centroids $(U,V)$ and the separation of the centroids vectors. The minimum values of this index under comparison support the best partitions. $u_{XB}(U,V;X)=\frac{\sum_{j=1}^k\sum_{i=1}^Nu_{ij}^2{||x_i-v_j||}^2}{N(\min_{j\neq l}\{{||v_j-v_l||}^2\})}$

fukuyama.sugeno:

This index consists of the difference of two terms, the first combining the fuzziness in the membership matrix with the geometrical compactness of the representation of the data set via the prototypes, and the second the fuzziness in its row of the partition matrix with the distance from the $i$th prototype to the grand mean of the data. The minimum values of this index also propose a good partition. $u_{FS}(U,V;X)=\sum_{i=1}^{N}\sum_{j=1}^k (u_{ij}^2)^q(||x_i-v_j||^2-||v_j-\bar v||^2)$

partition.coefficient:

An index which measures the fuzziness of the partition but without considering the data set itself. It is a heuristic measure since it has no connection to any property of the data. The maximum values of it imply a good partition in the meaning of a least fuzzy clustering. $F(U;k)=\frac{tr (UU^T)}{N}=\frac{<U,U>}{N}=\frac{||U||^2}{N}$

$F(U;k)$ shows the fuzziness or the overlap of the partition and depends on $kN$ elements.
$1/k\leq F(U;k)\leq 1$ , where if $F(U;k)=1$ then $U$ is a hard partition and if $F(U;k)=1/k$ then $U=[1/k]$ is the centroid of the fuzzy partion space $P_{fk}$ . The converse is also valid.

partition.entropy:

It is a measure that provides information about the membership matrix without also considering the data itself. The minimum values imply a good partition in the meaning of a more crisp partition. $H(U;k)=\sum_{i=1}^{N} h(u_i)/N$ , where $h(u)=-\sum_{j=1}^{k} u_j\,\log _a (u_j)$ the Shannon's entropy.

$H(U;k)$ shows the uncertainty of a fuzzy partition and depends also on $kN$ elements. Specifically, $h(u_i)$ is interpreted as the amount of fuzzy information about the membership of $x_i$ in $k$ classes that is retained by column $u_j$ . Thus, at $U=[1/k]$ the most information is withheld since the membership is the fuzziest possible.
$0\leq H(U;k)\leq \log_a(k)$ , where for $H(U;k)=0$ $U$ is a hard partition and for $H(U;k)=\log_a(k)$ $U=[1/k]$ .

proportion.exponent:

It is a measure $P(U;k)$ of fuzziness adept to detect structural variations in the partition matrix as it becomes more fuzzier. A crisp cluster in the partition matrix can drive it to infinity when the partition coefficient and the partition entropy are more sensitive to small changes when approaching a hard partition. Its evaluation does not also involve the data or the algorithm used to partition them and its maximum implies the optimal partition but without knowing what maximum is a statistically significant maximum.

$0\leq P(U;k)<\infty$ , since the $[0,1]$ values explode to $[0,\infty)$ due to the natural logarithm. Specifically, $P=0$ when and only when $U=[1/k]$ , while $P\rightarrow\infty$ when any column of $U$ is crisp.
$P(U;k)$ can easily explode and it is good for partitions with large column maximums and at detecting structural variations.

separation.index (known as CS Index):

This index identifies unique cluster structure with well-defined properties that depend on the data and a measure of distance. It answers the question if the clusters are compact and separated, but it rather seems computationally infeasible for big data sets since a distance matrix between all the data membership values has to be calculated. It also presupposes that a hard partition is derived from the fuzzy one.
$D_1(U;k;X,d)=\min_{i+1\,\leq\,l\,\leq\,k-1}\left\{\min_{1\,\leq\,j\,\leq\,k}\left\{\frac{dis(u_j,u_l)}{\max_{1\leq m\leq k}\{dia(u_m)\}}\right\}\right\}$ , where $dia$ is the diameter of the subset, $dis$ the distance of two subsets, and $d$ a metric. $U$ is a CS partition of $X$ $\Leftrightarrow D_1>1$ . When this holds then $U$ is unique.

Value

Returns a vector with the validity measures values.

Author(s)

Evgenia Dimitriadou

References

James C. Bezdek, Pattern Recognition with Fuzzy Objective Function Algorithms, Plenum Press, 1981, NY.
L. X. Xie and G. Beni, Validity measure for fuzzy clustering, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 3, n. 8, p. 841-847, 1991.
I. Gath and A. B. Geva, Unsupervised Optimal Fuzzy Clustering, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 11, n. 7, p. 773-781, 1989.
Y. Fukuyama and M. Sugeno, A new method of choosing the number of clusters for the fuzzy $c$-means method, Proc. 5th Fuzzy Syst. Symp., p. 247-250, 1989 (in japanese).

Examples

# a 2-dimensional example
x<-rbind(matrix(rnorm(100,sd=0.3),ncol=2),
         matrix(rnorm(100,mean=1,sd=0.3),ncol=2))
cl<-cmeans(x,2,20,verbose=TRUE,method="cmeans")
resultindexes <- fclustIndex(cl,x, index="all")
resultindexes

Support Vector Machines

Description

svm is used to train a support vector machine. It can be used to carry out general regression and classification (of nu and epsilon-type), as well as density-estimation. A formula interface is provided.

Usage

## S3 method for class 'formula'
svm(formula, data = NULL, ..., subset, na.action =
na.omit, scale = TRUE)
## Default S3 method:
svm(x, y = NULL, scale = TRUE, type = NULL, kernel =
"radial", degree = 3, gamma = if (is.vector(x)) 1 else 1 / ncol(x),
coef0 = 0, cost = 1, nu = 0.5,
class.weights = NULL, cachesize = 40, tolerance = 0.001, epsilon = 0.1,
shrinking = TRUE, cross = 0, probability = FALSE, fitted = TRUE,
..., subset, na.action = na.omit)

Arguments

`formula`	a symbolic description of the model to be fit.
`data`	an optional data frame containing the variables in the model. By default the variables are taken from the environment which ‘svm’ is called from.
`x`	a data matrix, a vector, or a sparse matrix (object of class `Matrix` provided by the Matrix package, or of class `matrix.csr` provided by the SparseM package, or of class `simple_triplet_matrix` provided by the slam package).
`y`	a response vector with one label for each row/component of `x`. Can be either a factor (for classification tasks) or a numeric vector (for regression).
`scale`	A logical vector indicating the variables to be scaled. If `scale` is of length 1, the value is recycled as many times as needed. Per default, data are scaled internally (both `x` and `y` variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.
`type`	`svm` can be used as a classification machine, as a regression machine, or for novelty detection. Depending of whether `y` is a factor or not, the default setting for `type` is `C-classification` or `eps-regression`, respectively, but may be overwritten by setting an explicit value. Valid options are: `C-classification` `nu-classification` `one-classification` (for novelty detection) `eps-regression` `nu-regression`
`kernel`	the kernel used in training and predicting. You might consider changing some of the following parameters, depending on the kernel type. linear: $u'v$ polynomial: $(\gamma u'v + coef0)^{degree}$ radial basis: $e^(-\gamma \|u-v\|^2)$ sigmoid: $tanh(\gamma u'v + coef0)$
`degree`	parameter needed for kernel of type `polynomial` (default: 3)
`gamma`	parameter needed for all kernels except `linear` (default: 1/(data dimension))
`coef0`	parameter needed for kernels of type `polynomial` and `sigmoid` (default: 0)
`cost`	cost of constraints violation (default: 1)—it is the ‘C’-constant of the regularization term in the Lagrange formulation.
`nu`	parameter needed for `nu-classification`, `nu-regression`, and `one-classification`
`class.weights`	a named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named. Specifying `"inverse"` will choose the weights inversely proportional to the class distribution.
`cachesize`	cache memory in MB (default 40)
`tolerance`	tolerance of termination criterion (default: 0.001)
`epsilon`	epsilon in the insensitive-loss function (default: 0.1)
`shrinking`	option whether to use the shrinking-heuristics (default: `TRUE`)
`cross`	if a integer value k>0 is specified, a k-fold cross validation on the training data is performed to assess the quality of the model: the accuracy rate for classification and the Mean Squared Error for regression
`fitted`	logical indicating whether the fitted values should be computed and included in the model or not (default: `TRUE`)
`probability`	logical indicating whether the model should allow for probability predictions.
`...`	additional parameters for the low level fitting function `svm.default`
`subset`	An index vector specifying the cases to be used in the training sample. (NOTE: If given, this argument must be named.)
`na.action`	A function to specify the action to be taken if `NA`s are found. The default action is `na.omit`, which leads to rejection of cases with missing values on any required variable. An alternative is `na.fail`, which causes an error if `NA` cases are found. (NOTE: If given, this argument must be named.)

Details

For multiclass-classification with k levels, k>2, libsvm uses the ‘one-against-one’-approach, in which k(k-1)/2 binary classifiers are trained; the appropriate class is found by a voting scheme.

libsvm internally uses a sparse data representation, which is also high-level supported by the package SparseM.

If the predictor variables include factors, the formula interface must be used to get a correct model matrix.

plot.svm allows a simple graphical visualization of classification models.

The probability model for classification fits a logistic distribution using maximum likelihood to the decision values of all binary classifiers, and computes the a-posteriori class probabilities for the multi-class problem using quadratic optimization. The probabilistic regression model assumes (zero-mean) laplace-distributed errors for the predictions, and estimates the scale parameter using maximum likelihood.

For linear kernel, the coefficients of the regression/decision hyperplane can be extracted using the coef method (see examples).

Value

An object of class "svm" containing the fitted model, including:

`SV`	The resulting support vectors (possibly scaled).
`index`	The index of the resulting support vectors in the data matrix. Note that this index refers to the preprocessed data (after the possible effect of `na.omit` and `subset`)
`coefs`	The corresponding coefficients times the training labels.
`rho`	The negative intercept.
`sigma`	In case of a probabilistic regression model, the scale parameter of the hypothesized (zero-mean) laplace distribution estimated by maximum likelihood.
`probA`, `probB`	numeric vectors of length k(k-1)/2, k number of classes, containing the parameters of the logistic distributions fitted to the decision values of the binary classifiers (1 / (1 + exp(a x + b))).

Note

Data are scaled internally, usually yielding better results.

Parameters of SVM-models usually must be tuned to yield sensible results!

Author(s)

David Meyer (based on C/C++-code by Chih-Chung Chang and Chih-Jen Lin)
[email protected]

References

Chang, Chih-Chung and Lin, Chih-Jen:
LIBSVM: a library for Support Vector Machines
https://www.csie.ntu.edu.tw/~cjlin/libsvm/
Exact formulations of models, algorithms, etc. can be found in the document:
Chang, Chih-Chung and Lin, Chih-Jen:
LIBSVM: a library for Support Vector Machines
https://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.ps.gz
More implementation details and speed benchmarks can be found on: Rong-En Fan and Pai-Hsune Chen and Chih-Jen Lin:
Working Set Selection Using the Second Order Information for Training SVM
https://www.csie.ntu.edu.tw/~cjlin/papers/quadworkset.pdf

Examples

data(iris)
attach(iris)

## classification mode
# default with factor response:
model <- svm(Species ~ ., data = iris)

# alternatively the traditional interface:
x <- subset(iris, select = -Species)
y <- Species
model <- svm(x, y) 

print(model)
summary(model)

# test with train data
pred <- predict(model, x)
# (same as:)
pred <- fitted(model)

# Check accuracy:
table(pred, y)

# compute decision values and probabilities:
pred <- predict(model, x, decision.values = TRUE)
attr(pred, "decision.values")[1:4,]

# visualize (classes by color, SV by crosses):
plot(cmdscale(dist(iris[,-5])),
     col = as.integer(iris[,5]),
     pch = c("o","+")[1:150 %in% model$index + 1])

## try regression mode on two dimensions

# create data
x <- seq(0.1, 5, by = 0.05)
y <- log(x) + rnorm(x, sd = 0.2)

# estimate model and predict input values
m   <- svm(x, y)
new <- predict(m, x)

# visualize
plot(x, y)
points(x, log(x), col = 2)
points(x, new, col = 4)

## density-estimation

# create 2-dim. normal with rho=0:
X <- data.frame(a = rnorm(1000), b = rnorm(1000))
attach(X)

# traditional way:
m <- svm(X, gamma = 0.1)

# formula interface:
m <- svm(~., data = X, gamma = 0.1)
# or:
m <- svm(~ a + b, gamma = 0.1)

# test:
newdata <- data.frame(a = c(0, 4), b = c(0, 4))
predict (m, newdata)

# visualize:
plot(X, col = 1:1000 %in% m$index + 1, xlim = c(-5,5), ylim=c(-5,5))
points(newdata, pch = "+", col = 2, cex = 5)

## weights: (example not particularly sensible)
i2 <- iris
levels(i2$Species)[3] <- "versicolor"
summary(i2$Species)
wts <- 100 / table(i2$Species)
wts
m <- svm(Species ~ ., data = i2, class.weights = wts)

## extract coefficients for linear kernel

# a. regression
x <- 1:100
y <- x + rnorm(100)
m <- svm(y ~ x, scale = FALSE, kernel = "linear")
coef(m)
plot(y ~ x)
abline(m, col = "red")

# b. classification
# transform iris data to binary problem, and scale data
setosa <- as.factor(iris$Species == "setosa")
iris2 = scale(iris[,-5])

# fit binary C-classification model
m <- svm(setosa ~ Petal.Width + Petal.Length,
        data = iris2, kernel = "linear")

# plot data and separating hyperplane
plot(Petal.Length ~ Petal.Width, data = iris2, col = setosa)
(cf <- coef(m))
abline(-cf[1]/cf[3], -cf[2]/cf[3], col = "red")

# plot margin and mark support vectors
abline(-(cf[1] + 1)/cf[3], -cf[2]/cf[3], col = "blue")
abline(-(cf[1] - 1)/cf[3], -cf[2]/cf[3], col = "blue")
points(m$SV, pch = 5, cex = 2)

`x`	matrix or distance object
`obj`	return value of `allShortestPaths`
`start`	integer, starting point of path
`end`	integer, end point of path

`length`	A matrix with the total lengths of the shortest path between each pair of points.
`middlePoints`	A matrix giving a point in the middle of each shortest path (or 0 if the direct connection is the shortest path), this is mainly used as input for `extractPath`.

`x`	Matrix of inputs (or object of class `"bclust"` for plot).
`centers`, `k`	Number of clusters.
`iter.base`	Number of runs of the base cluster algorithm.
`minsize`	Minimum number of points in a base cluster.
`dist.method`	Distance method used for the hierarchical clustering, see `dist` for available distances.
`hclust.method`	Linkage method used for the hierarchical clustering, see `hclust` for available methods.
`base.method`	Partitioning cluster method used as base algorithm.
`base.centers`	Number of centers used in each repetition of the base method.
`verbose`	Output status messages.
`final.kmeans`	If `TRUE`, a final kmeans step is performed using the output of the bagged clustering as initialization.
`docmdscale`	Logical, if `TRUE` a `cmdscale` result is included in the return value.
`resample`	Logical, if `TRUE` the base method is run on bootstrap samples of `x`, else directly on `x`.
`weights`	Vector of length `nrow(x)`, weights for the resampling. By default all observations have equal weight.
`maxcluster`	Maximum number of clusters memberships are to be computed for.
`object`	Object of class `"bclust"`.
`main`	Main title of the plot.
`...`	Optional arguments top be passed to the base method in `bclust`, ignored in `plot`.

`hclust`	Return value of the hierarchical clustering of the collection of base centers (Object of class `"hclust"`).
`cluster`	Vector with indices of the clusters the inputs are assigned to.
`centers`	Matrix of centers of the final clusters. Only useful, if the hierarchical clustering method produces convex clusters.
`allcenters`	Matrix of all `iter.base * base.centers` centers found in the base runs.

`l`	An LCA model as created by `lca`
`nsamples`	Number of bootstrap samples
`lcaiter`	Number of LCA iterations
`verbose`	If `TRUE` some output is printed during the computations.

`logl`, `loglsat`	The LogLikelihood of the models and of the corresponding saturated models
`lratio`	Likelihood quotient of the models and the corresponding saturated models
`lratiomean`, `lratiosd`	Mean and Standard deviation of `lratio`
`lratioorg`	Likelihood quotient of the original model and the corresponding saturated model
`zratio`	Z-Statistics of `lratioorg`
`pvalzratio`, `pvalratio`	P-Values for `zratio`, computed via normal distribution and empirical distribution
`chisq`	Pearson's Chisq of the models
`chisqmean`, `chisqsd`	Mean and Standard deviation of `chisq`
`chisqorg`	Pearson's Chisq of the original model
`zchisq`	Z-Statistics of `chisqorg`
`pvalzchisq`, `pvalchisq`	P-Values for `zchisq`, computed via normal distribution and empirical distribution
`nsamples`	Number of bootstrap samples
`lcaiter`	Number of LCA Iterations

`x`	Clustering result, object of class `"bclust"`.
`n`	Number of clusters to plot, by default the number of clusters used in the call of `bclust`.
`bycluster`	If `TRUE` (default), a boxplot for each cluster is plotted. If `FALSE`, a boxplot for each variable is plotted.
`main`	Main title of the plot, by default the name of the cluster object.
`oneplot`	If `TRUE`, all boxplots appear on one screen (using an appropriate rectangular layout).
`which`	Number of clusters which should be plotted, default is all clusters.
`...`	Additional arguments for `boxplot`.

`tab`	A 2-dimensional contingency table.
`match.names`	Flag whether row and columns should be matched by name.

`diag`	Percentage of data points in the main diagonal of `tab`.
`kappa`	`diag` corrected for agreement by chance.
`rand`	Rand index.
`crand`	Rand index corrected for agreement by chance.

`x`	The data matrix where columns correspond to variables and rows to observations.
`centers`	Number of clusters or initial values for cluster centers.
`iter.max`	Maximum number of iterations.
`verbose`	If `TRUE`, make some output during learning.
`dist`	Must be one of the following: If `"euclidean"`, the mean square error, if `"manhattan"`, the mean absolute error is computed. Abbreviations are also accepted.
`method`	If `"cmeans"`, then we have the $c$ -means fuzzy clustering method, if `"ufcl"` we have the on-line update. Abbreviations are also accepted.
`m`	A number greater than 1 giving the degree of fuzzification.
`rate.par`	A number between 0 and 1 giving the parameter of the learning rate for the on-line variant. The default corresponds to $0.3$ .
`weights`	a numeric vector with non-negative case weights. Recycled to the number of observations in `x` if necessary.
`control`	a list of control parameters. See Details.

`centers`	the final cluster centers.
`size`	the number of data points in each cluster of the closest hard clustering.
`cluster`	a vector of integers containing the indices of the clusters where the data points are assigned to for the closest hard clustering, as obtained by assigning points to the (first) class with maximal membership.
`iter`	the number of iterations performed.
`membership`	a matrix with the membership values of the data points to the clusters.
`withinerror`	the value of the objective function.
`call`	the call used to create the object.

`x`	A matrix of binary observations
`matching`	If TRUE an additional vector is returned which stores which row belongs to which pattern

`pat`	Numbers of patterns as described above.
`matching`	Vector giving the position of the pattern of each row of `x` in `pat`.

`x`	The data matrix, were columns correspond to the variables and rows to observations.
`centers`	Number of clusters or initial values for cluster centers
`iter.max`	Maximum number of iterations
`verbose`	If `TRUE`, make some output during learning
`dist`	Must be one of the following: If `"euclidean"`, the mean square error, if `"manhattan"`, the mean absolute error is computed. Abbreviations are also accepted.
`method`	Currently, only the `"cshell"` method; the c-shell fuzzy clustering method
`m`	The degree of fuzzification. It is defined for values greater than 1
`radius`	The radius of resulting clusters

`x`, `q`	vector or array of quantiles.
`p`	vector or array of probabilities.
`n`	number of observations.
`probs`	probabilities of the distribution.
`values`	values of the distribution.
`...`	ignored (only there for backwards compatibility)

`x`	Array of arbitrary dimensionality.
`i`	Vector of the same length as `x` has dimension.

`h`	hue
`from`	lower bound for saturation
`to`	upper bound for saturation
`v`	value

`weights`	ICA weight matrix
`projection`	Projected data
`epochs`	Number of iterations
`fun`	Name of the used function
`lrate`	Learning rate used
`initweights`	Initial weight matrix

`x`	A matrix or dataframe.
`what`	What to impute.

`X`	The matrix for which the ICA is to be computed
`lrate`	learning rate
`epochs`	number of iterations
`ncomp`	number of independent components
`fun`	function used for the nonlinear computation part

`x`	Matrix of values at which interpolation shall take place.
`a`	Array of arbitrary dimension.
`adims`	List of the same structure as `dimnames(a)`.
`method`	Interpolation method, one of `"linear"` or `"constant"`.

`x`	a numeric vector containing the values whose kurtosis is to be computed.
`na.rm`	a logical value indicating whether `NA` values should be stripped before the computation proceeds.
`type`	an integer between 1 and 3 selecting one of the algorithms for computing kurtosis detailed below.

`x`	Either a data matrix of binary observations or a list of patterns as created by `countpattern`
`k`	Number of classes used for LCA
`niter`	Number of Iterations
`matchdata`	If `TRUE` and `x` is a data matrix, the class membership of every data point is returned, otherwise the class membership of every pattern is returned.
`verbose`	If `TRUE` some output is printed during the computations.

`w`	Probabilities to belong to each class
`p`	Probabilities of a ‘1’ for each variable in each class
`matching`	Depending on `matchdata` either the class membership of each pattern or of each data point
`logl`, `loglsat`	The LogLikelihood of the model and of the saturated model
`bic`, `bicsat`	The BIC of the model and of the saturated model
`chisq`	Pearson's Chisq
`lhquot`	Likelihood quotient of the model and the saturated model
`n`	Number of data points.
`np`	Number of free parameters.

`tab`	Two-way contingency table of class memberships
`method`	One of `"rowmax"`, `"greedy"` or `"exact"`.
`iter`	Number of iterations used in greedy search.
`verbose`	If `TRUE`, display some status messages during computation.
`maxexact`	Maximum number of variables for which all possible permutations are computed.
`x`, `y`	Vectors or matrices with class memberships.

`formula`	A formula indicating cases, controls and the variables to be matched. Details are described below.
`data`	an optional data frame containing the variables in the model. By default the variables are taken from the environment which `matchControls` is called from.
`subset`	an optional vector specifying a subset of observations to be used in the matching process.
`contlabel`	A string giving the label of the control group.
`caselabel`	A string giving the labels of the cases.
`dogrep`	If `TRUE`, then `contlabel` and `contlabel` are matched using `grep`, else string comparison (exact equality) is used.
`replace`	If `FALSE`, then every control is used only once.

`cases`	Row names of cases.
`controls`	Row names of matched controls.
`factor`	A factor with 2 levels indicating cases and controls (the rest is set to `NA`.

`x`	a numeric vector containing the values whose moment is to be computed.
`order`	order of the moment to be computed, the default is to compute the first moment, i.e., the mean.
`center`	a logical value indicating whether centered moments are to be computed.
`absolute`	a logical value indicating whether absolute moments are to be computed.
`na.rm`	a logical value indicating whether `NA` values should be stripped before the computation proceeds.

`x`	A numeric matrix, or a data frame of categorical and/or numeric variables.
`y`	Class vector.
`formula`	A formula of the form `class ~ x1 + x2 + ...`. Interactions are not allowed.
`data`	Either a data frame of predictors (categorical and/or numeric) or a contingency table.
`laplace`	positive double controlling Laplace smoothing. The default (0) disables Laplace smoothing.
`...`	Currently not used.
`subset`	For data given in a data frame, an index vector specifying the cases to be used in the training sample. (NOTE: If given, this argument must be named.)
`na.action`	A function to specify the action to be taken if `NA`s are found. The default action is not to count them for the computation of the probability factors. An alternative is na.omit, which leads to rejection of cases with missing values on any required variable. (NOTE: If given, this argument must be named.)
`object`	An object of class `"naiveBayes"`.
`newdata`	A dataframe with new predictors (with possibly fewer columns than the training data). Note that the column names of `newdata` are matched against the training data ones.
`type`	If `"raw"`, the conditional a-posterior probabilities for each class are returned, and the class with maximal probability else.
`threshold`	Value replacing cells with probabilities within `eps` range.
`eps`	double for specifying an epsilon-range to apply laplace smoothing (to replace zero or close-zero probabilities by `theshold`.)

Package 'e1071'

Help Index

Find Shortest Paths Between All Nodes in a Directed Graph

Description

Usage

Arguments

Details

Value

Author(s)

References

Examples

Bagged Clustering

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Binary Combinations

Description

Usage

Arguments

Author(s)

Examples

Bootstrap Samples of LCA Results

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Boxplot of Cluster Profiles

Description

Usage

Arguments

Author(s)

Examples

Coefficients Comparing Classification Agreement

Description

Usage

Arguments

Details

Value

Author(s)

References

See Also

Examples

Fuzzy C-Means Clustering

Description

Usage

Arguments

Details

Value

Author(s)

References

Examples

Count Binary Patterns

Description

Usage

Arguments

Value

Author(s)

Examples

Fuzzy C-Shell Clustering

Description

Usage

Arguments

Details

Value

Author(s)

References

Examples

Discrete Distribution

Description

`apriori`	Class distribution for the dependent variable.
`tables`	A list of tables, one for each predictor variable. For each categorical variable a table giving, for each attribute level, the conditional probabilities given the target class. For each numeric variable, a table giving, for each target class, mean and standard deviation of the (sub-)variable.

`x`	An object of class `"stft"` as obtained by the function `stft`.
`col`	An optional colormap. By default 64 gray values are used, where white corresponds to the minimum value and black to the maximum.
`...`	further arguments to be passed to or from methods.

`x`	An object of class `svm`
`data`	data to visualize. Should be the same used for fitting.
`formula`	formula selecting the visualized two dimensions. Only needed if more than two input variables are used.
`fill`	switch indicating whether a contour plot for the class regions should be added.
`grid`	granularity for the contour plot.
`slice`	a list of named values for the dimensions held constant (only needed if more than two variables are used). The defaults for unspecified dimensions are 0 (for numeric variables) and the first level (for factors). Factor levels can either be specified as factors or character vectors of length 1.
`symbolPalette`	Color palette used for the class the data points and support vectors belong to.
`svSymbol`	Symbol used for support vectors.
`dataSymbol`	Symbol used for data points (other than support vectors).
`...`	additional graphics parameters passed to `filled.contour` and `plot`.

`x`	an object of class `tune`
`type`	choose whether a contour plot or a perspective plot is used if two parameters are to be visualized. Ignored if only one parameter has been tuned.
`theta`	angle of azimuthal direction.
`col`	the color(s) of the surface facets. Transparent colors are ignored.
`main`	main title
`xlab`, `ylab`	titles for the axes. N.B. These must be character strings; expressions are not accepted. Numbers will be coerced to character strings.
`swapxy`	if `TRUE`, the parameter axes are swaped (only used in case of two parameters).
`transform.x`, `transform.y`, `transform.z`	functions to transform the parameters (`x` and `y`) and the error measures (`z`). Ignored if `NULL`.
`color.palette`	color palette used in contour plot.
`nlevels`	number of levels used in contour plot.
`...`	Further graphics parameters.

`object`	Object of class `"svm"`, created by `svm`.
`newdata`	An object containing the new input data: either a matrix or a sparse matrix (object of class `Matrix` provided by the Matrix package, or of class `matrix.csr` provided by the SparseM package, or of class `simple_triplet_matrix` provided by the slam package). A vector will be transformed to a n x 1 matrix.
`decision.values`	Logical controlling whether the decision values of all binary classifiers computed in multiclass classification shall be computed and returned.
`probability`	Logical indicating whether class probabilities should be computed and returned. Only possible if the model was fitted with the `probability` option enabled.
`na.action`	A function to specify the action to be taken if ‘NA’s are found. The default action is `na.omit`, which leads to rejection of cases with missing values on any required variable. An alternative is `na.fail`, which causes an error if `NA` cases are found. (NOTE: If given, this argument must be named.)
`...`	Currently not used.

`x`	A data vector for `probplot`, an object of class `probplot` for the `lines` method.
`qdist`	A character string or a function for the quantiles of the target distribution.
`probs`	Vector of probabilities at which horizontal lines should be drawn.
`line`	Add a line passing through the quartiles to the plot?
`xlab`, `ylab`	Graphical parameters.
`h`	The y-value for a horizontal line.
`v`	The x-value for a vertical line.
`bend`	If `TRUE`, lines are “bent” at the quartile line, else regular `abline`s are added. See examples.
`...`	Further arguments for `qdist` and graphical parameters for lines.

`end`	the time of the last observation.
`frequency`	the number of observations per unit of time.

`x`	An object of class `matrix.csr`
`y`	A vector (either numeric or a factor)
`file`	The filename.
`fac`	If `TRUE`, the y-values (if any) are interpreted as factor levels.
`ncol`	Number of columns, detected automatically. Can be used to add empty columns (possibly not stored in the sparse format).

`x`	object of class `matrix.csr`
`y`	vector of numeric values or factor levels, depending on `fac`.

`x`	a data frame or a numeric matrix (or vector). For matrices or vectors, `scale()` is used.
`center`	either a logical value or numeric-alike vector of length equal to the number of columns of `x`, where ‘numeric-alike’ means that `as.numeric(.)` will be applied successfully if `is.numeric(.)` is not true.
`scale`	either a logical value or a numeric-alike vector of length equal to the number of columns of `x`.