Packages

p

scalation

analytics

package analytics

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

Linear Supertypes
Error, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. analytics
  2. Error
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. 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

  2. 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

  3. 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

  4. 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

  5. case class AddGate() extends Product with Serializable

    Perform Add for vectors.

  6. 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.

  7. 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.

  8. 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'.

  9. class CoordDescentLasso extends AnyRef

    The CoordDescentLasso class find the optimal parameters 'b' using Coordinate Descent.

  10. 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_02, x_03, x_1, x_12, x_13, x_0*x_1, x_02*x_1, x_0*x_12] + e

    Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

    See also

    scalation.metamodel.QuadraticFit

  11. 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_02, x_03, x_1, x_12, x_13, x_0*x_1, x_02*x_1, x_0*x_12] + e

    Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

    See also

    scalation.metamodel.QuadraticFit

  12. 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'.

  13. 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'.

  14. 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

  15. trait ExpandableForms extends AnyRef

    The ExpandableForms trait provides the framwork for expanding a vector to include additional terms.

  16. 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.

  17. class Fit extends QoF with Error

    The Fit class provides methods to determine basic Quality of Fit 'QoF' measures.

  18. type FunctionP2S = (VectoD, VectoD) ⇒ Double

    Function from PairV to Scalar (Double)

  19. 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)'.

  20. 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

  21. type Ints = IndexedSeq[Int]

    Shorthand for array of integers

  22. 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)'.

  23. 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

  24. 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)

  25. type Matrices = IndexedSeq[MatriD]

    Collection of matrices

  26. 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)

  27. 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.

  28. 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

  29. case class MultiplyGate() extends Product with Serializable

    MultiplyGate is to perfrom dot product from input and weights 'w'.

  30. 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

  31. 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)

  32. type NetParams = IndexedSeq[NetParam]

    Collection of NetParams

  33. 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.

  34. 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.

  35. 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.

  36. 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 ------------------------------------------------------------------------------

  37. 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.

  38. 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.

  39. 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.

  40. 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

  41. 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

  42. 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).

  43. type PairD = (Double, Double)

    Pair of doubles

  44. type PairI = (Int, Int)

    Pair of integers

  45. type PairV = (VectoD, VectoD)

    Pair of double vectors

  46. 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.

  47. 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

  48. 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, t2 ... tk]'. Fit the parameter vector 'b' in the regression equation

    y = b dot x + e = b_0 + b_1 * t + b_2 * t2 ... b_k * tk + e

    where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to 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

  49. 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, t2 ... tk]'. Fit the parameter vector 'b' in the regression equation

    y = b dot x + e = b_0 + b_1 * t + b_2 * t2 ... b_k * tk + e

    where 'e' represents the residuals (the part not explained by the model). Use Least-Squares (minimizing the residuals) to 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

  50. 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'.

  51. 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.

  52. 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.

  53. 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).

  54. trait QoF extends AnyRef

    The QoF trait defines methods to determine basic Quality of Fit 'QoF' measures.

  55. 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'.

  56. 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_02, x_1, x_12] + 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

  57. 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'.

  58. 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_02, x_1, x_0*x_1, x_12] + e

    Adds an a constant term for intercept (must not include intercept (column of ones) in initial data matrix).

    See also

    scalation.metamodel.QuadraticFit

  59. 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.

  60. 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 ----------------------------------------------------------------------------

  61. 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)'.

  62. trait Reducer extends AnyRef

    The Reducer trait provides a common framework for several data reduction algorithms.

  63. 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)

  64. 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.

  65. 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.

  66. 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

  67. 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/

  68. 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'

  69. 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

  70. 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).

  71. 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

  72. class Softmax extends AnyRef

    Softmax class calculate softmax regularization for the input

  73. class StoppingRule extends AnyRef

    The StoppingRule class provides a stopping rule to terminating the iterative steps in an optimization early.

  74. type Strings = Array[String]

    Shorthand for array of strings

  75. 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.

  76. 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.

  77. class Tanh extends AnyRef

    The Tanh class implements Tanh and derivative for vector version

  78. 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

  79. 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

  80. 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'

  81. type Vectors = IndexedSeq[VectoD]

    Collection of vectors

