1
0
Fork 0
mirror of https://github.com/tensorflow/haskell.git synced 2024-12-03 16:29:46 +01:00
Haskell bindings for TensorFlow
Find a file
Judah Jacobson a7cbc27d36 Distinguish between "rendered" and "unrendered" Tensors. (#88)
Distinguish between "rendered" and "unrendered" Tensors.

There are now three types of `Tensor`:

- `Tensor Value a`: rendered value
- `Tensor Ref a`: rendered reference
- `Tensor Build a` : unrendered value

The extra bookkeeping makes it easier to track (and enforce) which tensors are
rendered or not.  For examples where this has been confusing in the past, see

With this change, pure ops look similar to before, returning `Tensor Build`
instead of `Tensor Value`.  "Stateful" (monadic) ops are unchanged.  For
example:

    add :: OneOf [..] t => Tensor v'1 t -> Tensor v'2 t -> Tensor Build t
    assign :: (MonadBuild m, TensorType t)
           => Tensor Ref t -> Tensor v'2 t -> m (Tensor Ref t)

The `gradients` function now requires that the variables over which it's
differentiating are pre-rendered:

    gradients :: (..., Rendered v2) => Tensor v1 a -> [Tensor v2 a]
              -> m [Tensor Value a]

(`Rendered v2` means that `v2` is either a `Ref` or a `Value`.)

Additionally, the implementation of `gradients` now takes care to render every
intermediate value when performing the reverse accumulation.  I suspect this
fixes an exponential blowup for complicated expressions.
2017-04-11 09:30:21 +02:00
ci_build Update to 1.0 release and newest proto-lens (#77) 2017-02-22 15:24:45 -08:00
docker Update to 1.0 release and newest proto-lens (#77) 2017-02-22 15:24:45 -08:00
docs/haddock Update haddocks. (#46) 2016-11-23 10:55:35 -08:00
google-shim Initial commit 2016-10-24 19:26:42 +00:00
tensorflow Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-core-ops Adapt to lts-8.6 and use proto-lens-0.2.0.0 2017-04-03 14:48:28 +02:00
tensorflow-logging Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-mnist Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-mnist-input-data Initial commit 2016-10-24 19:26:42 +00:00
tensorflow-nn Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-opgen Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-ops Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-proto Adapt to lts-8.6 and use proto-lens-0.2.0.0 2017-04-03 14:48:28 +02:00
tensorflow-queue Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
tensorflow-records Improve comments and make naming consistent. 2017-02-11 12:53:42 -08:00
tensorflow-records-conduit Add cabal files and CI setup for TFRecords. 2017-02-11 12:53:42 -08:00
tensorflow-test Make code --pedantic (#35) 2016-11-18 10:42:02 -08:00
third_party Uprev to TF 1.0rc1. (#69) 2017-02-09 14:20:43 -08:00
tools call sudo consistently within OSX build script (#91) 2017-04-11 09:30:21 +02:00
.gitignore Optimize fetching (#27) 2016-11-17 10:41:49 -08:00
.gitmodules Initial commit 2016-10-24 19:26:42 +00:00
CONTRIBUTING.md Initial commit 2016-10-24 19:26:42 +00:00
LICENSE Initial commit 2016-10-24 19:26:42 +00:00
README.md Distinguish between "rendered" and "unrendered" Tensors. (#88) 2017-04-11 09:30:21 +02:00
stack.yaml Adapt to lts-8.6 and use proto-lens-0.2.0.0 2017-04-03 14:48:28 +02:00

Build Status

The tensorflow-haskell package provides Haskell bindings to TensorFlow.

This is not an official Google product.

Documentation

https://tensorflow.github.io/haskell/haddock/

TensorFlow.Core is a good place to start.

Examples

Neural network model for the MNIST dataset: code

Toy example of a linear regression model (full code):

import Control.Monad (replicateM, replicateM_, zipWithM)
import System.Random (randomIO)
import Test.HUnit (assertBool)

import qualified TensorFlow.Core as TF
import qualified TensorFlow.GenOps.Core as TF
import qualified TensorFlow.Gradient as TF
import qualified TensorFlow.Ops as TF

main :: IO ()
main = do
    -- Generate data where `y = x*3 + 8`.
    xData <- replicateM 100 randomIO
    let yData = [x*3 + 8 | x <- xData]
    -- Fit linear regression model.
    (w, b) <- fit xData yData
    assertBool "w == 3" (abs (3 - w) < 0.001)
    assertBool "b == 8" (abs (8 - b) < 0.001)

fit :: [Float] -> [Float] -> IO (Float, Float)
fit xData yData = TF.runSession $ do
    -- Create tensorflow constants for x and y.
    let x = TF.vector xData
        y = TF.vector yData
    -- Create scalar variables for slope and intercept.
    w <- TF.initializedVariable 0
    b <- TF.initializedVariable 0
    -- Define the loss function.
    let yHat = (x `TF.mul` w) `TF.add` b
        loss = TF.square (yHat `TF.sub` y)
    -- Optimize with gradient descent.
    trainStep <- gradientDescent 0.001 loss [w, b]
    replicateM_ 1000 (TF.run trainStep)
    -- Return the learned parameters.
    (TF.Scalar w', TF.Scalar b') <- TF.run (w, b)
    return (w', b')

gradientDescent :: Float
                -> TF.Tensor TF.Build Float
                -> [TF.Tensor TF.Ref Float]
                -> TF.Session TF.ControlNode
gradientDescent alpha loss params = do
    let applyGrad param grad =
            TF.assign param (param `TF.sub` (TF.scalar alpha `TF.mul` grad))
    TF.group =<< zipWithM applyGrad params =<< TF.gradients loss params

Installation Instructions

Build with Docker on Linux

As an expedient we use docker for building. Once you have docker working, the following commands will compile and run the tests.

git clone --recursive https://github.com/tensorflow/haskell.git tensorflow-haskell
cd tensorflow-haskell
IMAGE_NAME=tensorflow/haskell:v0
docker build -t $IMAGE_NAME docker
# TODO: move the setup step to the docker script.
stack --docker --docker-image=$IMAGE_NAME setup
stack --docker --docker-image=$IMAGE_NAME test

There is also a demo application:

cd tensorflow-mnist
stack --docker --docker-image=$IMAGE_NAME build --exec Main

Build on Mac OS X

Run the install_osx_dependencies.sh script in the tools/ directory. The script installs dependencies via Homebrew and then downloads and installs the TensorFlow library on your machine under /usr/local.

After running the script to install system dependencies, build the project with stack:

stack test