Liking cljdoc? Tell your friends :D
Clojure only.

uncomplicate.diamond.internal.dnnl.impl

args*clj

(args* args i arg-key arg)

batch-normalization-backward*clj

(batch-normalization-backward* eng
                               prop-kind
                               diff-data-desc
                               data-desc
                               epsilon
                               flags
                               hint-fwd-pd
                               attr)

batch-normalization-forward*clj

(batch-normalization-forward* eng prop-kind data-desc epsilon flags attr)

binary*clj

(binary* eng alg-kind src0 src1 dst attr)

concat*clj

(concat* eng dst concat-dimension src attr)
(concat* eng dst n concat-dimension srcs attr)

convolution-backward-data*clj

(convolution-backward-data* eng
                            alg-kind
                            diff-src-desc
                            weights-desc
                            diff-dst-desc
                            strides
                            dilates
                            padding-l
                            padding-r
                            hint-fwd-pd
                            attr)

convolution-backward-weights*clj

(convolution-backward-weights* eng
                               alg-kind
                               src-desc
                               diff-weights-desc
                               diff-bias-desc
                               diff-dst-desc
                               strides
                               dilates
                               padding-l
                               padding-r
                               hint-fwd-pd
                               attr)

convolution-forward*clj

(convolution-forward* eng
                      prop-kind
                      alg-kind
                      src-desc
                      weights-desc
                      bias-desc
                      dst-desc
                      strides
                      dilates
                      padding-l
                      padding-r
                      attr)

data-type*clj

(data-type* mem-desc)

deconvolution-backward-data*clj

(deconvolution-backward-data* eng
                              alg-kind
                              diff-src-desc
                              weights-desc
                              diff-dst-desc
                              strides
                              dilates
                              padding-l
                              padding-r
                              hint-fwd-pd
                              attr)

deconvolution-backward-weights*clj

(deconvolution-backward-weights* eng
                                 alg-kind
                                 src-desc
                                 diff-weights-desc
                                 diff-bias-desc
                                 diff-dst-desc
                                 strides
                                 dilates
                                 padding-l
                                 padding-r
                                 hint-fwd-pd
                                 attr)

deconvolution-forward*clj

(deconvolution-forward* eng
                        prop-kind
                        alg-kind
                        src-desc
                        weights-desc
                        bias-desc
                        dst-desc
                        strides
                        dilates
                        padding-l
                        padding-r
                        attr)

destroy-mem-desc*clj

(destroy-mem-desc* mem-desc)

dims*clj

(dims* mem-desc)

dnnl-errorclj

(dnnl-error err-code)
(dnnl-error err-code details)

eltwise-backward*clj

(eltwise-backward* eng
                   alg-kind
                   diff-data-desc
                   data-desc
                   alpha
                   beta
                   hint-fwd-pd
                   attr)

eltwise-forward*clj

(eltwise-forward* eng prop-kind alg-kind mem-desc alpha beta attr)

engine*clj

(engine* id)
(engine* id runtime)

engine-count*clj

(engine-count*)
(engine-count* runtime)

engine-kind*clj

(engine-kind* eng)

execute*clj

(execute* strm p args)

get-engine*clj

(get-engine* mem)

gru-backward*clj

(gru-backward* eng
               direction
               src-desc
               src-iter-desc
               weights-desc
               weights-iter-desc
               bias-desc
               dst-desc
               dst-iter-desc
               diff-src-desc
               diff-src-iter-desc
               diff-weights-desc
               diff-weights-iter-desc
               diff-bias-desc
               diff-dst-desc
               diff-dst-iter-desc
               hint-fwd-pd
               attr)

gru-forward*clj

(gru-forward* eng
              prop-kind
              direction
              src-desc
              src-iter-desc
              weights-desc
              weights-iter-desc
              bias-desc
              dst-desc
              dst-iter-desc
              attr)

inner-product-backward-data*clj

(inner-product-backward-data* eng
                              diff-src-desc
                              weights-desc
                              diff-dst-desc
                              hint-fwd-pd
                              attr)