Value Members

  1. val BASE_DIR: String

    The relative path for base directory

  2. 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

  3. 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

  4. 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

  5. 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

  6. final def flaw(method: String, message: String): Unit
    Definition Classes
    Error
  7. 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

  8. 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)

  9. 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

  10. 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)

  11. 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)

  12. 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)

  13. 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

  14. 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

  15. 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)

  16. 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

  17. 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)

  18. 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

  19. 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

  20. 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

  21. object ANCOVA extends Error

    The ANCOVA companion object provides helper functions.

  22. object ANCOVA1 extends Error

    The ANCOVA1 companion object provides factor functions.

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. 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

  32. object CoFilter_1D

    The Filter object provides the convolution and pooling operators.

  33. 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

  34. object ConvNet_1D

    The ConvNet_1D companion object provides factory functions for the ConvNet_1D class.

  35. 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

  36. 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

  37. 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

  38. 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

  39. object CubicRegression extends ModelFactory

    The CubicRegression companion object provides methods for creating functional forms.

  40. 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

  41. 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

  42. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.CubicRegressionTest3

  43. 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 R2, R2 bar and R^2 cv vs. the instance index. Runs the cubic case. > runMain scalation.analytics.CubicRegressionTest4

  44. 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*x2 y = b dot x' = b_0 + b_1*x + b_2*x2 + b_3*x^3

    > runMain scalation.analytics.CubicRegressionTest5

  45. object CubicXRegression extends ModelFactory

    The CubicXRegression companion object provides methods for creating functional forms.

  46. 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

  47. 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

  48. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.CubicXRegressionTest3

  49. 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 R2, R2 bar and R^2 cv vs. the instance index. Runs the cubic case. > runMain scalation.analytics.CubicXRegressionTest4

  50. 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.

  51. 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.

  52. 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

  53. 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

  54. 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

  55. 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

  56. 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

  57. 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

  58. 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

  59. 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

  60. 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

  61. 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

  62. 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

  63. 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

  64. 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

  65. 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

  66. 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

  67. 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

  68. 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

  69. 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

  70. 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

  71. 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.

  72. 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."

  73. 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

  74. 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

  75. 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

  76. 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

  77. 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

  78. 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

  79. 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

  80. 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

  81. 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

  82. 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

  83. object ExpRegression extends ModelFactory

    The ExpRegression companion object provides factory apply functions and a testing method.

  84. 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

  85. 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

  86. object Fit

    The Fit companion object provides factory methods for assessing quality of fit for standard types of modeling techniques.

  87. 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

  88. 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

  89. 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

  90. 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

  91. object ImputeBackward extends Imputation

    The ImputeBackward object imputes missing values using the subsequent value and slope.

  92. object ImputeForward extends Imputation

    The ImputeForward object imputes missing values using the previous value and slope.

  93. object ImputeMean extends Imputation

    The ImputeMean object imputes missing values using the filtered mean.

  94. object ImputeMovingAvg extends Imputation

    The ImputeMovingAvg object imputes missing values using the moving average.

  95. object ImputeNormal extends Imputation

    The ImputeNormal object imputes missing values using the median Normal variates.

  96. object ImputeNormalWin extends Imputation

    The ImputeNormalWin object imputes the missing values in the vector using Normal Distribution for a sliding window.

  97. object ImputeRegression extends Imputation

    The ImputeRegression object imputes missing values using SimpleRegression.

  98. 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.

  99. object KNN_Predictor extends ModelFactory

    The KNN_Predictor companion object provides a factory functions.

  100. 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

  101. 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

  102. 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

  103. object LassoRegression extends ModelFactory

    The LassoRegression companion object provides factory methods for the LassoRegression class.

  104. 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

  105. 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

  106. 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

  107. 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 R2, R2 Bar and R^2 cv vs. the instance index. > runMain scalation.analytics.LassoRegressionTest4

  108. 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

  109. object MV_Regression extends Error

    The MV_Regression companion object provides factory apply functions and a testing method.

  110. 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

  111. 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

  112. 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

  113. 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

  114. 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

  115. 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

  116. 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

  117. 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

  118. 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 R2, R2 Bar and R^2 cv vs. the instance index. > runMain scalation.analytics.MV_RegressionTest9

  119. 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.

  120. 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

  121. 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

  122. object ModelStudy extends Serializable

    The ModelStudy object records the names of modeling studies.

  123. object NMFactorizationTest extends App

    The NMFactorizationTest object to test NMFactorizationTest class.

    The NMFactorizationTest object to test NMFactorizationTest class. > runMain scalation.analytics.NMFactorizationTest

  124. 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.

  125. 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

  126. 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

  127. 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

  128. 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

  129. 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

  130. 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

  131. 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.

  132. 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.

  133. 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

  134. 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

  135. 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

  136. 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

  137. 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

  138. 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

  139. 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

  140. 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

  141. 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

  142. 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

  143. 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

  144. 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

  145. 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.

  146. 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.

  147. 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

  148. 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

  149. 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

  150. 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

  151. 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

  152. 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

  153. 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

  154. 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

  155. 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.

  156. 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

  157. object NullModel extends Error

    The NullModel companion object provides a simple factory method for building null models.

  158. 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

  159. 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

  160. object Optimizer

    The Optimizer object gives defaults for hyper-parameters as well as other adjustable program constants.

  161. 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.

  162. 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

  163. 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.

  164. 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.

  165. 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

  166. 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

  167. 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

  168. 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

  169. 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

  170. 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

  171. 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

  172. 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

  173. 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

  174. object PoissonRegression

    The PoissonRegression companion object provides factory functions.

  175. 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

  176. 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

  177. object PolyORegression extends ModelFactory

    The PolyORegression companion object provides factory functions and functions for creating functional forms.

  178. 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

  179. 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

  180. object PolyRegression extends ModelFactory

    The PolyRegression companion object provides factory functions and functions for creating functional forms.

  181. 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

  182. 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

  183. object PredictorMat

    The PredictorMat companion object provides a meythod for splitting a combined data matrix in predictor matrix and a response vector.

  184. object PredictorMat2

    The PredictorMat2 object provides functions for rescaling data and performing analysis.

  185. 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

  186. 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

  187. 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.

  188. 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

  189. 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

  190. 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

  191. 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

  192. 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

  193. 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

  194. object QuadRegression extends ModelFactory

    The QuadRegression companion object provides factory functions and functions for creating functional forms.

  195. 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

  196. 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

  197. 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

  198. 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

  199. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadRegressionTest5

  200. 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

  201. 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

  202. 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.

  203. 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

  204. 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

  205. 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

  206. 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

  207. 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

  208. object QuadXRegression extends ModelFactory

    The QuadXRegression companion object provides methods for creating functional forms.

  209. 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

  210. 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

  211. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadXRegressionTest3

  212. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.QuadXRegressionTest4

  213. object QuadraticFitTest extends App

    The QuadraticFitTest object is used to test the QuadraticFit class for a two dimensional case.

  214. object QuadraticFitTest2 extends App

    The QuadraticFitTest2 object is used to test the QuadraticFit class for a three dimensional case.

  215. object QuadraticFitTest3 extends App

    The QuadraticFitTest3 object is used to test the QuadraticFit class for a three dimensional case with noise.

  216. 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

  217. object RegTechnique extends Enumeration

    The RegTechnique object defines the implementation techniques available.

  218. object Regression extends ModelFactory

    The Regression companion object provides factory apply functions and a testing method.

  219. 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

  220. 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

  221. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.RegressionTest11

  222. 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

  223. 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

  224. 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

  225. 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

  226. 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

  227. 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

  228. 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

  229. 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

  230. 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

  231. object RegressionTree extends ModelFactory

    The RegressionTree companion object is used to count the number of leaves and provide factory functions.

  232. 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

  233. object RegressionTree_GB extends ModelFactory

    The RegressionTree_GB companion object defines hyper-parameters and provides a factory function.

  234. 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

  235. object Regression_WLS

    The Regression_WLS companion object provides methods for setting weights and testing.

  236. 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

  237. object RidgeRegression extends ModelFactory

    The RidgeRegression companion object defines hyper-paramters and provides factory functions for the RidgeRegression class.

  238. 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

  239. 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

  240. 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

  241. 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

  242. 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

  243. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.RidgeRegressionTest6

  244. 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

  245. object RoundRegression

    The RoundRegression companion object provides a factory method.

  246. 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

  247. object SimpleExpRegression extends ModelFactory

    The SimpleExpRegression companion object provides factory apply functions and a testing method.

  248. 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

  249. 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

  250. 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

  251. object SimpleRegression extends ModelFactory

    The SimpleRegression companion object provides a simple factory method for building simple regression linear regression models.

  252. 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

  253. 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

  254. 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

  255. 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

  256. 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

  257. 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

  258. object SimplerRegression extends Error

    The SimplerRegression companion object provides a simple factory method for building simple regression linear regression models.

  259. 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

  260. 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

  261. 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

  262. 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

  263. 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

  264. 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

  265. 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.

  266. 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.

  267. 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

  268. 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

  269. 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

  270. 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

  271. 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

  272. 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

  273. 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 R2, R2 bar and R^2 cv vs. the instance index. > runMain scalation.analytics.TranRegressionTest7

  274. 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*x2 y = b dot x' = b_0 + b_1*x + b_2*x2 + b_3*x^3

    > runMain scalation.analytics.TranRegressionTest8

  275. object TrigRegression extends ModelFactory

    The TrigRegression companion object provides factory functions and functions for creating functional forms.

  276. 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

  277. 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

  278. object Variable extends Error with Serializable

    The Variable object provides utilities for variables.

  279. object VariableKind extends Enumeration

    The VariableKind object indicates the kind of variable.

  280. 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

Inherited from Error

Inherited from AnyRef

Inherited from Any

Ungrouped