fastmath.regression — generateme/fastmath 1.5.0-alpha4

backend clj

(backend model)

Return name of backend library

cv clj

(cv model)

(cv model params)

Cross validation

data-native clj

(data-native model)

Return data transformed for backend library.

elastic-net clj

(elastic-net x y)

(elastic-net {:keys [lambda1 lambda2 tolerance max-iters]
              :or {lambda1 0.1 lambda2 0.1 tolerance 1.0E-4 max-iters 1000}}
             x
             y)

elastic-net regression. Backend library: smile

gaussian-process clj

(gaussian-process x y)

(gaussian-process {:keys [kernel lambda]
                   :or {kernel (k/kernel :gaussian) lambda 0.5}}
                  x
                  y)

gaussian-process regression. Backend library: smile

gaussian-process+ clj

(gaussian-process+ x y)

(gaussian-process+
  {:keys [kscale kernel noise normalize?]
   :or {kscale 1.0 kernel (k/kernel :gaussian 1.0) normalize? false}}
  xs
  y)

gradient-tree-boost clj

(gradient-tree-boost x y)

(gradient-tree-boost {:keys [loss number-of-trees shrinkage max-nodes subsample]
                      :or {loss :least-squares
                           number-of-trees 500
                           shrinkage 0.005
                           max-nodes 6
                           subsample 0.7}}
                     x
                     y)

gradient-tree-boost regression. Backend library: smile

lasso clj

(lasso x y)

(lasso {:keys [lambda tolerance max-iters]
        :or {lambda 10.0 tolerance 0.001 max-iters 1000}}
       x
       y)

lasso regression. Backend library: smile

loss-list clj

List of loss for Gradient Tree Boost algorithm

model-native clj

(model-native model)

Return trained model as a backend class.

neural-net clj

(neural-net x y)

(neural-net {:keys [activation-function layers learning-rate momentum
                    weight-decay number-of-epochs]
             :or {error-function :logistic-sigmoid
                  learning-rate 0.1
                  momentum 0.0
                  weight-decay 0.0
                  number-of-epochs 25}}
            x
            y)

neural-net regression. Backend library: smile

ols clj

(ols x y)

(ols {} x y)

ols regression. Backend library: smile

posterior-samples clj

(posterior-samples gp vs)

(posterior-samples gp vs stddev?)

Gaussian process - draw samples from posterior for given vs

predict clj

(predict model v)

(predict model v info?)

Predict for given vector. If info? is true returns also additional information (default false).

predict-all clj

(predict-all model v)

(predict-all model v info?)

Predict for given sequence of vectors. If info? is true returns also additional information (default false).

prior-samples clj

(prior-samples gp vs)

Gaussian process - draw samples from prior for given vs

random-forest clj

(random-forest x y)

(random-forest {:keys [number-of-trees mtry node-size max-nodes subsample]
                :or
                  {number-of-trees 500 node-size 2 max-nodes 100 subsample 1.0}}
               x
               y)

random-forest regression. Backend library: smile

rbf-network clj

(rbf-network x y)

(rbf-network {:keys [distance rbf number-of-basis normalize?]
              :or {distance dist/euclidean number-of-basis 10 normalize? false}}
             x
             y)

rbf-network regression. Backend library: smile

regression clj multimethod

regression-tree clj

(regression-tree x y)

(regression-tree {:keys [max-nodes node-size] :or {max-nodes 100 node-size 2}}
                 x
                 y)

regression-tree regression. Backend library: smile

ridge clj

(ridge x y)

(ridge {:keys [lambda] :or {lambda 0.1}} x y)

ridge regression. Backend library: smile

rls clj

(rls x y)

(rls {} x y)

rls regression. Backend library: smile

svr clj

(svr x y)

(svr {:keys [kernel C eps tolerance]
      :or {kernel (k/kernel :linear) C 1.0 eps 0.001 tolerance 0.001}}
     x
     y)

svr regression. Backend library: smile

train clj

(train model)

(train model xs ys)

Train another set of data for given regression model or force training already given data.

validate clj

(validate model tx ty)

Validate data against trained regression.