analytics

package analytics

The analytics package contains classes, traits and objects for analytics.

Linear Supertypes

Error, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

analytics
Error
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

case class AFF(f: FunctionS2S, fV: FunctionV_2V, fM: FunctionM_2M, dV: FunctionV_2V, dM: FunctionM_2M, bounds: PairD = null) extends Product with Serializable
The AFF class holds an Activation Function Family (AFF).
The AFF class holds an Activation Function Family (AFF).
f
the activation function itself
fV
the vector version of the activation function
fM
the matrix version of the activation function
dV
the vector version of the activation function derivative
dM
the matrix version of the activation function derivative
bounds
the (lower, upper) bounds on the range of the activation function
class ANCOVA extends Regression with ExpandableVariable
The ANCOVA class supports ANalysis of COVAriance 'ANCOVA'.
The ANCOVA class supports ANalysis of COVAriance '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 solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)
't' has categorical values/levels, e.g., treatment levels (0, ... 't.max ()')

See also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
class ANCOVA1 extends Regression with ExpandableVariable
The ANCOVA1 class supports ANalysis of COVAriance 'ANCOVA1'.
The ANCOVA1 class supports ANalysis of COVAriance 'ANCOVA1'. 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 solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)
't' has categorical values/levels, e.g., treatment levels (0, ... 't.max ()')

See also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
class ANOVA1 extends Regression with ExpandableVariable
The ANOVA1 class supports one-way ANalysis Of VAriance (ANOVA), i.e, it allows only one binary/categorial treatment variable.
The ANOVA1 class supports one-way ANalysis Of VAriance (ANOVA), i.e, it allows only one binary/categorial treatment variable. It is framed using General Linear Model '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 solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)

See also
ANCOVA for models with multiple variables
psych.colorado.edu/~carey/Courses/PSYC5741/handouts/GLM%20Theory.pdf
case class AddGate() extends Product with Serializable
Perform Add for vectors.
class CanCorrelation extends Reducer with Error
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.
class CoFilter_1D extends AnyRef
The CoFilter_1D class provides a convolution filter (cofilter) for taking a weighted average over a window of an input vector.
class ConvNet_1D extends PredictorMat2
The ConvNet_1D class implements a Convolutionsl Network model.
The ConvNet_1D class implements a Convolutionsl Network model. The model is trained using a data matrix 'x' and response vector 'y'.
class CoordDescentLasso extends AnyRef
The CoordDescentLasso class find the optimal parameters 'b' using Coordinate Descent.
class CubicRegression extends Regression with ExpandableForms
The CubicRegression class uses multiple regression to fit a cubic with cross-terms surface to the data.
The CubicRegression class uses multiple regression to fit a cubic with cross-terms surface to the data. For example in 2D, the cubic cross-terms regression equation is
y = b dot x + e = [b_0, ... b_k] dot [1, x_0, x_0^{2, x_0}3, x_1, x_1^{2, x_1}3, x_0*x_1, x_0^{2*x_1, x_0*x_1}2] + e
Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

See also
scalation.metamodel.QuadraticFit
class CubicXRegression extends Regression with ExpandableForms
The CubicXRegression class uses multiple regression to fit a cubic with cross-terms surface to the data.
The CubicXRegression class uses multiple regression to fit a cubic with cross-terms surface to the data. For example in 2D, the cubic cross-terms regression equation is
y = b dot x + e = [b_0, ... b_k] dot [1, x_0, x_0^{2, x_0}3, x_1, x_1^{2, x_1}3, x_0*x_1, x_0^{2*x_1, x_0*x_1}2] + e
Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

See also
scalation.metamodel.QuadraticFit
class ELM_3L extends PredictorMat2
The ELM_3L class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines.
The ELM_3L class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = f1 (b * f0 (a * v))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, ELM_3L explicitly adds bias. FIX: use TranRegression to allow 'f1' to be other activation functions besides 'f_id'.
class ELM_3L1 extends PredictorMat
The ELM_3L1 class supports single-output, 3-layer (input, hidden and output) Extreme-Learning Machines.
The ELM_3L1 class supports single-output, 3-layer (input, hidden and output) Extreme-Learning Machines. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = f1 (b * f0 (a * v))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, ELM_3L1 explicitly adds bias. Note: only uses 'f_id' implicitly, use ELM_3L for other options for 'f1'.
class ExpRegression extends PredictorMat
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

See also
www.stat.uni-muenchen.de/~leiten/Lehre/Material/GLM_0708/chapterGLM.pdf
trait ExpandableForms extends AnyRef
The ExpandableForms trait provides the framwork for expanding a vector to include additional terms.
trait ExpandableVariable extends AnyRef
The ExpandableVariable trait provides the framwork for replacing categorical variables with dummy variables.
The ExpandableVariable trait provides the framwork for replacing categorical variables with dummy variables. A dummy variable having 'n' levels is replaced with 'n-1' dummy variables.
class Fit extends QoF with Error
The Fit class provides methods to determine basic Quality of Fit 'QoF' measures.
type FunctionP2S = (VectoD, VectoD) ⇒ Double
Function from PairV to Scalar (Double)
class HyperParameter extends Cloneable
The HyperParameter class provides a simple and flexible means for handling model hyper-parameters.
The HyperParameter class provides a simple and flexible means for handling model hyper-parameters. A model may have one or more hyper-parameters that are organized into a map 'name -> (value, defaultV)'.
trait Imputation extends AnyRef
The Imputation trait specifies an imputation operation called 'impute' to be defined by the objects implementing it, i.e., ImputeRegression - impute missing values using SimpleRegression ImputeForward - impute missing values using previous values and slopes ImputeBackward - impute missing values using subsequent values and slopes ImputeMean - impute missing values usind the filtered mean ImputeNormal - impute missing values using the median of Normal random variates ImputeMovingAvg - impute missing values using the moving average ImputeNormalWin - impute missing values using the median of Normal random variates for a window
type Ints = IndexedSeq[Int]
Shorthand for array of integers
class KNN_Predictor extends PredictorMat
The KNN_Predictor class is used to predict a response value for new vector 'z'.
The KNN_Predictor class is used to predict a response value for new vector 'z'. It works by finding its 'kappa' nearest neighbors. These neighbors essentially vote according to their prediction. The consensus is the average individual predictions for 'z'. Using a distance metric, the 'kappa' vectors nearest to 'z' are found in the training data, which are stored row-wise in data matrix 'x'. The corresponding response values are given in the vector 'y', such that the response value for vector 'x(i)' is given by 'y(i)'.
class LassoRegression extends PredictorMat
The LassoRegression class supports multiple linear regression.
The LassoRegression 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).

See also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
class MV_Regression extends PredictorMat2
The MV_Regression class supports multi-variate, multiple linear regression.
The MV_Regression class supports multi-variate, 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 solve the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)
Five factorization techniques are provided:
'QR' // QR Factorization: slower, more stable (default) 'Cholesky' // Cholesky Factorization: faster, less stable (reasonable choice) 'SVD' // Singular Value Decomposition: slowest, most robust 'LU' // LU Factorization: better than Inverse 'Inverse' // Inverse/Gaussian Elimination, classical textbook technique

See also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf Note, not intended for use when the number of degrees of freedom 'df' is negative.
en.wikipedia.org/wiki/Degrees_of_freedom_(statistics)
type Matrices = IndexedSeq[MatriD]
Collection of matrices
trait Model extends Error
The Model trait provides a common framework for all analytics models and serves as base trait for Classifier and Predcitor traits.
The Model trait provides a common framework for all analytics models and serves as base trait for Classifier and Predcitor traits. The 'train' and 'eval' methods must be called first, e.g.,
val model = NullModel (y) model.train (null, y).eval (null, y)
trait ModelFactory extends Error
The ModelFactory trait is intended for use in Model factory objects.
The ModelFactory trait is intended for use in Model factory objects. It supports expansion of the data matrix and rescaling of data values. When the 'rescale' flag is on/true, the companion object factory 'apply' functions should rescale or normalize the data appropriately to the particular modeling technique (or even to the level of the activation function used). In ScalaTion, model constructors do not rescale, but 'apply' functions that call model constructors need to provide this option. For example,
val model1 = new Regression (x, y, fname, hparam, technique) val model2 = Regression (x, y, fname, hparam, technique)
'model1' will not have its data rescaled, while 'model2' will.
case class ModelStudy(name: String, problem: String, literature: IndexedSeq[URL], models: IndexedSeq[Model], datasets: IndexedSeq[URL], tables: IndexedSeq[Relation], matrices: IndexedSeq[MatriD]) extends Error with Product with Serializable
The ModelStudy maintains information about a modeling study.
The ModelStudy maintains information about a modeling study.
name
the unique for the modeling study
problem
the problem statement for the study
literature
the relevant literature for the modeling study
models
the models used for the modeling study
datasets
the datasets used for the modeling study
tables
the relational tables used for the modeling study
matrices
the data matrices used for the modeling study
case class MultiplyGate() extends Product with Serializable
MultiplyGate is to perfrom dot product from input and weights 'w'.
class NMFactorization extends Reducer
The NMFactorization class factors a matrix 'x' into two non negative matrices 'w' and 'h' such that 'x = wh' approximately.
The NMFactorization class factors a matrix 'x' into two non negative matrices 'w' and 'h' such that 'x = wh' approximately.

See also
en.wikipedia.org/wiki/Non-negative_matrix_factorization
case class NetParam(w: MatriD, b: VectoD = null) extends Product with Serializable
The NetParam class bundles parameter weights and biases together.
The NetParam class bundles parameter weights and biases together.
w
the weight matrix
b
the optional bias/intercept vector (null => not used)
type NetParams = IndexedSeq[NetParam]
Collection of NetParams
class NeuralNet_2L extends PredictorMat2
The NeuralNet_2L class supports multi-output, 2-layer (input and output) Neural-Networks.
The NeuralNet_2L class supports multi-output, 2-layer (input and output) Neural-Networks. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the weights/parameters 'b' connecting the layers, so that for a new input vector 'z', the net can predict the output value, i.e.,
yp_j = f (b dot z)
where 'f' is the activation function and the parameters 'b' gives the weights between input and output layers. No batching is used for this algorithm. Note, 'b0' is treated as the bias, so 'x0' must be 1.0.
class NeuralNet_3L extends PredictorMat2
The NeuralNet_3L class supports multi-output, 3-layer (input, hidden and output) Neural-Networks.
The NeuralNet_3L class supports multi-output, 3-layer (input, hidden and output) Neural-Networks. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = f1 (b * f0 (a * v))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, NeuralNet_3L explicitly adds bias.
class NeuralNet_3L1 extends NeuralNet_3L
The NeuralNet_3L1 class supports multi-output, 3-layer (input, hidden and output) Neural-Networks.
The NeuralNet_3L1 class supports multi-output, 3-layer (input, hidden and output) Neural-Networks. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = f1 (b * f0 (a * v))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, NeuralNet_3L1 explicitly adds bias.
class NeuralNet_XL extends PredictorMat2
The NeuralNet_XL class supports multi-output, multi-layer (input, multiple hidden and output) Neural-Networks.
The NeuralNet_XL class supports multi-output, multi-layer (input, multiple hidden and output) Neural-Networks. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the weight and bias parameters connecting the layers, so that for a new input vector 'v', the net can predict the output value. Defaults to two hidden layers. This implementation is partially adapted from Michael Nielsen's Python implementation found in

