fastmath.regression — generateme/fastmath 1.4.0-SNAPSHOT

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)

GPProto clj protocol

posterior-samples clj

(posterior-samples gp vs)

(posterior-samples gp vs stddev?)

Draw samples from posterior for given vs

prior-samples clj

(prior-samples _ vs)

Draw samples from prior for given vs

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

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

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

RegressionProto clj protocol

backend clj

(backend _)

cv clj

(cv _)

(cv _ params)

data-native clj

(data-native _)

model-native clj

(model-native _)

predict clj

(predict _ v)

(predict _ v info?)

predict-all clj

(predict-all _ vs)

(predict-all _ v info?)

stats clj

(stats _)

train clj

(train _)

(train _ x y)

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

validate clj

(validate model tx ty)

Validate data against trained regression.