package torch

  1. Overview
  2. Docs
Torch bindings for OCaml


Dune Dependency






The ocaml-torch project provides some OCaml bindings for the Torch library. This brings to OCaml NumPy-like tensor computations with GPU acceleration and tape-based automatic differentiation.

Published: 14 Jun 2023



ocaml-torch provides some ocaml bindings for the PyTorch tensor library. This brings to OCaml NumPy-like tensor computations with GPU acceleration and tape-based automatic differentiation.

These bindings use the PyTorch C++ API and are mostly automatically generated. The current GitHub tip and the opam package v0.7 corresponds to PyTorch v1.13.0.

On Linux note that you will need the PyTorch version using the appropriate cxx11 abi depending on your g++ version. cpu version, cuda 11.6 version.

Opam Installation

The opam package can be installed using the following command. This automatically installs the CPU version of libtorch.

opam install torch

You can then compile some sample code, see some instructions below. ocaml-torch can also be used in interactive mode via utop or ocaml-jupyter.

Here is a sample utop session.

Build a Simple Example

To build a first torch program, create a file with the following content.

open Torch

let () =
  let tensor = Tensor.randn [ 4; 2 ] in
  Tensor.print tensor

Then create a dune file with the following content:

  (names example)
  (libraries torch))

Run dune exec example.exe to compile the program and run it!

Alternatively you can first compile the code via dune build example.exe then run the executable _build/default/example.exe (note that building the bytecode target example.bc may not work on macos).

Tutorials and Examples

Some more advanced applications from external repos:

Sample Code

Below is an example of a linear model trained on the MNIST dataset (full code).

  (* Create two tensors to store model weights. *)
  let ws = Tensor.zeros [image_dim; label_count] ~requires_grad:true in
  let bs = Tensor.zeros [label_count] ~requires_grad:true in

  let model xs = Tensor.(mm xs ws + bs) in
  for index = 1 to 100 do
    (* Compute the cross-entropy loss. *)
    let loss =
      Tensor.cross_entropy_for_logits (model train_images) ~targets:train_labels

    Tensor.backward loss;

    (* Apply gradient descent, disable gradient tracking for these. *)
    Tensor.(no_grad (fun () ->
        ws -= grad ws * f learning_rate;
        bs -= grad bs * f learning_rate));

    (* Compute the validation error. *)
    let test_accuracy =
      Tensor.(argmax ~dim:(-1) (model test_images) = test_labels)
      |> Tensor.to_kind ~kind:(T Float)
      |> Tensor.sum
      |> Tensor.float_value
      |> fun sum -> sum /. test_samples
    printf "%d %f %.2f%%\n%!" index (Tensor.float_value loss) (100. *. test_accuracy);

Models and Weights

Various pre-trained computer vision models are implemented in the vision library. The weight files can be downloaded at the following links:

Running the pre-trained models on some sample images can the easily be done via the following commands.

dune exec examples/pretrained/predict.exe path/to/resnet18.ot images/tiger.jpg


Many thanks to @LaurentMazare for the original work of ocaml-torch.

Dependencies (14)

  1. libtorch >= "1.13.0" & < "1.14.0"
  2. ocaml-compiler-libs >= "v0.11.0"
  3. dune-configurator
  4. dune >= "2.0.0"
  5. ctypes-foreign
  6. ctypes >= "0.18.0"
  7. stdio >= "v0.16" & < "v0.17"
  8. ppx_jane >= "v0.16" & < "v0.17"
  9. ppx_inline_test >= "v0.16" & < "v0.17"
  10. ppx_expect >= "v0.16" & < "v0.17"
  11. ppx_bench >= "v0.16" & < "v0.17"
  12. core >= "v0.16" & < "v0.17"
  13. base >= "v0.16" & < "v0.17"
  14. ocaml >= "4.14"

Dev Dependencies


Used by





Innovation. Community. Security.