See also
github.com/mnielsen/neural-networks-and-deep-learning/blob/master/src/network2.py
github.com/MichalDanielDobrzanski/DeepLearningPython35/blob/master/network2.py ------------------------------------------------------------------------------
class NeuralNet_XLT extends NeuralNet_XL
The NeuralNet_XLT class supports multi-output, multi-layer (input, {hidden} and output) Neural-Networks with Transfer Learning.
The NeuralNet_XLT class supports multi-output, multi-layer (input, {hidden} and output) Neural-Networks with Transfer Learning. A layer (first hidden by default) from a neural- network model trained on a related dataset is transferred into that position in 'this' model. Given several input vectors and output vectors (training data), fit the parameters 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output vector.
trait NoFeatureSelection extends AnyRef
The NoFeatureSelection trait is for modeling techniques that do not support feature selection (adding/remove variables from the model).
The NoFeatureSelection trait is for modeling techniques that do not support feature selection (adding/remove variables from the model). For example, SimpleRegression only has one feature/predictor variable, so feature selection makes no sense for this modeling technique. Therefore the 'forwardSel' defined in Predictor is set to throw an exception.
trait NoFeatureSelectionMat extends AnyRef
The NoFeatureSelectionMat trait is for modeling techniques that do not support feature selection (adding/remove variables from the model).
The NoFeatureSelectionMat trait is for modeling techniques that do not support feature selection (adding/remove variables from the model). For example, SimpleRegression only has one feature/predictor variable, so feature selection makes no sense for this modeling technique. Therefore the 'buildModel' method specified in PredictorMat and is called by 'forwardSel' and 'backwardElim' is set to throw an exception.
case class Node(f: Int, branch: Int, yp: Double, thresh: Double, depth: Int, pthresh: Double, pfea: Int, leaf: Boolean = false) extends Product with Serializable
Class that contains information for a tree node.
Class that contains information for a tree node.
f
the feature of the node, if it is leaf, contains the feature of its parent
branch
the branch value (0 => left, 1 => right)
yp
leaf node's prediction for y
thresh
the threshold for continuous feature
depth
the current depth of the node
pthresh
the threshold for parent node
pfea
the feature of parent node
leaf
Boolean value indicate whether is a leaf node
class NonLinRegression extends PredictorMat with NoFeatureSelectionMat
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'.

See also
www.bsos.umd.edu/socy/alan/stats/socy602_handouts/kut86916_ch13.pdf
class NullModel extends Fit with Predictor with NoFeatureSelection
The NullModel class implements the simplest type of predictive modeling technique that just predicts the response 'y' to be the mean.
The NullModel class implements the simplest type of predictive modeling technique that just predicts the response 'y' to be the mean. Fit the parameter vector 'b' in the null regression equation
y = b dot x + e = b0 + e
where 'e' represents the residual/error vector (the part not explained by the model).
type PairD = (Double, Double)
Pair of doubles
type PairI = (Int, Int)
Pair of integers
type PairV = (VectoD, VectoD)
Pair of double vectors
class Perceptron extends PredictorMat
The Perceptron class supports single-output, 2-layer (input and output) Neural-Networks.
The Perceptron class supports single-output, 2-layer (input and output) Neural-Networks. Although perceptrons are typically used for classification, this class is used for prediction. Given several input vectors and output values (training data), fit the weights/parameters 'b' connecting the layers, so that for a new input vector 'z', the net can predict the output value, i.e.,
z = f (b dot z)
The parameter vector 'b' (w) gives the weights between input and output layers. Note, 'b0' is treated as the bias, so 'x0' must be 1.0.
class PoissonRegression extends PredictorMat
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 also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf
class PolyORegression extends Regression with ExpandableForms
The PolyORegression class supports orthogonal polynomial regression.
The PolyORegression class supports orthogonal polynomial regression. In this case, 't' is expanded to an orthononalization of '[1, t, t^{2 ... t}k]'. Fit the parameter vector 'b' in the regression equation
y = b dot x + e = b_0 + b_1 * t + b_2 * t^{2 ... b_k * t}k + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)

See also
www.ams.sunysb.edu/~zhu/ams57213/Team3.pptx
class PolyRegression extends Regression with ExpandableForms
The PolyRegression class supports polynomial regression.
The PolyRegression class supports polynomial regression. In this case, 't' is expanded to '[1, t, t^{2 ... t}k]'. Fit the parameter vector 'b' in the regression equation
y = b dot x + e = b_0 + b_1 * t + b_2 * t^{2 ... b_k * t}k + e
where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)

See also
www.ams.sunysb.edu/~zhu/ams57213/Team3.pptx
trait Predictor extends Model
The Predictor trait provides a common framework for several types of predictors.
The Predictor trait provides a common framework for several types of predictors.
y = f(x; b) + e
y = response/output value x = predictor/input vector b = parameter vector e = residual/error value
A predictor is for potentially unbounded responses (real or integer). When the number of distinct responses is bounded by some relatively small integer 'k', a classifier is likely more appropriate. Note, the 'train' method (from Model) must be called first followed by 'eval'.
abstract class PredictorMat extends Fit with Predictor
The PredictorMat abstract class supports multiple predictor analytics, such as Regression.
The PredictorMat abstract class supports multiple predictor analytics, such as Regression. In this case, 'x' is multi-dimensional [1, x_1, ... x_k]. Fit the parameter vector 'b' in for example the regression equation
y = b dot x + e = b_0 + b_1 * x_1 + ... b_k * x_k + e
Note, "protected val" arguments required by ResponseSurface.
abstract class PredictorMat2 extends Predictor
The PredictorMat2 abstract class provides the basic structure and API for a variety of modeling techniques with multiple outputs/responses, e.g., Neural Networks.
class PrincipalComponents extends Reducer with Error
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 Principal Components 'PC's by calling 'findPCs' and then call 'reduce' to reduce the data (i.e., reduce matrix 'x' to a lower dimensionality matrix).
trait QoF extends AnyRef
The QoF trait defines methods to determine basic Quality of Fit 'QoF' measures.
class QuadELM_3L1 extends PredictorMat
The QuadELM_3L1 class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines.
The QuadELM_3L1 class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = forms (f1 (b * f0 (a * v)))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, QuadELM_3L1 explicitly adds bias. 'forms' expands a vector to include quadratic forms. Note: only uses 'f_id' implicitly, use ELM_3L for other options for 'f1'.
class QuadRegression extends Regression with ExpandableForms
The QuadRegression class uses multiple regression to fit a quadratic surface to the data.
The QuadRegression class uses multiple regression to fit a quadratic 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_0^{2, x_1, x_1}2] + e
Has no interaction/cross-terms and adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

See also
scalation.metamodel.QuadraticFit
class QuadXELM_3L1 extends PredictorMat
The QuadXELM_3L1 class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines.
The QuadXELM_3L1 class supports multi-output, 3-layer (input, hidden and output) Extreme-Learning Machines. It can be used for both classification and prediction, depending on the activation functions used. Given several input vectors and output vectors (training data), fit the parameters 'a' and 'b' connecting the layers, so that for a new input vector 'v', the net can predict the output value, i.e.,
yp = forms (f1 (b * f0 (a * v)))
where 'f0' and 'f1' are the activation functions and the parameter 'a' and 'b' are the parameters between input-hidden and hidden-output layers. Unlike NeuralNet_2L which adds input 'x0 = 1' to account for the intercept/bias, QuadXELM_3L1 explicitly adds bias. 'forms' expands a vector to include quadratic forms with cross terms. Note: only uses 'f_id' implicitly, use ELM_3L for other options for 'f1'.
class QuadXRegression extends Regression with ExpandableForms
The QuadXRegression class uses multiple regression to fit a quadratic with cross-terms to the data.
The QuadXRegression class uses multiple regression to fit a quadratic with cross-terms to the data. For example in 2D, the quadratic cross regression equation is
y = b dot x + e = [b_0, ... b_k] dot [1, x_0, x_0^{2, x_1, x_0*x_1, x_1}2] + e
Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

See also
scalation.metamodel.QuadraticFit
class QuadraticFit extends AnyRef
The QuadraticFit class uses multiple regression to fit a quadratic surface to the function 'f'.
The QuadraticFit class uses multiple regression to fit a quadratic surface to the function 'f'. This is useful when computing 'f' is costly, for example in simulation optimization. The fit is over a multi-dimensional grid and can be used for interpolation and limited extrapolation.
class RecurrentNeuralNet extends Error
The RecurrentNeuralNet class feeds input in sequential time into hidden layer.
The RecurrentNeuralNet class feeds input in sequential time into hidden layer. It uses parameter U, W, V in network. where U is parameter for input x, W is for hidden layer z, and V is for output y We have 'St = Activate (U dot x(t) + W dot x(t-1))' and 'y(t) = softmax(V dot St)'

See also
github.com/pangolulu/rnn-from-scratch ----------------------------------------------------------------------------
class RecurrentNeuralNetLayer extends AnyRef
The RecurrentNeuralNetLayer is a 3-layer where x denotes the input, 'y 'denotes the output and 's' is the intermediate/hidden value.
The RecurrentNeuralNetLayer is a 3-layer where x denotes the input, 'y 'denotes the output and 's' is the intermediate/hidden value. We have 'St = Activate (U dot x(t) + W dot x(t-1))' and 'y(t) = softmax(V dot St)'.
trait Reducer extends AnyRef
The Reducer trait provides a common framework for several data reduction algorithms.
class Regression extends PredictorMat
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 solve the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)
Five factorization techniques are provided:
'QR' // QR Factorization: slower, more stable (default) 'Cholesky' // Cholesky Factorization: faster, less stable (reasonable choice) 'SVD' // Singular Value Decomposition: slowest, most robust 'LU' // LU Factorization: better than Inverse 'Inverse' // Inverse/Gaussian Elimination, classical textbook technique

See also
see.stanford.edu/materials/lsoeldsee263/05-ls.pdf Note, not intended for use when the number of degrees of freedom 'df' is negative.
en.wikipedia.org/wiki/Degrees_of_freedom_(statistics)
class RegressionTree extends PredictorMat
The RegressionTree class implements a RegressionTree selecting splitting features using minimal variance in children nodes.
The RegressionTree class implements a RegressionTree selecting splitting features using minimal variance in children nodes. To avoid exponential choices in the selection, supporting ordinal features currently. Use companion object is recommended for generate Regression Tree.
class RegressionTree_GB extends PredictorMat
The RegressionTree_GB class uses Gradient Boosting on RegressionTree.
The RegressionTree_GB class uses Gradient Boosting on RegressionTree. One Tree is included in the model at a time wisely chosen for reducing gradient.
class Regression_WLS extends Regression
The Regression_WLS class supports weighted multiple linear regression.
The Regression_WLS class supports weighted multiple linear regression. In this case, 'xx' is multi-dimensional [1, xx_1, ... xx_k]. Weights are set to the inverse of a variable's variance, so they can compensate for such variability (heteroscedasticity). Fit the parameter vector 'b' in the regression equation
yy = b dot xx + e = b_0 + b_1 * xx_1 + ... b_k * xx_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 = fac.solve (.)
The data matrix 'xx' is reweighted 'x = rootW * xx' and the response vector 'yy' is reweighted 'y = rootW * yy' where 'rootW' is the square root of the weights.

See also
en.wikipedia.org/wiki/Least_squares#Weighted_least_squares These are then passed to Ordinary Least Squares (OLS) Regression. Five factorization techniques are provided: 'QR' // QR Factorization: slower, more stable (default) 'Cholesky' // Cholesky Factorization: faster, less stable (reasonable choice) 'SVD' // Singular Value Decomposition: slowest, most robust 'LU' // LU Factorization: better than Inverse 'Inverse' // Inverse/Gaussian Elimination, classical textbook technique
www.markirwin.net/stat149/Lecture/Lecture3.pdf
class RidgeRegression extends PredictorMat
The RidgeRegression class supports multiple linear ridge regression.
The RidgeRegression class supports multiple linear ridge regression. In this case, 'x' is multi-dimensional [x_1, ... x_k]. Ridge regression puts a penalty on the L2 norm of the parameters b to reduce the chance of them taking on large values that may lead to less robust models. 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 solve for the parameter vector 'b' using the regularized Normal Equations:
b = fac.solve (.) with regularization x.t * x + λ * I
Five factorization techniques are provided:
'QR' // QR Factorization: slower, more stable (default) 'Cholesky' // Cholesky Factorization: faster, less stable (reasonable choice) 'SVD' // Singular Value Decomposition: slowest, most robust 'LU' // LU Factorization: similar, but better than inverse 'Inverse' // Inverse/Gaussian Elimination, classical textbook technique

