1
0
Fork 0
mirror of https://github.com/tensorflow/haskell.git synced 2024-12-24 10:39:45 +01:00
Haskell bindings for TensorFlow
Find a file
fkm3 b3c0997a8c Add support for logging to tensorboard (#74)
Add support for logging to tensorboard

Based on @gnezdo's internal version with some differences:

* Uses a pure haskell implementation of EventWriter instead of FFI.
* Special `buildAnd*` functions were dropped in favor of using
  `mergeAllSummaries :: Build SummaryTensor` with the normal
  `build` function.
2017-02-20 19:16:42 -08:00
ci_build Add cabal files and CI setup for TFRecords. 2017-02-11 12:53:42 -08:00
docker Add cabal files and CI setup for TFRecords. 2017-02-11 12:53:42 -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 Add support for logging to tensorboard (#74) 2017-02-20 19:16:42 -08:00
tensorflow-core-ops Uprev to TF 1.0rc1. (#69) 2017-02-09 14:20:43 -08:00
tensorflow-logging Add support for logging to tensorboard (#74) 2017-02-20 19:16:42 -08:00
tensorflow-mnist Support fetching storable vectors + use them in benchmark (#50) 2016-12-14 18:53:06 -08:00
tensorflow-mnist-input-data Initial commit 2016-10-24 19:26:42 +00:00
tensorflow-nn Update type constraints to work around a ghc-8 bug. (#47) 2016-11-28 21:15:09 -08:00
tensorflow-opgen Support type attributes that aren't used by an input/output. (#51) 2016-12-15 11:52:48 -08:00
tensorflow-ops Add example to README + make haddock link more prominent (#60) 2017-01-16 20:44:45 -08:00
tensorflow-proto Add support for logging to tensorboard (#74) 2017-02-20 19:16:42 -08:00
tensorflow-queue Support fetching storable vectors + use them in benchmark (#50) 2016-12-14 18:53:06 -08: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 Haddock (#3) 2016-10-25 12:43:06 -07: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 Update Mac build instructions. (#73) 2017-02-12 22:17:38 -08:00
stack.yaml Add support for logging to tensorboard (#74) 2017-02-20 19:16:42 -08: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.build (TF.initializedVariable 0)
    b <- TF.build (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 <- TF.build (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.Value Float
                -> [TF.Tensor TF.Ref Float]
                -> TF.Build 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

The following instructions were verified with Mac OS X El Capitan.

  • Install dependencies via Homebrew:

      brew install protobuf
      brew install snappy
    
  • Install the TensorFlow library on your machine:

      curl https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-darwin-x86_64-1.0.0-rc0.tar.gz > libtensorflow.tar.gz
      tar zxf libtensorflow.tar.gz -C /usr/local
      mv /usr/local/lib/libtensorflow.so /usr/local/lib/libtensorflow.dylib
      install_name_tool -id libtensorflow.dylib /usr/local/lib/libtensorflow.dylib
      rm libtensorflow.tar.gz
    
  • Run stack:

      stack test