Merge branch 'main' into safe-names-dev

Author: dougalm

.github/workflows/docs.yaml

@@ -32,6 +32,13 @@ jobs:
         ${{ matrix.install_deps }}
         echo "${{ matrix.path_extension }}" >> $GITHUB_PATH
 
+    - name: Get example files
+      run: |
+        wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
+        wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
+        gunzip t10k-images-idx3-ubyte.gz t10k-labels-idx1-ubyte.gz
+        mv t10k-images-idx3-ubyte t10k-labels-idx1-ubyte $GITHUB_WORKSPACE/examples/
+
     - name: Cache
       uses: actions/cache@v2
       with:

CITATION.cff

@@ -0,0 +1,62 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- given-names: "Dougal"
+  family-names: "Maclaurin"
+- given-names: "Adam"
+  family-names: "Paszke"
+title: "Dex: typed and functional array processing"
+version: 0.0.0
+date-released: 2018-09-29
+url: "https://github.com/google-research/dex-lang"
+preferred-citation:
+  type: article
+  authors:
+  - given-names: "Adam"
+    family-names: "Paszke"
+  - given-names: "Daniel D."
+    family-names: "Johnson"
+  - given-names: "David"
+    family-names: "Duvenaud"
+  - given-names: "Dimitrios"
+    family-names: "Vytiniotis"
+  - given-names: "Alexey"
+    family-names: "Radul"
+  - given-names: "Matthew J."
+    family-names: "Johnson"
+  - given-names: "Jonathan"
+    family-names: "Ragan-Kelley"
+  - given-names: "Dougal"
+    family-names: "Maclaurin"
+  doi: "10.1145/3473593"
+  title: "Getting to the Point: Index Sets and Parallelism-Preserving Autodiff for Pointful Array Programming"
+  volume: 5
+  number: "ICFP"
+  year: 2021
+  month: 8
+  issue-date: "August 2021"
+  journal: "Proceedings of the ACM on Programming Languages"
+  pages: 29
+  abstract: >
+    We present a novel programming language design that attempts to combine the clarity
+    and safety of high-level functional languages with the efficiency and parallelism
+    of low-level numerical languages. We treat arrays as eagerly-memoized functions on
+    typed index sets, allowing abstract function manipulations, such as currying, to work
+    on arrays. In contrast to composing primitive bulk-array operations, we argue for
+    an explicit nested indexing style that mirrors application of functions to arguments.
+    We also introduce a fine-grained typed effects system which affords concise and automatically-parallelized
+    in-place updates. Specifically, an associative accumulation effect allows reverse-mode
+    automatic differentiation of in-place updates in a way that preserves parallelism.
+    Empirically, we benchmark against the Futhark array programming language, and demonstrate
+    that aggressive inlining and type-driven compilation allows array programs to be written
+    in an expressive, "pointful" style with little performance penalty.
+  keywords:
+  - "array programming"
+  - "automatic differentiation"
+  - "parallel computing"
+  url: "https://doi.org/10.1145/3473593"
+  publisher:
+    name: "Association for Computing Machinery"
+    city: "New York"
+    region: "NY"
+    country: "USA"

dex.cabal

@@ -13,7 +13,7 @@ maintainer:          [email protected]
 license-file:        LICENSE
 build-type:          Simple
 
-data-files:          lib/*.dx
+data-files:          lib/*.dx, static/*.html, static/*.js, static/*.css
 extra-source-files:  lib/*.dx,
                      src/lib/dexrt.bc,
                      static/index.js, static/style.css

examples/kernelregression.dx

@@ -1,7 +1,8 @@
+import linalg
 import plot
 
 -- Conjugate gradients solver
-def solve {m} (mat:m=>m=>Float) (b:m=>Float) : m=>Float =
+def solve' {m} (mat:m=>m=>Float) (b:m=>Float) : m=>Float =
   x0 = for i:m. 0.0
   ax = mat **. x0
   r0 = b - ax
@@ -16,6 +17,11 @@ def solve {m} (mat:m=>m=>Float) (b:m=>Float) : m=>Float =
        (x', r', p')
   xOut
 
+def chol_solve (l:LowerTriMat m Float) (b:m=>Float) : m=>Float =
+    b' = forward_substitute l b
+    u = transposeLowerToUpper l
+    backward_substitute u b'
+
 ' # Kernel ridge regression
 
 ' To learn a function $f_{true}: \mathcal{X} \to \mathbb R$
@@ -40,7 +46,7 @@ ys : Nx=>Float = for i. trueFun xs.i + noise * randn (ixkey k2 i)
 -- Kernel ridge regression
 def regress {a} (kernel: a -> a -> Float) (xs: Nx=>a) (ys: Nx=>Float) : a -> Float =
     gram = for i j. kernel xs.i xs.j + select (i==j) 0.0001 0.0
-    alpha = solve gram ys
+    alpha = solve' gram ys
     predict = \x. sum for i. alpha.i * kernel xs.i x
     predict
 
@@ -59,3 +65,35 @@ preds = map predict xtest
 
 :html showPlot $ xyPlot xtest preds
 > <html output>
+
+' # Gaussian process regression
+
+' GP regression (kriging) works in a similar way. Compared with kernel ridge regression, GP regression assumes Gaussian distributed prior. This, combined
+with the Bayes rule, gives the variance of the prediction.
+
+' In this implementation, the conjugate gradient solver is replaced with the
+cholesky solver from `lib/linalg.dx` for efficiency.
+
+def gp_regress (kernel: a -> a -> Float) (xs: n=>a) (ys: n=>Float)
+    : (a -> (Float&Float)) =
+    noise_var = 0.0001
+    gram = for i j. kernel xs.i xs.j
+    c = chol (gram + eye *. noise_var)
+    alpha = chol_solve c ys
+    predict = \x.
+        k' = for i. kernel xs.i x
+        mu = sum for i. alpha.i * k'.i
+        alpha' = chol_solve c k'
+        var = kernel x x + noise_var - sum for i. k'.i * alpha'.i
+        (mu, var)
+    predict
+
+gp_predict = gp_regress (rbf 0.2) xs ys
+
+(gp_preds, vars) = unzip (map gp_predict xtest)
+
+:html showPlot $ xycPlot xtest gp_preds (map sqrt vars)
+> <html output>
+
+:html showPlot $ xyPlot xtest vars
+> <html output>