See also
statweb.stanford.edu/~tibs/ElemStatLearn/
class RoundRegression extends Regression
The RoundRegression class supports rounded multiple linear regression.
The RoundRegression class supports rounded 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
y = round (b dot x) + e = round (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). Use Least-Squares (minimizing the residuals) to fit the parameter vector 'b'
class SimpleExpRegression extends PredictorMat with NoFeatureSelectionMat
The SimpleExpRegression class supports exponential regression.
The SimpleExpRegression 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

See also
www.stat.uni-muenchen.de/~leiten/Lehre/Material/GLM_0708/chapterGLM.pdf
class SimpleRegression extends PredictorMat with NoFeatureSelectionMat
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 'x1', i.e., (1, x1). Fit the parameter vector 'b' in the regression equation
y = b dot x + e = [b0, b1] dot [1, x1] + e = b0 + b1 * x1 + e
where 'e' represents the residuals (the part not explained by the model).
class SimplerRegression extends PredictorMat with NoFeatureSelectionMat
The SimplerRegression class supports simpler linear regression.
The SimplerRegression class supports simpler linear regression. In this case, the vector 'x' consists of a single variable 'x0'. Fit the parameter vector 'b' in the regression equation
y = b dot x + e = [b0] dot [x0] + e = b0 * x0 + e
where 'e' represents the residuals (the part not explained by the model). The simpler regression model has no intercept parameter, only a slope parameter.

See also
SimpleRegression for both intercept and slope parameters
class Softmax extends AnyRef
Softmax class calculate softmax regularization for the input
class StoppingRule extends AnyRef
The StoppingRule class provides a stopping rule to terminating the iterative steps in an optimization early.
type Strings = Array[String]
Shorthand for array of strings
class SumQueue extends AnyRef
The SumQueue class retains the last 'q' elements as well as the running total in 'sum' and number of elements in 'size_', making it efficient to compute moving averages.
class SumSqQueue extends AnyRef
The SumQueue class retains the last 'q' elements as well as the running total in 'sum' and number of elements in 'size_', making it efficient to compute moving averages.
class Tanh extends AnyRef
The Tanh class implements Tanh and derivative for vector version
class TranRegression extends Regression
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'. Common transforms include 'log (y)', 'sqrt (y)' when 'y > 0', or even 'sq (y)', 'exp (y)'. More generally, a Box-Cox Transformation may be applied.

See also
citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.469.7176&rep=rep1&type=pdf Use Least-Squares (minimizing the residuals) to fit the parameter vector 'b' Note: this class does not provide transformations on columns of matrix 'x'.
www.ams.sunysb.edu/~zhu/ams57213/Team3.pptx
class TrigRegression extends Regression with ExpandableForms
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 solve for the parameter vector 'b' using the Normal Equations:
x.t * x * b = x.t * y b = fac.solve (.)

See also
link.springer.com/article/10.1023%2FA%3A1022436007242#page-1
case class Variable(xj: VectoD, j: Int, kind: VariableKind.VariableKind = Continuous, name_: String = null, concept: String = null) extends Product with Serializable
The Variable class provides meta-data for a variable including its kind, distinct values, name and optional ontological concept.
The Variable class provides meta-data for a variable including its kind, distinct values, name and optional ontological concept. The variable may be an input variable (feature) or an output variable (response). Typically, it represents a column 'xj' in a data matrix. --------------------------------------------------------------------------- Several modeling techniques such as decision trees need to divide the values into groups, e.g., for branch values: When 'xj' is categorical, these will be all its distinct values. Otherwise, these will be 0 (up to threshold) or 1 (above threshold).
xj
the column vector (feature/response)
j
the index position within the relevant data matrix
kind
indication of the variable kind
concept
an optional URI for an optological concept

See also
classifier.Node for 'threshold'
type Vectors = IndexedSeq[VectoD]
Collection of vectors

Value Members

val BASE_DIR: String
The relative path for base directory
def chopr(y: VectoD, te: Int, te_size: Int, tr_size: Int): (VectoD, VectoD)
Chop the testing 'te' and training 'tr' datasets out of the full dataset for rolling validation where the training set is before the testing set.
Chop the testing 'te' and training 'tr' datasets out of the full dataset for rolling validation where the training set is before the testing set. This version works for models without an 'x' componenet, only 'y'.
y
the full response/output vector
te
the start (inclusive) of the testing region
te_size
the size of the testing region
tr_size
the size of the training region
def chopr(x: MatriD, y: VectoD, te: Int, te_size: Int, tr_size: Int): (MatriD, VectoD, MatriD, VectoD)
Chop the testing 'te' and training 'tr' datasets out of the full dataset for rolling validation where the training set is before the testing set.
Chop the testing 'te' and training 'tr' datasets out of the full dataset for rolling validation where the training set is before the testing set.
x
the full data/input matrix
y
the full response/output vector
te
the start (inclusive) of the testing region
te_size
the size of the testing region
tr_size
the size of the training region
def diagnoseMat(x: MatriD): Unit
Diagnose matrix 'x' looking for high correlation, high condition number, lower than expected rank, zero variance columns (there should only be one).
Diagnose matrix 'x' looking for high correlation, high condition number, lower than expected rank, zero variance columns (there should only be one).
x
the data matrix to diagnose
def findInfinity(x: VectoD): IndexedSeq[Int]
Find values in a vector of infinite magnitude, returning all the index poistions.
Find values in a vector of infinite magnitude, returning all the index poistions.
x
the vector in question
final def flaw(method: String, message: String): Unit

Definition Classes
Error
def pullResponse(xy: MatriD, col: Int = -1): (MatriD, VectoD)
Pull out the designated response column from the combined data-resposnse matrix, returning the data matrix 'x' and response vector 'y'.
Pull out the designated response column from the combined data-resposnse matrix, returning the data matrix 'x' and response vector 'y'. When 'col' is negative or the last column, slice out the last column.
xy
the combined data-response matrix
col
the designated response column to be pulled out
def rSqF(y: VectoD, yp: VectoD, skip: Int): Double
Calculate the Coefficient of Determination (R^2) with skipping
Calculate the Coefficient of Determination (R^2) with skipping
y
the actual values in the m-dimensional output/response vector
yp
the predicted/forecasted y-vector
skip
skip the first 'skip' values (e.g., due to forecasting start up)
def rSqF(y: VectoD, yp: VectoD): Double
Calculate the Coefficient of Determination (R^2).
Calculate the Coefficient of Determination (R^2).
y
the actual values in the m-dimensional output/response vector
yp
the predicted/forecasted y-vector
def shift_r(y1: VectoD, y2: VectoD): VectoD
Shift the training dataset right by 'd2 = y2.dim' instances, filling in from the testing dataset.
Shift the training dataset right by 'd2 = y2.dim' instances, filling in from the testing dataset. Used to update the training dataset before retraining, e.g., in rolling validation. This version works for models without an 'x' componenet, only 'y'.
y1
the training dataset (vector)
y2
the portion of the testing dataset to be shifted in (vector)
def shift_r(xy1: (MatriD, VectoD), xy2: (MatriD, VectoD)): (MatriD, VectoD)
Shift the training dataset right by 'd2 = xy2._2.dim' instances, filling in from the testing dataset.
Shift the training dataset right by 'd2 = xy2._2.dim' instances, filling in from the testing dataset. Used to update the training dataset before retraining, e.g., in rolling validation.
xy1
the training dataset (matrix, vector)
xy2
the portion of the testing dataset to be shifted in (matrix, vector)
def smapeF(y: VectoD, yp: VectoD, skip: Int): Double
Calculate the symmetric Mean Absolute Percentage Error (sMAPE) with skipping.
Calculate the symmetric Mean Absolute Percentage Error (sMAPE) with skipping. It is the mean of the absolute errors over the average of the absolute values for the actual and predicted response.
y
the actual values in the m-dimensional output/response vector
yp
the predicted/forecasted y-vector
skip
skip the first 'skip' values (e.g., due to forecasting start up)
def smapeF(y: VectoD, yp: VectoD): Double
Calculate the symmetric Mean Absolute Percentage Error (sMAPE).
Calculate the symmetric Mean Absolute Percentage Error (sMAPE).
y
the actual values in the m-dimensional output/response vector
yp
the predicted/forecasted y-vector
def sseF(y: MatriD, yp: MatriD): Double
Calculate the sum of squared errors (sse).
Calculate the sum of squared errors (sse).
y
the actual response/output matrix
yp
the predicted response/output matrix
def sseF(y: VectoD, yp: VectoD, skip: Int): Double
Calculate the sum of squared errors (sse) with skipping.
Calculate the sum of squared errors (sse) with skipping.
y
the actual response/output vector
yp
the predicted response/output vector
skip
skip the first 'skip' values (e.g., due to forecasting start up)
def sseF(y: VectoD, yp: VectoD): Double
Calculate the sum of squared errors (sse).
Calculate the sum of squared errors (sse).
y
the actual response/output vector
yp
the predicted response/output vector
def sstF(y: VectoD, skip: Int): Double
Calculate the sum of squares total (ssr + sse) with skipping.
Calculate the sum of squares total (ssr + sse) with skipping.
y
the actual values in the m-dimensional output/response vector
skip
skip the first 'skip' values (e.g., due to forecasting start up)
def sstF(y: VectoD): Double
Calculate the sum of squares total (ssr + sse).
Calculate the sum of squares total (ssr + sse).
y
the actual values in the m-dimensional output/response vector
def subSample(x: MatriD, y: VectoD, nSamp: Int, str: Int): (MatriD, VectoD, Array[Int])
Create a random sub-sample of rows from matrix 'x' and vector 'y', returning the sub-sample matrix and vector and the indices selected.
Create a random sub-sample of rows from matrix 'x' and vector 'y', returning the sub-sample matrix and vector and the indices selected.
x
the data original matrix
y
the data original matrix
nSamp
the desired sample size (number of rows in matrix)
str
the random number stream to use
def subSample(x: MatriD, nSamp: Int, stream: Int): (MatriD, Array[Int])
Create a random sub-sample of rows from matrix 'x', returning the sub-sample matrix and the indices selected.
Create a random sub-sample of rows from matrix 'x', returning the sub-sample matrix and the indices selected. Must change the 'stream' parameter to get a different subsample.
x
the data original matrix
nSamp
the desired sample size (number of rows in matrix)
stream
the random number stream to use
object ANCOVA extends Error
The ANCOVA companion object provides helper functions.
object ANCOVA1 extends Error
The ANCOVA1 companion object provides factor functions.
object ANCOVA1Test extends App
The ANCOVA1Test object tests the ANCOVA1 class using the following regression equation.
The ANCOVA1Test object tests the ANCOVA1 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
> runMain scalation.analytics.ANCOVA1Test
object ANCOVATest extends App
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
> runMain scalation.analytics.ANCOVATest
object ANCOVATest2 extends App
The ANCOVATest2 object tests the ANCOVA class using the following regression equation.
The ANCOVATest2 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
This version needs the treatment levels to be shift down to zero. > runMain scalation.analytics.ANCOVATest2
object ANCOVATest3 extends App
The ANCOVATest3 object tests the ANCOVA object related to related to encoding a column 'x1' of strings.
The ANCOVATest3 object tests the ANCOVA object related to related to encoding a column 'x1' of strings. > runMain scalation.analytics.ANCOVATest3
object ANOVA1Test extends App
The ANOVA1Test object tests the ANOVA1 class using the following regression equation.
The ANOVA1Test object tests the ANOVA1 class using the following regression equation.
y = b dot x = b_0 + b_1*d_1 + b_2*d_2
> runMain scalation.analytics.ANOVA1Test
object ActivationFun
The ActivationFun object contains common Activation functions and provides both scalar and vector versions.
The ActivationFun object contains common Activation functions and provides both scalar and vector versions.