inner-product-backward-weights*clj

(inner-product-backward-weights* eng
                                 src-desc
                                 diff-weights-desc
                                 diff-bias-desc
                                 diff-dst-desc
                                 hint-fwd-pd
                                 attr)

inner-product-forward*clj

(inner-product-forward* eng
                        prop-kind
                        src-desc
                        weights-desc
                        bias-desc
                        dst-desc
                        attr)

lstm-backward*clj

(lstm-backward* eng
                direction
                src-desc
                src-iter-desc
                src-iter-c-desc
                weights-iter-peephole-projection
                bias-desc
                dst-desc
                dst-iter-desc
                dst-iter-c-desc
                diff-src-desc
                diff-src-iter-desc
                diff-src-iter-c-desc
                diff-weights-iter-peephole-projection
                diff-bias-desc
                diff-dst-desc
                diff-dst-iter-desc
                diff-dst-iter-c-desc
                hint-fwd-pd
                attr)

lstm-forward*clj

(lstm-forward* eng
               prop-kind
               direction
               src-desc
               src-iter-desc
               src-iter-c-desc
               weights-desc
               weights-iter-desc
               weights-peephole-desc
               weights-projection-desc
               bias-desc
               dst-desc
               dst-iter-desc
               dst-iter-c-desc
               attr)

memory*clj

(memory* desc eng data master)

ndims*clj

(ndims* mem-desc)

pooling-backward*clj

(pooling-backward* eng
                   alg-kind
                   diff-src-desc
                   diff-dst-desc
                   strides
                   kernel
                   dilates
                   padding-l
                   padding-r
                   hint-fwd-pd
                   attr)

pooling-forward*clj

(pooling-forward* eng
                  prop-kind
                  alg-kind
                  src-desc
                  dst-desc
                  strides
                  kernel
                  dilates
                  padding-l
                  padding-r
                  attr)

primitive*clj

(primitive* pd)

query-md*clj

(query-md* pd what)
(query-md* pd what index)

reduction*clj

(reduction* eng alg-kind src-desc dst-desc p epsilon attr)

reorder*clj

(reorder* input input-eng output output-eng)

softmax-backward*clj

(softmax-backward* eng alg-kind diff-data-desc data-desc axis hint-fwd-pd attr)

softmax-forward*clj

(softmax-forward* eng prop-kind alg-kind mem-desc axis attr)

stream*clj

(stream* eng)
(stream* eng flags)

strides*clj

(strides* mem-desc)

submemory-desc*clj

(submemory-desc* parent-desc n)
(submemory-desc* parent-desc dims offsets)

sum*clj

(sum* eng dst scales src attr)

sum-pp*clj

(sum-pp* eng dst scales srcs attr)

vanilla-rnn-backward*clj

(vanilla-rnn-backward* eng
                       activation
                       direction
                       src-desc
                       src-iter-desc
                       weights-desc
                       weights-iter-desc
                       bias-desc
                       dst-desc
                       dst-iter-desc
                       diff-src-desc
                       diff-src-iter-desc
                       diff-weights-desc
                       diff-weights-iter-desc
                       diff-bias-desc
                       diff-dst-desc
                       diff-dst-iter-desc
                       alpha
                       hint-fwd-pd
                       attr)

vanilla-rnn-forward*clj

(vanilla-rnn-forward* eng
                      prop-kind
                      activation
                      direction
                      src-desc
                      src-iter-desc
                      weights-desc
                      weights-iter-desc
                      bias-desc
                      dst-desc
                      dst-iter-desc
                      alpha
                      attr)

wait*clj

(wait* strm)

with-checkcljmacro

(with-check status form)
(with-check status form details)

cljdoc builds & hosts documentation for Clojure/Script libraries

Keyboard shortcuts
Ctrl+kJump to recent docs
←Move to previous article
→Move to next article
Ctrl+/Jump to the search field
Raise an issueBrowse cljdoc sourceChat on Slack
× close