analytics
The ANCOVA class supports ANalysis of COVAraiance (ANCOVA).
The ANCOVA class supports ANalysis of COVAraiance (ANCOVA). It allows
the addition of a categorical treatment variable 't' into a multiple linear
regression. This is done by introducing dummy variables 'dj' to distinguish
the treatment level. The problem is again to fit the parameter vector 'b'
in the augmented regression equation
y = b dot x + e = b0 + b_1 * x_1 + b_2 * x_2 + ... b_k * x_k + b_k+1 * d_1 + b_k+2 * d_2 + ... b_k+l * d_l + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y
where 'x_pinv' is the pseudo-inverse.
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
The ANOVA class supports one-way ANalysis Of VAraiance (ANOVA).
The ANOVA class supports one-way ANalysis Of VAraiance (ANOVA). It is
framed using GLM notation and supports the use of one binary/categorical
treatment variable 't'. This is done by introducing dummy variables 'd_j' to
distinguish the treatment level. The problem is again to fit the parameter
vector 'b' in the following equation
y = b dot x + e = b_0 + b_1 * d_1 + b_1 * d_2 ... b_k * d_k + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y
where 'x_pinv' is the pseudo-inverse.
http://psych.colorado.edu/~carey/Courses/PSYC5741/handouts/GLM%20Theory.pdf
The ARMA class provide basic time series analysis capabilities for Auto-
Regressive (AR) and Moving Average (MA) models.
The ARMA class provide basic time series analysis capabilities for Auto-
Regressive (AR) and Moving Average (MA) models. In an 'ARMA(p, q)' model,
'p' and 'q' refer to the order of the Auto-Regressive and Moving Average
components of the model. ARMA models are often used for forecasting.
The AugNaiveBayes class implements an Integer-Based Tree Auguments Naive Bayes
Classifier, which is a commonly used such classifier for discrete input data.
The AugNaiveBayes class implements an Integer-Based Tree Auguments Naive Bayes
Classifier, which is a commonly used such classifier for discrete input data.
The classifier is trained using a data matrix 'x' and a classification vector 'y'.
Each data vector in the matrix is classified into one of 'k' classes numbered
0, ..., k-1. Prior probabilities are calculated based on the population of
each class in the training-set. Relative posterior probabilities are computed
by multiplying these by values computed using conditional probabilities. The
classifier supports limited dependency between features/variables.
The BayesNetwork class implements a Bayesian Network Classifier.
The BayesNetwork class implements a Bayesian Network Classifier. It
classifies a data vector 'z' by determining which of 'k' classes has the
highest Joint Probability of 'z' and the outcome (i.e., one of the 'k'
classes) of occurring. The Joint Probability calculation is factored
into multiple calculations of Conditional Probability. Conditional
dependencies are specified using a Directed Acyclic Graph (DAG). Nodes
are conditionally dependent on their parents only. Conditional probability
are recorded in tables. Training is achieved by ...
The CanCorrelation class performs Canonical Correlation Analysis (CCA)
on two random vectors.
The CanCorrelation class performs Canonical Correlation Analysis (CCA)
on two random vectors. Samples for the first one are stored in the 'x'
data matrix and samples for the second are stored in the 'y' data matrix.
Find vectors a and b that maximize the correlation between x * a and y * b.
max {rho (x * a, y * b)}
Additional vectors orthogonal to a and b can also be found.
The Classifier trait provides a common framework for several classifiers.
The ClassifierInt abstract class provides a common foundation for several
classifiers that operate on integer-valued data.
The ClassifierReal abstract class provides a common foundation for several
classifiers that operate on real-valued data.
The Clusterer trait provides a common framework for several clustering
algorithms.
The 'DAG' class provides a data structure for storing directed acyclic graphs.
The DecisionTreeC45 class implements a Decision Tree classifier using the
C4.5 algorithm.
The DecisionTreeC45 class implements a Decision Tree classifier using the
C4.5 algorithm. The classifier is trained using a data matrix 'x' and a
classification vector 'y'. Each data vector in the matrix is classified into
one of 'k' classes numbered '0, ..., k-1'. Each column in the matrix represents
a feature (e.g., Humidity). The 'vc' array gives the number of distinct values
per feature (e.g., 2 for Humidity).
The DecisionTreeID3 class implements a Decision Tree classifier using the
ID3 algorithm.
The DecisionTreeID3 class implements a Decision Tree classifier using the
ID3 algorithm. The classifier is trained using a data matrix 'x' and a
classification vector 'y'. Each data vector in the matrix is classified into
one of 'k' classes numbered '0, ..., k-1'. Each column in the matrix represents
a feature (e.g., Humidity). The 'vc' array gives the number of distinct values
per feature (e.g., 2 for Humidity).
The ExpRegression class supports exponential regression.
The ExpRegression class supports exponential regression. In this case,
'x' is multi-dimensional [1, x_1, ... x_k]. Fit the parameter vector 'b' in the
exponential regression equation
log (mu (x)) = b dot x = b_0 + b_1 * x_1 + ... b_k * x_k
www.stat.uni-muenchen.de/~leiten/Lehre/Material/GLM_0708/chapterGLM.pdf
A General Linear Model (GLM) can be developed using the GLM trait and object
(see below).
A General Linear Model (GLM) can be developed using the GLM trait and object
(see below). The implementation currently supports univariate models with
multivariate models (where each response is a vector) planned for the future.
It provides factory methods for the following special types of GLMs:
SimpleRegression - simple linear regression,
Regression - multiple linear regression using OLS
Regression_WLS - multiple linear regression using WLS
RidgeRegression - robust multiple linear regression,
TranRegression - transformed (e.g., log) multiple linear regression,
PolyRegression - polynomial regression,
TrigRegression - trigonometric regression
ResponseSurface - response surface regression,
ANOVA - GLM form of ANalysis Of VAriance,
ANCOVA - GLM form of ANalysis of COVAriance.
The HiddenMarkov classes provides Hidden Markov Models (HMM).
The HiddenMarkov classes provides Hidden Markov Models (HMM). An HMM model
consists of a probability vector 'pi' and probability matrices 'a' and 'b'.
The discrete-time system is characterized by a hidden 'state(t)' and an
'observed(t)' symbol at time 't'.
pi(j) = P(state(t) = j) a(i, j) = P(state(t+1) = j|state(t) = i) b(i, k) = P(observed(t) = k|state(t) = i)
http://www.cs.sjsu.edu/faculty/stamp/RUA/HMM.pdf
Cluster several vectors/points using hierarchical clustering.
Cluster several vectors/points using hierarchical clustering. Start with each point forming its own cluster and merge clusters until there are only 'k'.
The KMeansClustering class cluster several vectors/points using k-means
clustering.
The KMeansClustering class cluster several vectors/points using k-means
clustering. Either (1) randomly assign points to 'k' clusters or (2) randomly
pick 'k' points as initial centroids (technique (1) to work better and is the
primary technique). Iteratively, reassign each point to the cluster containing
the closest centroid. Stop when there are no changes to the clusters.
The KNN_Classifier class is used to classify a new vector 'z' into one of
'k' classes.
The KNN_Classifier class is used to classify a new vector 'z' into one of
'k' classes. It works by finding its 'knn' nearest neighbors. These neighbors
essentially vote according to their classification. The class with most
votes is selected as the classification of 'z'. Using a distance metric,
the 'knn' vectors nearest to 'z' are found in the training data, which is
stored row-wise in the data matrix 'x'. The corresponding classifications
are given in the vector 'y', such that the classification for vector 'x(i)'
is given by 'y(i)'.
The LogisticRegression class supports (binomial) logistic regression.
The LogisticRegression class supports (binomial) logistic regression. In this
case, 'x' may be multi-dimensional '[1, x_1, ... x_k]'. Fit the parameter
vector 'b' in the logistic regression equation
y = b dot x + e = b_0 + b_1 * x_1 + ... b_k * x_k + e
where 'e' represents the residuals (the part not explained by the model) and 'y' is now binary.
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
The MarkovClustering class implements a Markov Clustering Algorithm (MCL)
and is used to cluster nodes in a graph.
The MarkovClustering class implements a Markov Clustering Algorithm (MCL)
and is used to cluster nodes in a graph. The graph is represented as an
edge-weighted adjacency matrix (a non-zero cell indicates nodes i and j are
connected).
The primary constructor takes either a graph (adjacency matrix) or a Markov transition matrix as input. If a graph is passed in, the normalize method must be called to convert it into a Markov transition matrix. Before normalizing, it may be helpful to add self loops to the graph. The matrix (graph or transition) may be either dense or sparse. See the MarkovClusteringTest object at the bottom of the file for examples.
The NMFactorization class factors a matrix 'v' into two non negative matrices
'w' and 'h' such that v = wh approximately.
The NMFactorization class factors a matrix 'v' into two non negative matrices
'w' and 'h' such that v = wh approximately.
http://en.wikipedia.org/wiki/Non-negative_matrix_factorization
The NaiveBayes class implements an Integer-Based Naive Bayes Classifier,
which is a commonly used such classifier for discrete input data.
The NaiveBayes class implements an Integer-Based Naive Bayes Classifier,
which is a commonly used such classifier for discrete input data. The
classifier is trained using a data matrix 'x' and a classification vector 'y'.
Each data vector in the matrix is classified into one of 'k' classes numbered
0, ..., k-1. Prior probabilities are calculated based on the population of
each class in the training-set. Relative posterior probabilities are computed
by multiplying these by values computed using conditional probabilities. The
classifier is naive, because it assumes feature independence and therefore
simply multiplies the conditional probabilities.
The NaiveBayesR class implements a Gaussian Naive Bayes Classifier, which
is the most commonly used such classifier for continuous input data.
The NaiveBayesR class implements a Gaussian Naive Bayes Classifier, which
is the most commonly used such classifier for continuous input data. The
classifier is trained using a data matrix 'x' and a classification vector 'y'.
Each data vector in the matrix is classified into one of 'k' classes numbered
0, ..., k-1. Prior probabilities are calculated based on the population of
each class in the training-set. Relative posterior probabilities are computed
by multiplying these by values computed using conditional density functions
based on the Normal (Gaussian) distribution. The classifier is naive, because
it assumes feature independence and therefore simply multiplies the conditional
densities.
The NeuralNet class supports basic 3-layer (input, hidden and output) Neural
Networks.
The NeuralNet class supports basic 3-layer (input, hidden and output) Neural
Networks. Given several input and output vectors (training data), fit the weights
connecting the layers, so that for a new input vector 'zi', the net can predict
the output vector 'zo' ('zh' is the itermediate value at the hidden layer), i.e.,
zi --> zh = f (w * zi) --> zo = g (v * zh)
Note, w_0 and v_0 are treated as biases, so zi_0 and zh_0 must be 1.0.
The NonLinRegression class supports non-linear regression.
The NonLinRegression class supports non-linear regression. In this case,
'x' can be multi-dimensional [1, x1, ... xk] and the function 'f' is non-linear
in the parameters 'b'. Fit the parameter vector 'b' in the regression equation
y = f(x, b) + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector 'b' by using Non-linear Programming to minimize Sum of Squares Error (SSE).
www.bsos.umd.edu/socy/alan/stats/socy602_handouts/kut86916_ch13.pdf
The Perceptron class supports single-valued 2-layer (input and output)
Neural-Networks.
The Perceptron class supports single-valued 2-layer (input and output)
Neural-Networks. Given several input vectors and output values (training data),
fit the weights 'w' connecting the layers, so that for a new
input vector 'zi', the net can predict the output value 'zo', i.e.,
'zi --> zo = f (w dot zi)'.
Note, w0 is treated as the bias, so x0 must be 1.0.
The PoissonRegression class supports Poisson regression.
The PoissonRegression class supports Poisson regression. In this case,
x' may be multi-dimensional '[1, x_1, ... x_k]'. Fit the parameter
vector 'b' in the Poisson regression equation
log (mu(x)) = b dot x = b_0 + b_1 * x_1 + ... b_k * x_k
where 'e' represents the residuals (the part not explained by the model) and 'y' is now integer valued.
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
The PolyRegression class supports polynomial regression.
The PolyRegression class supports polynomial regression. In this case,
't' is expanded to [1, t, t2 ... tk]. Fit the parameter vector 'b' in the
regression equation
y = b dot x + e = b_0 + b_1 * t + b_2 * t2 ... b_k * tk + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y
where 'x_pinv' is the pseudo-inverse.
www.ams.sunysb.edu/~zhu/ams57213/Team3.pptx
The Predictor trait provides a common framework for several predictors.
The PrincipalComponents class performs the Principal Component Analysis (PCA)
on data matrix 'x'.
The PrincipalComponents class performs the Principal Component Analysis (PCA)
on data matrix 'x'. It can be used to reduce the dimensionality of the data.
First find the PCs by calling 'findPCs' and then call 'reduce' to reduce
the data (i.e., reduce matrix 'x' to a lower dimensionality matrix).
The RandomGraph class generates random undirected graphs with clusters
(as adjacency matrices).
The Reducer trait provides a common framework for several data reduction
algorithms.
The Regression class supports multiple linear regression.
The Regression class supports multiple linear regression. In this case,
'x' is multi-dimensional [1, x_1, ... x_k]. Fit the parameter vector 'b' in
the regression equation
y = b dot x + e = b_0 + b_1 * x_1 + ... b_k * x_k + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y [ alternative: b = solve (y) ]
where 'x_pinv' is the pseudo-inverse. Three techniques are provided:
Fac_QR // QR Factorization: slower, more stable (default) Fac_Cholesky // Cholesky Factorization: faster, less stable (reasonable choice) Inverse // Inverse/Gaussian Elimination, classical textbook technique (outdated)
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
The Regression_WLS class supports weighted multiple linear regression.
The Regression_WLS class supports weighted multiple linear regression.
In this case, 'x' is multi-dimensional [1, x_1, ... x_k]. Fit the parameter
vector 'b' in the regression equation
y = b dot x + e = b_0 + b_1 * x_1 + ... b_k * x_k + e
where 'e' represents the residuals (the part not explained by the model). Use Weighted Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y [ alternative: b = solve (y) ]
where 'x_pinv' is the pseudo-inverse. Three techniques are provided:
Fac_QR // QR Factorization: slower, more stable (default) Fac_Cholesky // Cholesky Factorization: faster, less stable (reasonable choice) Inverse // Inverse/Gaussian Elimination, classical textbook technique (outdated)
www.markirwin.net/stat149/Lecture/Lecture3.pdf
The ResponseSurface class uses multiple regression to fit a quadratic/cubic
surface to the data.
The ResponseSurface class uses multiple regression to fit a quadratic/cubic
surface to the data. For example in 2D, the quadratic regression equation is
y = b dot x + e = [b_0, ... b_k] dot [1, x_0, x_02, x_1, x_0*x_1, x_12] + e
scalation.metamodel.QuadraticFit
The RidgeRegression class supports multiple linear regression.
The RidgeRegression class supports multiple linear regression. In this
case, 'x' is multi-dimensional [x_1, ... x_k]. Both the input matrix 'x' and
the response vector 'y' are centered (zero mean). Fit the parameter vector
'b' in the regression equation
y = b dot x + e = b_1 * x_1 + ... b_k * x_k + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y [ alternative: b = solve (y) ]
where 'x_pinv' is the pseudo-inverse. Three techniques are provided:
Fac_QR // QR Factorization: slower, more stable (default) Fac_Cholesky // Cholesky Factorization: faster, less stable (reasonable choice) Inverse // Inverse/Gaussian Elimination, classical textbook technique (outdated)
see http://statweb.stanford.edu/~tibs/ElemStatLearn/
The SimpleRegression class supports simple linear regression.
The SimpleRegression class supports simple linear regression. In this case,
the vector 'x' consists of the constant one and a single variable 'x_1', i.e.,
(1, x_1). Fit the parameter vector 'b' in the regression equation
y = b dot x + e = (b_0, b_1) dot (1, x_1) + e = b_0 + b_1 * x_1 + e
where 'e' represents the residuals (the part not explained by the model).
The SupportVectorMachine class is a translation of Pseudo-Code from a
modified SMO (Modification 2) found at the above URL's into Scala and includes
a few simplifications (e.g., currently only works for linear kernels, dense
data and binary classification).
The TranRegression class supports transformed multiple linear regression.
The TranRegression class supports transformed multiple linear regression.
In this case, 'x' is multi-dimensional [1, x_1, ... x_k]. Fit the parameter
vector 'b' in the transformed regression equation
transform (y) = b dot x + e = b_0 + b_1 * x_1 + b_2 * x_2 ... b_k * x_k + e
where 'e' represents the residuals (the part not explained by the model) and 'transform' is the function (defaults to log) used to transform the response vector 'y'. Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y
where 'x_pinv' is the pseudo-inverse.
www.ams.sunysb.edu/~zhu/ams57213/Team3.pptx
The TrigRegression class supports trigonometric regression.
The TrigRegression class supports trigonometric regression. In this case,
't' is expanded to [1, sin (wt), cos (wt), sin (2wt), cos (2wt), ...].
Fit the parameter vector 'b' in the regression equation
y = b dot x + e = b_0 + b_1 sin (wt) + b_2 cos (wt) + b_3 sin (2wt) + b_4 cos (2wt) + ... + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to fit the parameter vector
b = x_pinv * y
where 'x_pinv' is the pseudo-inverse. http://link.springer.com/article/10.1023%2FA%3A1022436007242#page-1
The ANCOVATest object tests the ANCOVA class using the following
regression equation.
The ANCOVATest object tests the ANCOVA class using the following
regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*d_1 + b_4*d_2
The ANOVATest object tests the ANOVA class using the following
regression equation.
The ANOVATest object tests the ANOVA class using the following
regression equation.
y = b dot x = b_0 + b_1*d_1 + b_2*d_2
The ARMATest object is used to test the ARMA class.
AugNaiveBayes is the companion object for the AugNaiveBayes class.
The AugNaiveBayesTestInt object is used to test the 'AugNaiveBayes' class.
The AugNaiveBayesTestInt object is used to test the 'AugNaiveBayes' class.
* Ex: Classify whether a car is more likely to be stolen (1) or not (1).
http://www.inf.u-szeged.hu/~ormandi/ai2/06-naiveBayes-example.pdf
The AugNaiveBayesTest2 object is used to test the 'AugNaiveBayes' class.
The AugNaiveBayesTest2 object is used to test the 'AugNaiveBayes' class.
Given whether a person is Fast and/or Strong, classify them as making C = 1
or not making C = 0 the football team.
The BayesNetworkTest object is used to test the BayesNetwork class.
The BayesNetworkTest object is used to test the BayesNetwork class.
Ex: Classify whether a person has a Back Ache.
www.eng.tau.ac.il/~bengal/BN.pdf
DecisionTreeC45 is the companion object for the DecisionTreeC45 class.
The DecisionTreeC45Test object is used to test the DecisionTreeC45 class.
The DecisionTreeC45Test object is used to test the DecisionTreeC45 class.
Ex: Classify (No/Yes) whether a person will play tennis based on the measured
features.
http://www.cise.ufl.edu/~ddd/cap6635/Fall-97/Short-papers/2.htm
DecisionTreeID3 is the companion object for the DecisionTreeID3 class.
The DecisionTreeID3Test object is used to test the DecisionTreeID3 class.
The DecisionTreeID3Test object is used to test the DecisionTreeID3 class.
Ex: Classify (No/Yes) whether a person will play tennis based on the measured
features.
http://www.cise.ufl.edu/~ddd/cap6635/Fall-97/Short-papers/2.htm
The ExpRegressionTest object tests ExpRegression class using the following
exponentail regression problem.
The ExpRegressionTest2 object has a basic test for the ExpRegression class.
The GLM object makes the GLM trait's methods directly available.
The GLM object makes the GLM trait's methods directly available.
This approach (using traits and objects) allows the methods to also be inherited.
The GLMTest object tests the GLM object using the following regression
equation.
The GLMTest object tests the GLM object using the following regression
equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*d_1 + b_4*d_2
A Generalized Linear Model (GZLM) can be developed using the GZLM object.
A Generalized Linear Model (GZLM) can be developed using the GZLM object.
It provides factory methods for General Linear Models (GLM) via inheritance
and for proper Generalized Linear Models:
LogisticRegression - logistic regression,
PoissonRegression - Poisson regression,
ExpRegression - Exponential regression,
The GZLMTest object tests the GZLM object using the following regression
equation.
The GZLMTest object tests the GZLM object using the following regression
equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*d_1 + b_4*d_2
The HiddenMarkovTest object is used to test the HiddenMarkov class.
The HierClusteringTest object is used to test the HierClustering class.
The KMeansClusteringTest object is used to test the KMeansClustering class.
The KNN_ClassifierTest object is used to test the KNN_Classifier class.
The LogisticFunction object contains Activation functions.
The LogisticRegressionTest object tests the LogisticRegression class.
The LogisticRegressionTest object tests the LogisticRegression class.
www.cookbook-r.com/Statistical_analysis/Logistic_regression/ Answer: b = (-8.8331, 0.4304), n_dev = 43.860, r_dev = 25.533, aci = 29.533, pseudo_rSq = 0.4178
The LogisticRegressionTest object tests the LogisticRegression class.
The LogisticRegressionTest object tests the LogisticRegression class.
www.stat.wisc.edu/~mchung/teaching/.../GLM.logistic.Rpackage.pdf
statmaster.sdu.dk/courses/st111/module03/index.html
The MarkovClusteringTest object is used to test the MarkovClustering class.
The MarkovClusteringTest object is used to test the MarkovClustering class.
www.cs.ucsb.edu/~xyan/classes/CS595D-2009winter/MCL_Presentation2.pdf
The NMFactorizationTest object to test NMFactorizationTest class.
NaiveBayes is the companion object for the NaiveBayes class.
The NaiveBayesRTest object is used to test the 'NaiveBayesR' class.
The NaiveBayesRTest object is used to test the 'NaiveBayesR' class.
* Ex: Classify whether a person is male (M) or female (F) based on the measured features.
http://en.wikipedia.org/wiki/Naive_Bayes_classifier
The NaiveBayesTestInt object is used to test the 'NaiveBayes' class.
The NaiveBayesTestInt object is used to test the 'NaiveBayes' class.
* Ex: Classify whether a car is more likely to be stolen (1) or not (1).
http://www.inf.u-szeged.hu/~ormandi/ai2/06-naiveBayes-example.pdf
The NaiveBayesTest2 object is used to test the 'NaiveBayes' class.
The NaiveBayesTest2 object is used to test the 'NaiveBayes' class.
Given whether a person is Fast and/or Strong, classify them as making C = 1
or not making C = 0 the football team.
The NeuralNetTest object is used to test the NeuralNet class.
The NeuralNetTest object is used to test the NeuralNet class. For this
test, the initial weights are used for used for prediction.
The NeuralNetTest2 object is used to test the NeuralNet class.
The NeuralNetTest2 object is used to test the NeuralNet class. For this
test, training data is used to fit the weights before using them for prediction.
http://www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf
The NonLinRegressionTest object tests the NonLinRegression class:
y = f(x; b) = b0 + exp (b1 * x0).
The NonLinRegressionTest object tests the NonLinRegression class:
y = f(x; b) = b0 + exp (b1 * x0).
www.bsos.umd.edu/socy/alan/stats/socy602_handouts/kut86916_ch13.pdf Answers: sse = 49.45929986243339 fit = (VectorD (58.606566327280426, -0.03958645286504356), 0.9874574894685292) predict (VectorD (50.0)) = 8.09724678182599 FIX: check this example
The PerceptronTest object is used to test the Perceptron class.
The PerceptronTest object is used to test the Perceptron class. For this
test, the initial weights are used for used for prediction.
The PerceptronTest2 object is used to test the Perceptron class.
The PerceptronTest2 object is used to test the Perceptron class. For this
test, training data is used to fit the weights before using them for prediction.
http://www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf
The PoissonRegression object tests the PoissonRegression class.
The PoissonRegression object tests the PoissonRegression class.
http://www.cookbook-r.com/Statistical_analysis/Logistic_regression/ Answer: b = (-8.8331, 0.4304), n_dev = 43.860, r_dev = 25.533, aci = 29.533, pseudo_rSq = 0.4178
The PoissonRegressionTest2 object tests the PoissonRegression class.
The PoissonRegressionTest2 object tests the PoissonRegression class.
www.stat.wisc.edu/~mchung/teaching/.../GLM.logistic.Rpackage.pdf
statmaster.sdu.dk/courses/st111/module03/index.html
The PolyRegressionTest object tests PolyRegression class using the following
regression equation.
The PolyRegressionTest object tests PolyRegression class using the following
regression equation.
y = b dot x = b_0 + b_1*t + b_2*t^2.
The PrincipalComponentsTest object is used to test the PrincipalComponents class.
The PrincipalComponentsTest object is used to test the PrincipalComponents class.
http://www.ce.yildiz.edu.tr/personal/songul/file/1097/principal_components.pdf
The Probability object provides methods for operating on univariate and
bivariate probability distributions of discrete random variables 'X' and 'Y'.
The Probability object provides methods for operating on univariate and
bivariate probability distributions of discrete random variables 'X' and 'Y'.
A probability distribution is specified by its probabilty mass functions (pmf)
stored either as a "probabilty vector" for a univariate distribution or
a "probability matrix" for a bivariate distribution.
joint probability matrix: pxy(i, j) = P(X = x_i, Y = y_j) marginal probability vector: px(i) = P(X = x_i) conditional probability matrix: px_y(i, j) = P(X = x_i|Y = y_j)
In addition to computing joint, marginal and conditional probabilities, methods for computing entropy and mutual information are also provided. Entropy provides a measure of disorder or randomness. If there is little randomness, entropy will close to 0, while when randomness is high, entropy will be close to, e.g., log2 (px.dim). Mutual information provides a robust measure of dependency between random variables (constrast with correletion).
scalation.stat.StatVector
The ProbabilityTest object is used to test the Probability object.
The ProbabilityTest2 provides upper bound for 'entropy' and 'entropy_k'.
The RandomGraphTest object is used to test the RandomGraph class.
The RegTechnique object defines the implementation techniques available.
The RegressionTest object tests Regression class using the following
regression equation.
The RegressionTest object tests Regression class using the following
regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2.
Test regression and backward elimination.
http://statmaster.sdu.dk/courses/st111/module03/index.html
The RegressionTest2 object tests Regression class using the following
regression equation.
The RegressionTest2 object tests Regression class using the following
regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
Test regression using QR Decomposition and Gaussian Elimination for computing the pseudo-inverse.
The RegressionTest3 object tests the multi-colinearity method in the
Regression class using the following regression equation.
The RegressionTest3 object tests the multi-colinearity method in the
Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
The Regression_WLSTest object tests Regression_WLS class using the following
regression equation.
The Regression_WLSTest object tests Regression_WLS class using the following
regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2.
Test regression and backward elimination.
http://statmaster.sdu.dk/courses/st111/module03/index.html
The ResponseSurfaceTest object is used to test the ResponseSurface class.
The RidgeRegression companion object is used to center the input matrix 'x'.
The RidgeRegression companion object is used to center the input matrix 'x'.
This is done by subtracting the column means from each value.
The RidgeRegressionTest object tests RidgeRegression class using the following
regression equation.
The RidgeRegressionTest object tests RidgeRegression class using the following
regression equation.
y = b dot x = b_1*x_1 + b_2*x_2.
Test regression and backward elimination.
http://statmaster.sdu.dk/courses/st111/module03/index.html
The RidgeRegressionTest2 object tests RidgeRegression class using the following
regression equation.
The RidgeRegressionTest2 object tests RidgeRegression class using the following
regression equation.
y = b dot x = b_1*x1 + b_2*x_2.
Test regression using QR Decomposition and Gaussian Elimination for computing the pseudo-inverse.
The RidgeRegressionTest3 object tests the multi-colinearity method in the
RidgeRegression class using the following regression equation.
The RidgeRegressionTest3 object tests the multi-colinearity method in the
RidgeRegression class using the following regression equation.
y = b dot x = b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
Object to test SimpleRegression class: y = b dot x = (b_0, b_1) dot (1, x_1).
Object to test SimpleRegression class: y = b dot x = (b_0, b_1) dot (1, x_1).
http://www.analyzemath.com/statistics/linear_regression.html
The SimpleRegressionTest2 object to test SimpleRegression class:
The SimpleRegressionTest2 object to test SimpleRegression class:
y = b dot x = b_0 + b_1*x_1.
http://mathbits.com/mathbits/tisection/Statistics2/linear.htm
The SupportVectorMachineTest is used to test the SupportVectorMachine class.
The SupportVectorMachineTest2 is used to test the SupportVectorMachine class.
The TranRegressionTest object tests TranRegression class using the following
regression equation.
The TranRegressionTest object tests TranRegression class using the following
regression equation.
log (y) = b dot x = b_0 + b_1*x_1 + b_2*x_2.
The TrigRegressionTest object tests TrigRegression class using the following
regression equation.
The TrigRegressionTest object tests TrigRegression class using the following
regression equation.
y = b dot x = b_0 + b_1*t + b_2*t^2.
The analytics package contains classes, traits and objects for analytics including classification, clustering and prediction.