See also
en.wikipedia.org/wiki/Activation_function Convention: fun activation function (e.g., sigmoid) funV vector version of activation function (e.g., sigmoidV) funM matrix version of activation function (e.g., sigmoidM) funDV vector version of dervivative (e.g., sigmoidDV) funDM matrix version of dervivative (e.g., sigmoidDM) ---------------------------------------------------------------------------------- Supports: id, reLU, lreLU, eLU, tanh, sigmoid, gaussian, softmax Related functions: logistic, logit
object ActivationFunTest extends App
The ActivationFunTest is used to test the ActivationFun object.
The ActivationFunTest is used to test the ActivationFun object. > runMain scalation.analytics.ActivationFunTest
object ActivationFunTest2 extends App
The ActivationFunTest2 is used to test the ActivationFun object.
The ActivationFunTest2 is used to test the ActivationFun object.

See also
en.wikipedia.org/wiki/Softmax_function > runMain scalation.analytics.ActivationFunTest2
object CoFilterTest2 extends App
The CoFilterTest2 object is used to test the CoFilter class' convolutional operator.
The CoFilterTest2 object is used to test the CoFilter class' convolutional operator. > runMain scalation.analytics.CoFilterTest2
object CoFilter_1D
The Filter object provides the convolution and pooling operators.
object CoFilter_1DTest extends App
The CoFilter_1DTest object is used to test the CoFilter_1D class.
The CoFilter_1DTest object is used to test the CoFilter_1D class. Test using the simple example from section 11.10 of ScalaTion textbook. > runMain scalation.analytics.CoFilter_1DTest
object ConvNet_1D
The ConvNet_1D companion object provides factory functions for the ConvNet_1D class.
object ConvNet_1DTest extends App
The ConvNet_1DTest object is used to test the ConvNet_1D class.
The ConvNet_1DTest object is used to test the ConvNet_1D class. Test using the simple example from section 11.10 of ScalaTion textbook. Perform four training steps. > runMain scalation.analytics.ConvNet_1DTest
object ConvNet_1DTest2 extends App
The ConvNet_1DTest2 object is used to test the ConvNet_1D class using the AutoMPG dataset.
The ConvNet_1DTest2 object is used to test the ConvNet_1D class using the AutoMPG dataset. > runMain scalation.analytics.ConvNet_1DTest2
object ConvNet_1DTest3 extends App
The ConvNet_1DTest3 object is used to test the ConvNet_1D class for the convolutional operator.
The ConvNet_1DTest3 object is used to test the ConvNet_1D class for the convolutional operator. > runMain scalation.analytics.ConvNet_1DTest3
object CoordDescentLassoTest extends App
The CoordDescentLassoTest object tests CoordDescentLasso class using the following regression equation.
The CoordDescentLassoTest object tests CoordDescentLasso class using the following regression equation.
y = b dot x = b_1*x_1 + b_2*x_2.
It compares with RidgeRegression and Regression

See also
http://statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.CoordDescentLassoTest
object CubicRegression extends ModelFactory
The CubicRegression companion object provides methods for creating functional forms.
object CubicRegressionTest extends App
The CubicRegressionTest object is used to test the CubicRegression class.
The CubicRegressionTest object is used to test the CubicRegression class. > runMain scalation.analytics.CubicRegressionTest
object CubicRegressionTest2 extends App
The CubicRegressionTest2 object is used to test the CubicRegression class.
The CubicRegressionTest2 object is used to test the CubicRegression class. > runMain scalation.as4360.htmlnalytics.CubicRegressionTest2
object CubicRegressionTest3 extends App
The CubicRegressionTest3 object tests the CubicRegression class using the AutoMPG dataset.
The CubicRegressionTest3 object tests the CubicRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.CubicRegressionTest3
object CubicRegressionTest4 extends App
The CubicRegressionTest4 object tests the CubicRegression class using the AutoMPG dataset.
The CubicRegressionTest4 object tests the CubicRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. Runs the cubic case. > runMain scalation.analytics.CubicRegressionTest4
object CubicRegressionTest5 extends App
The CubicRegressionTest5 object compares Regression vs.
The CubicRegressionTest5 object compares Regression vs. QuadRegression vs. CubicRegression. using the following regression equations.
y = b dot x = b_0 + b_1*x y = b dot x' = b_0 + b_1*x + b_2*x^{2
y = b dot x' = b_0 + b_1*x + b_2*x}2 + b_3*x^3
> runMain scalation.analytics.CubicRegressionTest5
object CubicXRegression extends ModelFactory
The CubicXRegression companion object provides methods for creating functional forms.
object CubicXRegressionTest extends App
The CubicXRegressionTest object is used to test the CubicXRegression class.
The CubicXRegressionTest object is used to test the CubicXRegression class. > runMain scalation.analytics.CubicXRegressionTest
object CubicXRegressionTest2 extends App
The CubicXRegressionTest2 object is used to test the CubicXRegression class.
The CubicXRegressionTest2 object is used to test the CubicXRegression class. > runMain scalation.analytics.CubicXRegressionTest2
object CubicXRegressionTest3 extends App
The CubicXRegressionTest3 object tests the CubicXRegression class using the AutoMPG dataset.
The CubicXRegressionTest3 object tests the CubicXRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.CubicXRegressionTest3
object CubicXRegressionTest4 extends App
The CubicXRegressionTest4 object tests the CubicXRegression class using the AutoMPG dataset.
The CubicXRegressionTest4 object tests the CubicXRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. Runs the cubic case. > runMain scalation.analytics.CubicXRegressionTest4
object ELM_3L extends ModelFactory
The ELM_3L companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines.
The ELM_3L companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines. Note, 'rescale' is defined in ModelFactory in Model.scala.
object ELM_3L1 extends ModelFactory
The ELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines.
The ELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines. Note, 'rescale' is defined in ModelFactory in Model.scala.
object ELM_3L1Test extends App
The ELM_3L1Test object tests the multi-collinearity method in the ELM_3L1 class using the following regression equation on the Blood Pressure dataset.
The ELM_3L1Test object tests the multi-collinearity method in the ELM_3L1 class using the following regression equation on the Blood Pressure dataset. It also applies forward selection and backward elimination.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.ELM_3L1Test
object ELM_3L1Test2 extends App
The ELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset.
The ELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset. > runMain scalation.analytics.ELM_3L1Test2
object ELM_3L1Test3 extends App
The ELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset. > runMain scalation.analytics.ELM_3L1Test3
object ELM_3L1Test4 extends App
The ELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.ELM_3L1Test4
object ELM_3L1Test5 extends App
The ELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset. This tests forward feature/variable selection. > runMain scalation.analytics.ELM_3L1Test5
object ELM_3L1Test6 extends App
The ELM_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset.
The ELM_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.ELM_3L1Test6
object ELM_3LTest extends App
The ELM_3LTest object is used to test the ELM_3L class.
The ELM_3LTest object is used to test the ELM_3L class.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.ELM_3LTest
object ELM_3LTest2 extends App
The ELM_3LTest2 object trains a extreme learning machine on the ExampleBasketBall dataset.
The ELM_3LTest2 object trains a extreme learning machine on the ExampleBasketBall dataset. > runMain scalation.analytics.ELM_3LTest2
object ELM_3LTest3 extends App
The ELM_3LTest3 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3LTest3 object trains a extreme learning machine on the ExampleAutoMPG dataset. > runMain scalation.analytics.ELM_3LTest3
object ELM_3LTest4 extends App
The ELM_3LTest4 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3LTest4 object trains a extreme learning machine on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.ELM_3LTest4
object ELM_3LTest5 extends App
The ELM_3LTest5 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The ELM_3LTest5 object trains a extreme learning machine on the ExampleAutoMPG dataset. This tests forward feature/variable selection. FIX (1) missing intercept/bias, (2) R^2 cv too high > runMain scalation.analytics.ELM_3LTest5
object ExampleAutoMPG
The ExampleAutoMPG object stored the UCI AutoMPG dataset in a matrix.
The ExampleAutoMPG object stored the UCI AutoMPG dataset in a matrix.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG
object ExampleAutoMPG_Correlation extends App
The ExampleAutoMPG_Correlation object performs correlation analysis on the UCI AutoMPG dataset.
The ExampleAutoMPG_Correlation object performs correlation analysis on the UCI AutoMPG dataset.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG > runMain scalation.analytics.ExampleAutoMPG_Correlation
object ExampleAutoMPG_NullModel extends App
The ExampleAutoMPG_NullModel object performs NullModel on the UCI AutoMPG dataset.
The ExampleAutoMPG_NullModel object performs NullModel on the UCI AutoMPG dataset.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG > runMain scalation.analytics.ExampleAutoMPG_NullModel
object ExampleAutoMPG_Regression extends App
The ExampleAutoMPG_Regression object performs Regression on the UCI AutoMPG dataset.
The ExampleAutoMPG_Regression object performs Regression on the UCI AutoMPG dataset.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG > runMain scalation.analytics.ExampleAutoMPG_Regression
object ExampleAutoMPG_SimpleRegression extends App
The ExampleAutoMPG_SimpleRegression object performs SimpleRegression on the UCI AutoMPG dataset.
The ExampleAutoMPG_SimpleRegression object performs SimpleRegression on the UCI AutoMPG dataset.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG > runMain scalation.analytics.ExampleAutoMPG_SimpleRegression
object ExampleAutoMPG_SimplerRegression extends App
The ExampleAutoMPG_SimplerRegression object performs SimplerRegression on the UCI AutoMPG dataset.
The ExampleAutoMPG_SimplerRegression object performs SimplerRegression on the UCI AutoMPG dataset.

See also
archive.ics.uci.edu/ml/datasets/Auto+MPG > runMain scalation.analytics.ExampleAutoMPG_SimplerRegression
object ExampleBPressure
The ExampleBPressure object stores the Blood Pressure dataset in a matrix.
The ExampleBPressure object stores the Blood Pressure dataset in a matrix.

