Permalink
Switch branches/tags
Nothing to show
Commits on Sep 16, 2018
  1. Touch README.

    xkapastel committed Sep 15, 2018
Commits on Sep 14, 2018
Commits on Sep 13, 2018
  1. Add modules to circuit language.

    xkapastel committed Sep 13, 2018
    We need pluggable distributions over the functions blocks choose, to
    fit each problem.
    
    I'm also planning on fixing the T parameter throughout circuit, to
    make Denshi just one language instead of a very polymorphic library.
Commits on Sep 12, 2018
Commits on Sep 11, 2018
  1. The circuit runtime method is more like `apply` than `eval`. Also

    xkapastel committed Sep 11, 2018
    sneaking in Cargo.lock or whatever.
  2. Touch README, Cargo.toml

    xkapastel committed Sep 11, 2018
  3. Make circuits `(a * a) -> (a * a)`.

    xkapastel committed Sep 11, 2018
    Circuits are now two inputs to two outputs, instead of two inputs to
    one output.
    
    1. When dealing with discrete structures like terms, you usually have
    binary constructors, e.g. `(>>> foo bar)`. In order to have a circuit
    rewrite such a structure you'll need to be able to destruct them, and
    therefore need two outputs.
    
    2. I still want to do that "constraint solving circuit" idea based on
    Graphical Linear Algebra, where "reverse copy" does unification. So
    we'll need two outputs for that as well.
    
    In general, if you have functions from 2 to 1, you'll need functions
    from 1 to 2 for symmetry, and therefore the top type is 2 to 2.
  4. Touch README, misc. work.

    xkapastel committed Sep 11, 2018
Commits on Sep 10, 2018
  1. Implement Wrap.

    xkapastel committed Sep 10, 2018
  2. Read Lisp from stdin.

    xkapastel committed Sep 10, 2018
  3. Filling out Lisp API.

    xkapastel committed Sep 10, 2018
  4. Lisp is running!

    xkapastel committed Sep 10, 2018
  5. Make `circuit` module.

    xkapastel committed Sep 10, 2018
  6. Allocate Lisp values from an arena.

    xkapastel committed Sep 10, 2018
    The idea here is that Lisp is only used to configure stuff and won't
    execute for too long. So we just bump from an arena instead of
    bothering with GC.
  7. Start work on Lisp evaluator.

    xkapastel committed Sep 10, 2018
    I want a small language to control training, generate reports
    etc. Programs in it won't be long lived, and so don't need a garbage
    collector. So my current idea is to write a vau calculus Lisp and just
    leak in to an Arena.
Commits on Sep 9, 2018
  1. Tweak hyperparameters.

    xkapastel committed Sep 9, 2018
  2. Better hyperparameters for sanity check.

    xkapastel committed Sep 9, 2018
    The width didn't need to be so high; we don't need to sample many
    values to see if a circuit is correct or not, at least not for this
    example.
  3. Rewrite circuit runtime.

    xkapastel committed Sep 9, 2018
    I think this new design is simpler and more compositional.
    
    1. We keep `Block`s in their "raw" format, with the 4 floats.
    
    This is better because there is one source of truth for what a
    `Block`'s state is, instead of translating and doing training on the
    `Block`s with usize etc.
    
    2. We have `Runtime`s that give meaning to "raw" blocks.
    
    Follows from 1.
    
    3. We have `Solver`s instead of just a `train` function.
    
    We can have many different kinds of solvers, that do symbolic
    regression, or maybe manual aesthetic selection, or whatever. Better
    than one-size-fits-all `train`.
Commits on Sep 8, 2018
  1. Initial.

    xkapastel committed Sep 8, 2018