See also
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt
object ExampleBPressureTest extends App
The ExampleBPressureTest object test the ExampleBPressure by printing out of the vectors and matrices.
The ExampleBPressureTest object test the ExampleBPressure by printing out of the vectors and matrices. > runMain scalation.analytics.ExampleBPressureTest
object ExampleBasketBall
The ExampleBasketBall class stores a medium-sized example dataset with data about basketball player that can be used to predict their scoring average.
object ExampleConcrete
The ExampleConcrete class stores a medium-sized example dataset from the UCI Machine Learning Repository, "Abstract: Concrete is a highly complex material.
The ExampleConcrete class stores a medium-sized example dataset from the UCI Machine Learning Repository, "Abstract: Concrete is a highly complex material. The slump flow of concrete is not only determined by the water content, but that is also influenced by other concrete ingredients."
object ExampleConcreteTest extends App
The ExampleConcreteTest object is used to test the ExampleConcrete object.
The ExampleConcreteTest object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs Regression. > runMain scalation.analytics.ExampleConcreteTest
object ExampleConcreteTest10 extends App
The ExampleConcreteTest10 object is used to test the ExampleConcrete object.
The ExampleConcreteTest10 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_XL with 4 layers. > runMain scalation.analytics.ExampleConcreteTes10t
object ExampleConcreteTest2 extends App
The ExampleConcreteTest2 object is used to test the ExampleConcrete object.
The ExampleConcreteTest2 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs Perceptron. > runMain scalation.analytics.ExampleConcreteTest2
object ExampleConcreteTest3 extends App
The ExampleConcreteTest3 object is used to test the ExampleConcrete object.
The ExampleConcreteTest3 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs Perceptron. > runMain scalation.analytics.ExampleConcreteTest3
object ExampleConcreteTest4 extends App
The ExampleConcreteTest4 object is used to test the ExampleConcrete object.
The ExampleConcreteTest4 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_2L with 'sigmoid'. > runMain scalation.analytics.ExampleConcreteTest4
object ExampleConcreteTest5 extends App
The ExampleConcreteTest5 object is used to test the ExampleConcrete object.
The ExampleConcreteTest5 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_2L with 'sigmoid'. > runMain scalation.analytics.ExampleConcreteTest5
object ExampleConcreteTest6 extends App
The ExampleConcreteTest6 object is used to test the ExampleConcrete object.
The ExampleConcreteTest6 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_2L with 'tanh'. > runMain scalation.analytics.ExampleConcreteTest6
object ExampleConcreteTest7 extends App
The ExampleConcreteTest7 object is used to test the ExampleConcrete object.
The ExampleConcreteTest7 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_2L with 'id'. > runMain scalation.analytics.ExampleConcreteTest7
object ExampleConcreteTest8 extends App
The ExampleConcreteTest8 object is used to test the ExampleConcrete object.
The ExampleConcreteTest8 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_3L with 'sigmoid'. > runMain scalation.analytics.ExampleConcreteTest8
object ExampleConcreteTest9 extends App
The ExampleConcreteTest9 object is used to test the ExampleConcrete object.
The ExampleConcreteTest9 object is used to test the ExampleConcrete object. It compares several modeling techniques. This one runs NeuralNet_3L with 'sigmiod'. > runMain scalation.analytics.ExampleConcreteTest9
object ExpRegression extends ModelFactory
The ExpRegression companion object provides factory apply functions and a testing method.
object ExpRegressionTest extends App
The ExpRegressionTest object tests ExpRegression class using the following exponential regression problem.
The ExpRegressionTest object tests ExpRegression class using the following exponential regression problem. > runMain scalation.analytics.ExpRegressionTest
object ExpRegressionTest2 extends App
The ExpRegressionTest2 object has a basic test for the ExpRegression class.
The ExpRegressionTest2 object has a basic test for the ExpRegression class. > runMain scalation.analytics.ExpRegressionTest
object Fit
The Fit companion object provides factory methods for assessing quality of fit for standard types of modeling techniques.
object FitTest extends App
The FitTest object is use to test the Fit class.
The FitTest object is use to test the Fit class. > runMain scalation.analytics.FitTest
object HyperParameterTest extends App
The HyperParameterTest object is used to test the HyperParameter class.
The HyperParameterTest object is used to test the HyperParameter class. runMain scalation.analytics.HyperParameterTest
object ImputationTest extends App
The ImputationTest object is used to test the objects extending the Imputation trait.
The ImputationTest object is used to test the objects extending the Imputation trait. > runMain scalation.analytics.ImputationTest
object ImputationTest2 extends App
The ImputationTest2 object is used to test the objects extending the Imputation trait.
The ImputationTest2 object is used to test the objects extending the Imputation trait. > runMain scalation.analytics.ImputationTest2
object ImputeBackward extends Imputation
The ImputeBackward object imputes missing values using the subsequent value and slope.
object ImputeForward extends Imputation
The ImputeForward object imputes missing values using the previous value and slope.
object ImputeMean extends Imputation
The ImputeMean object imputes missing values using the filtered mean.
object ImputeMovingAvg extends Imputation
The ImputeMovingAvg object imputes missing values using the moving average.
object ImputeNormal extends Imputation
The ImputeNormal object imputes missing values using the median Normal variates.
object ImputeNormalWin extends Imputation
The ImputeNormalWin object imputes the missing values in the vector using Normal Distribution for a sliding window.
object ImputeRegression extends Imputation
The ImputeRegression object imputes missing values using SimpleRegression.
object Initializer
The Initializer object provides functions to initialize the parameters/weights of Neural Networks.
The Initializer object provides functions to initialize the parameters/weights of Neural Networks. Supports Uniform, Normal and Nguyen & Widrow methods.
object KNN_Predictor extends ModelFactory
The KNN_Predictor companion object provides a factory functions.
object KNN_PredictorTest extends App
The KNN_PredictorTest object is used to test the KNN_Predictor class.
The KNN_PredictorTest object is used to test the KNN_Predictor class. > runMain scalation.analytics.KNN_PredictorTest
object KNN_PredictorTest2 extends App
The KNN_PredictorTest2 object is used to test the KNN_Predictor class.
The KNN_PredictorTest2 object is used to test the KNN_Predictor class. > runMain scalation.analytics.KNN_PredictorTest2
object KNN_PredictorTest3 extends App
The KNN_PredictorTest3 object is used to test the KNN_predictor class.
The KNN_PredictorTest3 object is used to test the KNN_predictor class. > runMain scalation.analytics.KNN_PredictorTest3
object LassoRegression extends ModelFactory
The LassoRegression companion object provides factory methods for the LassoRegression class.
object LassoRegressionTest extends App
The LassoRegressionTest object tests LassoRegression class using the following regression equation.
The LassoRegressionTest object tests LassoRegression class using the following regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2.
It comapres LassoRegression to Regression.

See also
http://statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.LassoRegressionTest
object LassoRegressionTest2 extends App
The LassoRegressionTest2 object tests LassoRegression class using the following regression equation.
The LassoRegressionTest2 object tests LassoRegression class using the following regression equation.
y = b dot x = b_1*x1 + b_2*x_2.
Try non-default value for the 'lambda' hyper-parameter. > runMain scalation.analytics.LassoRegressionTest2
object LassoRegressionTest3 extends App
The LassoRegressionTest3 object tests LassoRegression class using the following regression equation.
The LassoRegressionTest3 object tests LassoRegression class using the following regression equation.
y = b dot x = b_1*x1 + b_2*x_2.
Test regression, forward selection and backward elimination. > runMain scalation.analytics.LassoRegressionTest3
object LassoRegressionTest4 extends App
The LassoRegressionTest4 object tests the LassoRegression class using the AutoMPG dataset.
The LassoRegressionTest4 object tests the LassoRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 Bar and R^2 cv vs. the instance index. > runMain scalation.analytics.LassoRegressionTest4
object LassoRegressionTest5 extends App
The LassoRegressionTest5 object tests the LassoRegression class using the AutoMPG dataset.
The LassoRegressionTest5 object tests the LassoRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also uses the 'findLambda' method to search for a shrinkage parameter that roughly mininizes 'sse_cv'. > runMain scalation.analytics.LassoRegressionTest5
object MV_Regression extends Error
The MV_Regression companion object provides factory apply functions and a testing method.
object MV_RegressionTest extends App
The MV_RegressionTest object tests MV_Regression class using the following regression equation.
The MV_RegressionTest object tests MV_Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2.

See also
statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.MV_RegressionTest
object MV_RegressionTest2 extends App
The MV_RegressionTest2 object tests MV_Regression class using the following regression equation, which has a perfect fit.
The MV_RegressionTest2 object tests MV_Regression class using the following regression equation, which has a perfect fit.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.MV_RegressionTest2
object MV_RegressionTest3 extends App
The MV_RegressionTest3 object tests the multi-collinearity method in the MV_Regression class using the following regression equation on the Blood Pressure dataset.
The MV_RegressionTest3 object tests the multi-collinearity method in the MV_Regression class using the following regression equation on the Blood Pressure dataset. Also performs Collinearity Diagnostics.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html > runMain scalation.analytics.MV_RegressionTest3
object MV_RegressionTest4 extends App
The MV_RegressionTest4 object tests the multi-collinearity method in the MV_Regression class using the following regression equation on the Blood Pressure dataset.
The MV_RegressionTest4 object tests the multi-collinearity method in the MV_Regression class using the following regression equation on the Blood Pressure dataset. It also applies forward selection and backward elimination.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.MV_RegressionTest4
object MV_RegressionTest5 extends App
The MV_RegressionTest5 object tests the cross-validation for the MV_Regression class using the following regression equation on the Blood Pressure dataset.
The MV_RegressionTest5 object tests the cross-validation for the MV_Regression class using the following regression equation on the Blood Pressure dataset.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4
> runMain scalation.analytics.MV_RegressionTest5
object MV_RegressionTest6 extends App
The MV_RegressionTest6 object tests MV_Regression class using the following regression equation.
The MV_RegressionTest6 object tests MV_Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.MV_RegressionTest6
object MV_RegressionTest7 extends App
The MV_RegressionTest7 object tests MV_Regression class using the following regression equation.
The MV_RegressionTest7 object tests MV_Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.MV_RegressionTest7
object MV_RegressionTest8 extends App
The MV_RegressionTest8 object tests the MV_Regression class using the AutoMPG dataset.
The MV_RegressionTest8 object tests the MV_Regression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. > runMain scalation.analytics.MV_RegressionTest8
object MV_RegressionTest9 extends App
The MV_RegressionTest9 object tests the MV_Regression class using the AutoMPG dataset.
The MV_RegressionTest9 object tests the MV_Regression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 Bar and R^2 cv vs. the instance index. > runMain scalation.analytics.MV_RegressionTest9
object MatrixTransform
The MatrixTransform object is used to transform the columns of a data matrix 'x'.
The MatrixTransform object is used to transform the columns of a data matrix 'x'. May also be used for a response vector 'y'. Such pre-processing of the data is required by some modeling techniques.
object MatrixTransformTest extends App
The MatrixTransformTest is used to test the MatrixTransform object.
The MatrixTransformTest is used to test the MatrixTransform object. It tests centering, scaling and normalization. > runMain scalation.analytics.MatrixTransformTest
object MatrixTransformTest2 extends App
The MatrixTransformTest2 is used to test the MatrixTransform object.
The MatrixTransformTest2 is used to test the MatrixTransform object. It tests usage of TransformV functional variables. > runMain scalation.analytics.MatrixTransformTest2
object ModelStudy extends Serializable
The ModelStudy object records the names of modeling studies.
object NMFactorizationTest extends App
The NMFactorizationTest object to test NMFactorizationTest class.
The NMFactorizationTest object to test NMFactorizationTest class. > runMain scalation.analytics.NMFactorizationTest
object NeuralNet_2L extends ModelFactory
The NeuralNet_2L companion object provides factory functions for buidling two-layer neural nets.
The NeuralNet_2L companion object provides factory functions for buidling two-layer neural nets. Note, 'rescale' is defined in ModelFactory in Model.scala.
object NeuralNet_2LTest extends App
The NeuralNet_2LTest object is used to test the NeuralNet_2L class.
The NeuralNet_2LTest object is used to test the NeuralNet_2L class. For this test, training data is used to fit the weights before using them for prediction.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.NeuralNet_2LTest
object NeuralNet_2LTest2 extends App
The NeuralNet_2LTest2 object trains a neural netowrk on the ExampleBasketBall dataset.
The NeuralNet_2LTest2 object trains a neural netowrk on the ExampleBasketBall dataset. > runMain scalation.analytics.NeuralNet_2LTest2
object NeuralNet_2LTest3 extends App
The NeuralNet_2LTest3 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_2LTest3 object trains a neural netowrk on the ExampleAutoMPG dataset. > runMain scalation.analytics.NeuralNet_2LTest3
object NeuralNet_2LTest4 extends App
The NeuralNet_2LTest4 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_2LTest4 object trains a neural netowrk on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.NeuralNet_2LTest4
object NeuralNet_2LTest5 extends App
The NeuralNet_2LTest5 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_2LTest5 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection. > runMain scalation.analytics.NeuralNet_2LTest5
object NeuralNet_2LTest6 extends App
The NeuralNet_2LTest6 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_2LTest6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.NeuralNet_2LTest6
object NeuralNet_3L extends ModelFactory
The NeuralNet_3L companion object provides factory functions for buidling three-layer (one hidden layer) neural nets.
The NeuralNet_3L companion object provides factory functions for buidling three-layer (one hidden layer) neural nets. Note, 'rescale' is defined in ModelFactory in Model.scala.
object NeuralNet_3L1 extends ModelFactory
The NeuralNet_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) neural nets.
The NeuralNet_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) neural nets. Note, 'rescale' is defined in ModelFactory in Model.scala.
object NeuralNet_3L1Test extends App
The NeuralNet_3L1Test object is used to test the NeuralNet_3L1 class.
The NeuralNet_3L1Test object is used to test the NeuralNet_3L1 class.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.NeuralNet_3L1Test
object NeuralNet_3L1Test2 extends App
The NeuralNet_3L1Test2 object trains a neural netowrk on the ExampleBasketBall dataset.
The NeuralNet_3L1Test2 object trains a neural netowrk on the ExampleBasketBall dataset. > runMain scalation.analytics.NeuralNet_3L1Test2
object NeuralNet_3L1Test3 extends App
The NeuralNet_3L1Test3 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_3L1Test3 object trains a neural netowrk on the ExampleAutoMPG dataset. > runMain scalation.analytics.NeuralNet_3L1Test3
object NeuralNet_3L1Test4 extends App
The NeuralNet_3L1Test4 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_3L1Test4 object trains a neural netowrk on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.NeuralNet_3L1Test4
object NeuralNet_3L1Test5 extends App
The NeuralNet_3L1Test5 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_3L1Test5 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection. > runMain scalation.analytics.NeuralNet_3L1Test5
object NeuralNet_3L1Test6 extends App
The NeuralNet_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.NeuralNet_3L1Test6
object NeuralNet_3LTest extends App
The NeuralNet_3LTest object is used to test the NeuralNet_3L class.
The NeuralNet_3LTest object is used to test the NeuralNet_3L class.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.NeuralNet_3LTest
object NeuralNet_3LTest2 extends App
The NeuralNet_3LTest2 object trains a neural netowrk on the ExampleBasketBall dataset.
The NeuralNet_3LTest2 object trains a neural netowrk on the ExampleBasketBall dataset. > runMain scalation.analytics.NeuralNet_3LTest2
object NeuralNet_3LTest3 extends App
The NeuralNet_3LTest3 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_3LTest3 object trains a neural netowrk on the ExampleAutoMPG dataset. > runMain scalation.analytics.NeuralNet_3LTest3
object NeuralNet_3LTest4 extends App
The NeuralNet_3LTest4 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_3LTest4 object trains a neural netowrk on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.NeuralNet_3LTest4
object NeuralNet_3LTest5 extends App
The NeuralNet_3LTest5 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_3LTest5 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection. > runMain scalation.analytics.NeuralNet_3LTest5
object NeuralNet_3LTest6 extends App
The NeuralNet_3LTest6 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_3LTest6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.NeuralNet_3LTest6
object NeuralNet_XL extends ModelFactory
The NeuralNet_XL companion object provides factory functions for buidling multi-layer neural nets (defaults to two hidden layers).
The NeuralNet_XL companion object provides factory functions for buidling multi-layer neural nets (defaults to two hidden layers). Note, 'rescale' is defined in ModelFactory in Model.scala.
object NeuralNet_XLT extends ModelFactory
The NeuralNet_XLT companion object provides factory functions for buidling three-layer (one hidden layer) neural network classifiers.
The NeuralNet_XLT companion object provides factory functions for buidling three-layer (one hidden layer) neural network classifiers. Note, 'rescale' is defined in ModelFactory in Model.scala.
object NeuralNet_XLTTest extends App
The NeuralNet_XLTTest object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_XLTTest object trains a neural netowrk on the ExampleAutoMPG dataset. This test case does not use transfer learning. A Neural Network with 2 hidden layers is created. > runMain scalation.analytics.NeuralNet_XLTTest
object NeuralNet_XLTTest2 extends App
The NeuralNet_XLTTest2 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_XLTTest2 object trains a neural netowrk on the ExampleAutoMPG dataset. This test case uses transfer learning. A Neural Network with 2 hidden layers is created with the first hidden layer being transferred from a model trained on related data. FIX: find a related dataset for 'nn0'. > runMain scalation.analytics.NeuralNet_XLTTest2
object NeuralNet_XLTest extends App
The NeuralNet_XLTest object is used to test the NeuralNet_XL class.
The NeuralNet_XLTest object is used to test the NeuralNet_XL class.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.NeuralNet_XLTest
object NeuralNet_XLTest2 extends App
The NeuralNet_XLTest2 object trains a neural netowrk on the ExampleBasketBall dataset.
The NeuralNet_XLTest2 object trains a neural netowrk on the ExampleBasketBall dataset. > runMain scalation.analytics.NeuralNet_XLTest2
object NeuralNet_XLTest3 extends App
The NeuralNet_XLTest3 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_XLTest3 object trains a neural netowrk on the ExampleAutoMPG dataset. > runMain scalation.analytics.NeuralNet_XLTest3
object NeuralNet_XLTest4 extends App
The NeuralNet_XLTest4 object trains a neural netowrk on the ExampleAutoMPG dataset.
The NeuralNet_XLTest4 object trains a neural netowrk on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.NeuralNet_XLTest4
object NeuralNet_XLTest5 extends App
The NeuralNet_XLTest5 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_XLTest5 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection. > runMain scalation.analytics.NeuralNet_XLTest5
object NeuralNet_XLTest6 extends App
The NeuralNet_XLTest6 object trains a neural network on the ExampleAutoMPG dataset.
The NeuralNet_XLTest6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2, > runMain scalation.analytics.NeuralNet_XLTest6
object NonLinRegression extends ModelFactory
The NonLinRegression companion object provides factory methods for buidling perceptrons.
The NonLinRegression companion object provides factory methods for buidling perceptrons. Note, 'rescale' is defined in ModelFactory in Model.scala.
object NonLinRegressionTest extends App
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).

See also
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
object NullModel extends Error
The NullModel companion object provides a simple factory method for building null models.
object NullModelTest extends App
The NullModelTest object is used to test the NullModel class.
The NullModelTest object is used to test the NullModel class.
y = b dot x + e = b0 + e
> runMain scalation.analytics.NullModelTest
object NullModelTest2 extends App
The NullModelTest2 object is used to test the NullModel class.
The NullModelTest2 object is used to test the NullModel class.
y = b dot x + e = b0 + e
> runMain scalation.analytics.NullModelTest2
object Optimizer
The Optimizer object gives defaults for hyper-parameters as well as other adjustable program constants.
object Optimizer_ADAM
The Optimizer_SGDM object provides functions to optimize the parameters/weights of Neural Networks with various numbers of layers.
The Optimizer_SGDM object provides functions to optimize the parameters/weights of Neural Networks with various numbers of layers. This optimizer used Stochastic Gradient Descent with Momentum.
object Optimizer_SGD extends Error
The Optimizer object provides functions to optimize the parameters (weights and biases) of Neural Networks with various numbers of layers.
The Optimizer object provides functions to optimize the parameters (weights and biases) of Neural Networks with various numbers of layers. This optimizer used Stochastic Gradient Descent
object Optimizer_SGDM
The Optimizer_SGDM object provides functions to optimize the parameters/weights of Neural Networks with various numbers of layers.
The Optimizer_SGDM object provides functions to optimize the parameters/weights of Neural Networks with various numbers of layers. This optimizer used Stochastic Gradient Descent with Momentum.
object Perceptron extends ModelFactory
The Perceptron companion object provides factory methods for buidling perceptrons.
The Perceptron companion object provides factory methods for buidling perceptrons. Note, 'rescale' is defined in ModelFactory in Model.scala.
object PerceptronTest extends App
The PerceptronTest object is used to test the Perceptron class.
The PerceptronTest object is used to test the Perceptron class. For this test, training data is used to fit the weights before using them for prediction.

See also
www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf > runMain scalation.analytics.PerceptronTest
object PerceptronTest2 extends App
The PerceptronTest2 object trains a perceptron on a small dataset of temperatures from counties in Texas where the variables/factors to consider are Latitude (x1), Elevation (x2) and Longitude (x3).
The PerceptronTest2 object trains a perceptron on a small dataset of temperatures from counties in Texas where the variables/factors to consider are Latitude (x1), Elevation (x2) and Longitude (x3). The model equation is the following:
y = sigmoid (w dot x) = sigmoid (w0 + w1*x1 + w2*x2 + w3*x3)
This test case illustrates how to transform the columns of the matrix so that the 'sigmoid' activation function can work effectively. Since the dataset is very small, should use 'train0' which does no batching. > runMain scalation.analytics.PerceptronTest2
object PerceptronTest3 extends App
The PerceptronTest3 object trains a perceptron on a small dataset with variables x1 and x2.
The PerceptronTest3 object trains a perceptron on a small dataset with variables x1 and x2. The model equation is the following:
y = sigmoid (b dot x) = sigmoid (b0 + b1*x1 + b2*x2)
Does not call the 'train' method; improvements steps for sigmoid are explicitly in code below. > runMain scalation.analytics.PerceptronTest3
object PerceptronTest4 extends App
The PerceptronTest4 object trains a perceptron on a small dataset with variables x1 and x2.
The PerceptronTest4 object trains a perceptron on a small dataset with variables x1 and x2. The model equation is the following:
y = sigmoid (b dot x) = sigmoid (b0 + b1*x1 + b2*x2)
This version calls the 'train0' method. > runMain scalation.analytics.PerceptronTest4
object PerceptronTest5 extends App
The PerceptronTest5 object trains a perceptron on a small dataset with 2 variables.
The PerceptronTest5 object trains a perceptron on a small dataset with 2 variables. > runMain scalation.analytics.PerceptronTest5
object PerceptronTest6 extends App
The PerceptronTest6 object trains a perceptron on a small dataset with 4 variables.
The PerceptronTest6 object trains a perceptron on a small dataset with 4 variables. > runMain scalation.analytics.PerceptronTest6
object PerceptronTest7 extends App
The PerceptronTest7 object trains a perceptron on the ExampleBasketBall dataset.
The PerceptronTest7 object trains a perceptron on the ExampleBasketBall dataset. > runMain scalation.analytics.PerceptronTest7
object PerceptronTest8 extends App
The PerceptronTest8 object trains a perceptron on the ExampleAutoMPG dataset.
The PerceptronTest8 object trains a perceptron on the ExampleAutoMPG dataset. > runMain scalation.analytics.PerceptronTest8
object PerceptronTest9 extends App
The PerceptronTest9 object trains a perceptron on the ExampleAutoMPG dataset.
The PerceptronTest9 object trains a perceptron on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.PerceptronTest9
object PoissonRegression
The PoissonRegression companion object provides factory functions.
object PoissonRegressionTest extends App
The PoissonRegressionTest object tests the PoissonRegression class.
The PoissonRegressionTest object tests the PoissonRegression class.

See also
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 > runMain scalation.analytics.PoissonRegressionTest
object PoissonRegressionTest2 extends App
The PoissonRegressionTest2 object tests the PoissonRegression class.
The PoissonRegressionTest2 object tests the PoissonRegression class.

See also
statmaster.sdu.dk/courses/st111/module03/index.html
www.stat.wisc.edu/~mchung/teaching/.../GLM.logistic.Rpackage.pdf > runMain scalation.analytics.PoissonRegressionTest2
object PolyORegression extends ModelFactory
The PolyORegression companion object provides factory functions and functions for creating functional forms.
object PolyORegressionTest extends App
The PolyORegressionTest object tests PolyORegression class using the following regression equation.
The PolyORegressionTest object tests PolyORegression class using the following regression equation.
y = b dot x = b_0 + b_1*t + b_2*t^2 + ... b_k*t_k
Note, the 'order' at which R-Squared drops is QR(7), Cholesky(14), SVD(6), Inverse(13). > runMain scalation.analytics.PolyORegressionTest
object PolyORegressionTest2 extends App
The PolyORegressionTest2 object tests PolyORegression class using the following regression equation.
The PolyORegressionTest2 object tests PolyORegression class using the following regression equation.
y = b dot x = b_0 + b_1*t + b_2*t^2 + ... b_k*t_k
> runMain scalation.analytics.PolyORegressionTest2
object PolyRegression extends ModelFactory
The PolyRegression companion object provides factory functions and functions for creating functional forms.
object PolyRegressionTest extends App
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 + ... b_k*t_k
Note, the 'order' at which R-Squared drops is QR(7), Cholesky(14), SVD(6), Inverse(13). > runMain scalation.analytics.PolyRegressionTest
object PolyRegressionTest2 extends App
The PolyRegressionTest2 object tests PolyRegression class using the following regression equation.
The PolyRegressionTest2 object tests PolyRegression class using the following regression equation.
y = b dot x = b_0 + b_1*t + b_2*t^2 + ... b_k*t_k
> runMain scalation.analytics.PolyRegressionTest2
object PredictorMat
The PredictorMat companion object provides a meythod for splitting a combined data matrix in predictor matrix and a response vector.
object PredictorMat2
The PredictorMat2 object provides functions for rescaling data and performing analysis.
object PredictorMatTest extends App
The PredictorMatTest is used to test the PredictorMat abstract class and its derived classes using the ExampleBasketBall dataset containing data matrix 'x' and response vector 'y'.
The PredictorMatTest is used to test the PredictorMat abstract class and its derived classes using the ExampleBasketBall dataset containing data matrix 'x' and response vector 'y'. Shift imports for ExampleAutoMPG dataset. > runMain scalation.analytics.PredictorMatTest
object PrincipalComponentsTest extends App
The PrincipalComponentsTest object is used to test the PrincipalComponents class.
The PrincipalComponentsTest object is used to test the PrincipalComponents class.

See also
www.ce.yildiz.edu.tr/personal/songul/file/1097/principal_components.pdf > runMain scalation.analytics.PrincipalComponentsTest
object QuadELM_3L1 extends ModelFactory
The QuadELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines.
The QuadELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines. Note, 'rescale' is defined in ModelFactory in Model.scala.
object QuadELM_3L1Test extends App
The QuadELM_3L1Test object tests the multi-collinearity method in the QuadELM_3L1 class using the following regression equation on the Blood Pressure dataset.
The QuadELM_3L1Test object tests the multi-collinearity method in the QuadELM_3L1 class using the following regression equation on the Blood Pressure dataset. It also applies forward selection and backward elimination.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.QuadELM_3L1Test
object QuadELM_3L1Test2 extends App
The QuadELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset.
The QuadELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset. > runMain scalation.analytics.QuadELM_3L1Test2
object QuadELM_3L1Test3 extends App
The QuadELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset. > runMain scalation.analytics.QuadELM_3L1Test3
object QuadELM_3L1Test4 extends App
The QuadELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.QuadELM_3L1Test4
object QuadELM_3L1Test5 extends App
The QuadELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset. This tests forward feature/variable selection. FIX (1) missing intercept/bias, (2) R^2 cv too high > runMain scalation.analytics.QuadELM_3L1Test5
object QuadELM_3L1Test6 extends App
The QuadELM_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset.
The QuadELM_3L1Test6 object trains a neural network on the ExampleAutoMPG dataset. This tests forward feature/variable selection with plotting of R^2. > runMain scalation.analytics.QuadELM_3L1Test6
object QuadRegression extends ModelFactory
The QuadRegression companion object provides factory functions and functions for creating functional forms.
object QuadRegressionTest extends App
The QuadRegressionTest object is used to test the QuadRegression class.
The QuadRegressionTest object is used to test the QuadRegression class. > runMain scalation.analytics.QuadRegressionTest
object QuadRegressionTest2 extends App
The QuadRegressionTest2 object is used to test the QuadRegression class.
The QuadRegressionTest2 object is used to test the QuadRegression class. > runMain scalation.analytics.QuadRegressionTest2
object QuadRegressionTest3 extends App
The QuadRegressionTest3 object is used to test the QuadRegression class.
The QuadRegressionTest3 object is used to test the QuadRegression class. > runMain scalation.analytics.QuadRegressionTest3
object QuadRegressionTest4 extends App
The QuadRegressionTest4 object tests the QuadRegression class using the AutoMPG dataset.
The QuadRegressionTest4 object tests the QuadRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It compares Regression, QuadRegression and QuadRegression with normalization. > runMain scalation.analytics.QuadRegressionTest4
object QuadRegressionTest5 extends App
The QuadRegressionTest5 object tests the QuadRegression class using the AutoMPG dataset.
The QuadRegressionTest5 object tests the QuadRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadRegressionTest5
object QuadRegressionTest6 extends App
The QuadRegressionTest6 object tests QuadRegression class using the following regression equation.
The QuadRegressionTest6 object tests QuadRegression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.QuadRegressionTest6
object QuadRegressionTest7 extends App
The QuadRegressionTest7 object compares Regression vs.
The QuadRegressionTest7 object compares Regression vs. QuadRegression using the following regression equations.
y = b dot x = b_0 + b_1*x y = b dot x' = b_0 + b_1*x + b_2*x^2
> runMain scalation.analytics.QuadRegressionTest7
object QuadXELM_3L1 extends ModelFactory
The QuadXELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines.
The QuadXELM_3L1 companion object provides factory functions for buidling three-layer (one hidden layer) extreme learning machines. Note, 'rescale' is defined in ModelFactory in Model.scala.
object QuadXELM_3L1Test extends App
The QuadXELM_3L1Test object tests the multi-collinearity method in the QuadXELM_3L1 class using the following regression equation on the Blood Pressure dataset.
The QuadXELM_3L1Test object tests the multi-collinearity method in the QuadXELM_3L1 class using the following regression equation on the Blood Pressure dataset. It also applies forward selection and backward elimination.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.QuadXELM_3L1Test
object QuadXELM_3L1Test2 extends App
The QuadXELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset.
The QuadXELM_3L1Test2 object trains a extreme learning machine on the ExampleBasketBall dataset. > runMain scalation.analytics.QuadXELM_3L1Test2
object QuadXELM_3L1Test3 extends App
The QuadXELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadXELM_3L1Test3 object trains a extreme learning machine on the ExampleAutoMPG dataset. > runMain scalation.analytics.QuadXELM_3L1Test3
object QuadXELM_3L1Test4 extends App
The QuadXELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadXELM_3L1Test4 object trains a extreme learning machine on the ExampleAutoMPG dataset. It test cross-validation. > runMain scalation.analytics.QuadXELM_3L1Test4
object QuadXELM_3L1Test5 extends App
The QuadXELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset.
The QuadXELM_3L1Test5 object trains a extreme learning machine on the ExampleAutoMPG dataset. This tests forward feature/variable selection. FIX (1) missing intercept/bias, (2) R^2 cv too high > runMain scalation.analytics.QuadXELM_3L1Test5
object QuadXRegression extends ModelFactory
The QuadXRegression companion object provides methods for creating functional forms.
object QuadXRegressionTest extends App
The QuadXRegressionTest object is used to test the QuadXRegression class.
The QuadXRegressionTest object is used to test the QuadXRegression class. > runMain scalation.analytics.QuadXRegressionTest
object QuadXRegressionTest2 extends App
The QuadXRegressionTest2 object is used to test the QuadXRegression class.
The QuadXRegressionTest2 object is used to test the QuadXRegression class. > runMain scalation.analytics.QuadXRegressionTest2
object QuadXRegressionTest3 extends App
The QuadXRegressionTest3 object tests the QuadXRegression class using the AutoMPG dataset.
The QuadXRegressionTest3 object tests the QuadXRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadXRegressionTest3
object QuadXRegressionTest4 extends App
The QuadXRegressionTest4 object tests the QuadXRegression class using the AutoMPG dataset.
The QuadXRegressionTest4 object tests the QuadXRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadXRegressionTest4
object QuadraticFitTest extends App
The QuadraticFitTest object is used to test the QuadraticFit class for a two dimensional case.
object QuadraticFitTest2 extends App
The QuadraticFitTest2 object is used to test the QuadraticFit class for a three dimensional case.
object QuadraticFitTest3 extends App
The QuadraticFitTest3 object is used to test the QuadraticFit class for a three dimensional case with noise.
object RecurrentNeuralNetTest extends App
The RecurrentNeuralNetTest object is used to test the RecurrentNeuralNet class.
The RecurrentNeuralNetTest object is used to test the RecurrentNeuralNet class. > runMain scalation.analytics.RecurrentNeuralNetTest
object RegTechnique extends Enumeration
The RegTechnique object defines the implementation techniques available.
object Regression extends ModelFactory
The Regression companion object provides factory apply functions and a testing method.
object RegressionTest extends App
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.

See also
statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.RegressionTest
object RegressionTest10 extends App
The RegressionTest10 object tests the Regression class using the following regression equation.
The RegressionTest10 object tests the Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
Show effects of increasing collinearity. > runMain scalation.analytics.RegressionTest10
object RegressionTest11 extends App
The RegressionTest11 object tests the Regression class using the AutoMPG dataset.
The RegressionTest11 object tests the Regression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.RegressionTest11
object RegressionTest12 extends App
The RegressionTest12 object tests the Regression class to illustrate projection of 6 vectors/points onto a plane in 3D space, see the last exercise in Regression section of the textbook.
The RegressionTest12 object tests the Regression class to illustrate projection of 6 vectors/points onto a plane in 3D space, see the last exercise in Regression section of the textbook.
y = b dot x = b_1*x1 + b_2*x_2.
> runMain scalation.analytics.RegressionTest12
object RegressionTest2 extends App
The RegressionTest2 object tests Regression class using the following regression equation, which has a perfect fit.
The RegressionTest2 object tests Regression class using the following regression equation, which has a perfect fit.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.RegressionTest2
object RegressionTest3 extends App
The RegressionTest3 object tests the multi-collinearity method in the Regression class using the following regression equation on the Blood Pressure dataset.
The RegressionTest3 object tests the multi-collinearity method in the Regression class using the following regression equation on the Blood Pressure dataset. Also performs Collinearity Diagnostics.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html > runMain scalation.analytics.RegressionTest3
object RegressionTest4 extends App
The RegressionTest4 object tests the multi-collinearity method in the Regression class using the following regression equation on the Blood Pressure dataset.
The RegressionTest4 object tests the multi-collinearity method in the Regression class using the following regression equation on the Blood Pressure dataset. It also applies forward selection and backward elimination.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.RegressionTest4
object RegressionTest5 extends App
The RegressionTest5 object tests the cross-validation for the Regression class using the following regression equation on the Blood Pressure dataset.
The RegressionTest5 object tests the cross-validation for the Regression class using the following regression equation on the Blood Pressure dataset.
y = b dot x = b_0 + b_1*x_1 + b_2*x_2 + b_3*x_3 + b_4 * x_4
> runMain scalation.analytics.RegressionTest5
object RegressionTest6 extends App
The RegressionTest6 object tests Regression class using the following regression equation.
The RegressionTest6 object tests Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.RegressionTest6
object RegressionTest7 extends App
The RegressionTest7 object tests Regression class using the following regression equation.
The RegressionTest7 object tests Regression class using the following regression equation.
y = b dot x = b_0 + b_1*x1 + b_2*x_2.
> runMain scalation.analytics.RegressionTest7
object RegressionTest8 extends App
The RegressionTest8 object tests the Regression class using the AutoMPG dataset.
The RegressionTest8 object tests the Regression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. > runMain scalation.analytics.RegressionTest8
object RegressionTest9 extends App
The RegressionTest9 object is used to test the Regression class.
The RegressionTest9 object is used to test the Regression class.
y = b dot x = b0 + b1 * x1
This version uses gradient descent to search for the optimal solution for 'b'. Try normalizing the data first.

See also
MatrixTransform > runMain scalation.analytics.RegressionTest9
object RegressionTree extends ModelFactory
The RegressionTree companion object is used to count the number of leaves and provide factory functions.
object RegressionTreeTest extends App
The RegressionTreeTest object is used to test the RegressionTree class.
The RegressionTreeTest object is used to test the RegressionTree class. It tests a simple case that does not require a file to be read.

See also
translate.google.com/translate?hl=en&sl=zh-CN&u=https://www.hrwhisper.me/machine-learning-decision-tree/&prev=search > runMain scalation.analytics.RegressionTreeTest
object RegressionTree_GB extends ModelFactory
The RegressionTree_GB companion object defines hyper-parameters and provides a factory function.
object RegressionTree_GBTest extends App
The RegressionTree_GBTest object is used to test the RegressionTree_GB class.
The RegressionTree_GBTest object is used to test the RegressionTree_GB class. It tests a simple case that does not require a file to be read. > runMain scalation.analytics.RegressionTree_GBTest
object Regression_WLS
The Regression_WLS companion object provides methods for setting weights and testing.
object Regression_WLSTest extends App
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.

See also
statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.Regression_WLSTest
object RidgeRegression extends ModelFactory
The RidgeRegression companion object defines hyper-paramters and provides factory functions for the RidgeRegression class.
object RidgeRegressionTest extends App
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.
It compares RidgeRegression with Regression

See also
http://statmaster.sdu.dk/courses/st111/module03/index.html > runMain scalation.analytics.RidgeRegressionTest
object RidgeRegressionTest2 extends App
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.
Try non-default value for the 'lambda' hyper-parameter. > runMain scalation.analytics.RidgeRegressionTest2
object RidgeRegressionTest3 extends App
The RidgeRegressionTest3 object tests RidgeRegression class using the following regression equation.
The RidgeRegressionTest3 object tests RidgeRegression class using the following regression equation.
y = b dot x = b_1*x1 + b_2*x_2.
Test regression, forward selection and backward elimination. > runMain scalation.analytics.RidgeRegressionTest3
object RidgeRegressionTest4 extends App
The RidgeRegressionTest4 object tests RidgeRegression class using the following regression equation.
The RidgeRegressionTest4 object tests RidgeRegression class using the following regression equation.
y = b dot x = b_1*x1 + b_2*x_2.
> runMain scalation.analytics.RidgeRegressionTest4
object RidgeRegressionTest5 extends App
The RidgeRegressionTest5 object tests the multi-collinearity method in the RidgeRegression class using the following regression equation.
The RidgeRegressionTest5 object tests the multi-collinearity 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

See also
online.stat.psu.edu/online/development/stat501/12multicollinearity/05multico_vif.html
online.stat.psu.edu/online/development/stat501/data/bloodpress.txt > runMain scalation.analytics.RidgeRegressionTest5
object RidgeRegressionTest6 extends App
The RidgeRegressionTest6 object tests the RidgeRegression class using the AutoMPG dataset.
The RidgeRegressionTest6 object tests the RidgeRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.RidgeRegressionTest6
object RidgeRegressionTest7 extends App
The RidgeRegressionTest7 object tests the RidgeRegression class using the AutoMPG dataset.
The RidgeRegressionTest7 object tests the RidgeRegression class using the AutoMPG dataset. It illustrates using the Relation class for reading the data from a .csv file "auto-mpg.csv". Assumes no missing values. It also uses the 'findLambda' method to search for a shrinkage parameter that roughly mininizes 'sse_cv'. > runMain scalation.analytics.RidgeRegressionTest7
object RoundRegression
The RoundRegression companion object provides a factory method.
object RoundRegressionTest extends App
The RoundRegressionTest object tests RoundRegression class using the following regression equation.
The RoundRegressionTest object tests RoundRegression class using the following regression equation.
y = round (b dot x) = round (b_0 + b_1*x_1 + b_2*x_2).
> runMain scalation.analytics.RoundRegressionTest
object SimpleExpRegression extends ModelFactory
The SimpleExpRegression companion object provides factory apply functions and a testing method.
object SimpleExpRegressionTest extends App
The SimpleExpRegressionTest object tests SimpleExpRegression class using the following exponential regression problem.
The SimpleExpRegressionTest object tests SimpleExpRegression class using the following exponential regression problem. > runMain scalation.analytics.SimpleExpRegressionTest
object SimpleExpRegressionTest2 extends App
The SimpleExpRegressionTest2 object has a basic test for the SimpleExpRegression class.
The SimpleExpRegressionTest2 object has a basic test for the SimpleExpRegression class. > runMain scalation.analytics.SimpleExpRegressionTest2
object SimpleExpRegressionTest3 extends App
The SimpleExpRegressionTest3 object has a basic test for the SimpleExpRegression class.
The SimpleExpRegressionTest3 object has a basic test for the SimpleExpRegression class.

See also
http://www.cnachtsheim-text.csom.umn.edu/kut86916_ch13.pdf y = 58.6065 exp (-.03959 x) + e > runMain scalation.analytics.SimpleExpRegressionTest3
object SimpleRegression extends ModelFactory
The SimpleRegression companion object provides a simple factory method for building simple regression linear regression models.
object SimpleRegressionTest extends App
The SimpleRegressionTest object to test the SimpleRegression class.
The SimpleRegressionTest object to test the SimpleRegression class.
y = b0 + b1 * x
> runMain scalation.analytics.SimpleRegressionTest
object SimpleRegressionTest2 extends App
The SimpleRegressionTest2 object to test the SimpleRegression class.
The SimpleRegressionTest2 object to test the SimpleRegression class.
y = b0 + b1 * x
> runMain scalation.analytics.SimpleRegressionTest2
object SimpleRegressionTest3 extends App
The SimpleRegressionTest3 object is used to test the SimpleRegression class.
The SimpleRegressionTest3 object is used to test the SimpleRegression class.
y = b dot x = [b0, b1] dot [1, x1]

See also
http://www.analyzemath.com/statistics/linear_regression.html > runMain scalation.analytics.SimpleRegressionTest3
object SimpleRegressionTest4 extends App
The SimpleRegressionTest4 object is used to test the SimpleRegression class.
The SimpleRegressionTest4 object is used to test the SimpleRegression class.
y = b dot x = b0 + b1 * x1

See also
http://mathbits.com/mathbits/tisection/Statistics2/linear.htm > runMain scalation.analytics.SimpleRegressionTest4
object SimpleRegressionTest5 extends App
The SimpleRegressionTest5 object is used to test the SimpleRegression class.
The SimpleRegressionTest5 object is used to test the SimpleRegression class.
y = b dot x = b0 + b1 * x1
This version uses gradient descent to search for the optimal solution for b. > runMain scalation.analytics.SimpleRegressionTest5
object SimpleRegressionTest6 extends App
The SimpleRegressionTest6 object is used to test the SimpleRegression class.
The SimpleRegressionTest6 object is used to test the SimpleRegression class.
y = b dot x = b0 + b1 * x1
This version does Exploratory Data Analysis (EDA) on the AutoMPG dataset. > runMain scalation.analytics.SimpleRegressionTest6
object SimplerRegression extends Error
The SimplerRegression companion object provides a simple factory method for building simple regression linear regression models.
object SimplerRegressionTest extends App
The SimplerRegressionTest object is used to test the SimplerRegression class.
The SimplerRegressionTest object is used to test the SimplerRegression class.
y = b0 * x + e
> runMain scalation.analytics.SimplerRegressionTest
object SimplerRegressionTest2 extends App
The SimplerRegressionTest2 object is used to test the SimplerRegression class.
The SimplerRegressionTest2 object is used to test the SimplerRegression class.
y = b dot x + e = [b0] dot [x0] + e
> runMain scalation.analytics.SimplerRegressionTest2
object SimplerRegressionTest3 extends App
The SimplerRegressionTest3 object is used to test the SimplerRegression class.
The SimplerRegressionTest3 object is used to test the SimplerRegression class.
y = b dot x + e = [b0] dot [x0] + e
> runMain scalation.analytics.SimplerRegressionTest3
object SimplerRegressionTest4 extends App
The SimplerRegressionTest4 object is used to test the SimplerRegression class.
The SimplerRegressionTest4 object is used to test the SimplerRegression class.
y = b dot x = b0 * x0

See also
http://mathbits.com/mathbits/tisection/Statistics2/linear.htm > runMain scalation.analytics.SimplerRegressionTest4
object SumQueueTest extends App
The SumQueueTest object is used to test the SumQueue class.
The SumQueueTest object is used to test the SumQueue class. > runMain scalation.analytics.SumQueueTest
object SumQueueTest2 extends App
The SumQueueTest2 object is used to test the SumSqQueue class.
The SumQueueTest2 object is used to test the SumSqQueue class. > runMain scalation.analytics.SumQueueTest2
object TranRegression extends ModelFactory
The TranRegression companion object provides transformation and inverse transformation function based on the parameter 'lambda'.
The TranRegression companion object provides transformation and inverse transformation function based on the parameter 'lambda'. It support the family of Box-Cox transformations. Note, 'rescale' is defined in ModelFactory in Model.scala.
object TranRegressionEx
The TranRegressionEx provides a sample dataset for testing purposes.
The TranRegressionEx provides a sample dataset for testing purposes. Move the comments on the line used to generate the response 'y(k)' to test 1D and 2D cases.
object TranRegressionTest extends App
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.
> runMain scalation.analytics.TranRegressionTest
object TranRegressionTest2 extends App
The TranRegressionTest2 object tests TranRegression class using the following regression equation.
The TranRegressionTest2 object tests TranRegression class using the following regression equation.
sqrt (y) = b dot x = b_0 + b_1*x_1 + b_2*x_2.
> runMain scalation.analytics.TranRegressionTest2
object TranRegressionTest3 extends App
The TranRegressionTest3 object tests TranRegression class using the following regression equation.
The TranRegressionTest3 object tests TranRegression class using the following regression equation.
sqrt (y) = b dot x = b_0 + b_1*x_1 + b_2*x_2.
> runMain scalation.analytics.TranRegressionTest3
object TranRegressionTest4 extends App
The TranRegressionTest4 object tests TranRegression class using the following regression equation.
The TranRegressionTest4 object tests TranRegression class using the following regression equation.
sqrt (y) = b dot x = b_0 + b_1*x_1 + b_2*x_2.
> runMain scalation.analytics.TranRegressionTest4
object TranRegressionTest5 extends App
The TranRegressionTest5 object tests TranRegression class using the following regression equation.
The TranRegressionTest5 object tests TranRegression class using the following regression equation.
sqrt (y) = b dot x = b_0 + b_1*x_1 + b_2*x_2.
> runMain scalation.analytics.TranRegressionTest5
object TranRegressionTest6 extends App
The TranRegressionTest6 object tests TranRegression class using the following regression equation on the beer foam dataset.
The TranRegressionTest6 object tests TranRegression class using the following regression equation on the beer foam dataset.

See also
https://www.tf.uni-kiel.de/matwis/amat/iss/kap_2/articles/beer_article.pdf exp (y) = b dot x = b_0 + b_1*x_1. > runMain scalation.analytics.TranRegressionTest6
object TranRegressionTest7 extends App
The TranRegressionTest7 object tests the TranRegression class using the AutoMPG dataset.
The TranRegressionTest7 object tests the TranRegression class using the AutoMPG dataset. It also combines feature selection with cross-validation and plots R^{2, R}2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.TranRegressionTest7
object TranRegressionTest8 extends App
The TranRegressionTest8 object compares Regression vs.
The TranRegressionTest8 object compares Regression vs. QuadRegression vs. TranRegression. using the following regression equations.
y = b dot x = b_0 + b_1*x y = b dot x' = b_0 + b_1*x + b_2*x^{2
y = b dot x' = b_0 + b_1*x + b_2*x}2 + b_3*x^3
> runMain scalation.analytics.TranRegressionTest8
object TrigRegression extends ModelFactory
The TrigRegression companion object provides factory functions and functions for creating functional forms.
object TrigRegressionTest extends App
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 sin wt + b_2 cos wt + ... b_2k-1 sin kwt + b_2k cos kwt + e
The data is generated from a noisy cubic function. > runMain scalation.analytics.TrigRegressionTest
object TrigRegressionTest2 extends App
The TrigRegressionTest2 object tests TrigRegression class using the following regression equation.
The TrigRegressionTest2 object tests TrigRegression class using the following regression equation.
y = b dot x = b_0 + b_1 sin wt + b_2 cos wt + ... b_2k-1 sin kwt + b_2k cos kwt + e
The data is generated from periodic noisy cubic functions. > runMain scalation.analytics.TrigRegressionTest2
object Variable extends Error with Serializable
The Variable object provides utilities for variables.
object VariableKind extends Enumeration
The VariableKind object indicates the kind of variable.
object VariableTest extends App
The VariableTest the conversion of a categorical variable into multiple dummy variables.
The VariableTest the conversion of a categorical variable into multiple dummy variables. > runMain scalation.analytics.VariableTest

Packages

analytics

package analytics

Type Members

Value Members

Inherited from Error

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

analytics 

package analytics

Type Members

Value Members

Inherited from Error

Inherited from AnyRef

Inherited from Any

Ungrouped

analytics