DiffSharp is a tensor library with support for differentiable programming.
It is designed for use in machine learning, probabilistic programming, optimization and other domains.
DiffSharp provides world-leading automatic differentiation capabilities for tensor code, including composable gradients, Hessians, Jacobians, directional derivatives, and matrix-free Hessian- and Jacobian-vector products over arbitrary user code. This goes beyond conventional tensor libraries such as PyTorch and TensorFlow, allowing the use of nested forward and reverse differentiation up to any level.
With DiffSharp, you can compute higher-order derivatives efficiently and differentiate functions that are internally making use of differentiation and gradient-based optimization.
DiffSharp comes with a LibTorch backend, using the same C++ and CUDA implementations for tensor computations that power PyTorch. On top of these raw tensors (LibTorch's ATen, excluding autograd), DiffSharp implements its own computation graph and differentiation capabilities. It is tested on Linux, macOS, and Windows, and it supports CUDA and GPUs.
The DiffSharp API is designed to be similar to the PyTorch Python API through very similar naming and idioms, and where elements have similar names the PyTorch documentation can generally be used as a guide.
DiffSharp uses the incredible F# programming language for tensor programming. F# code is generally faster and more robust than equivalent Python code, while still being succinct and compact like Python, making it an ideal modern AI and machine learning implementation language. This allows fluent and productive code for tensor programming.
All documentation pages in this website are interactive notebooks which you can execute directly in your browser without installing anything in your local machine.
Using the buttons on the top of each page, you can execute the page as an interactive notebook running on cloud servers provided by Google Colab and Binder.
Using the buttons you can also download a page as a script or an interactive notebook, which you can execute locally in Jupyter or Visual Studio Code using dotnet interactive.
type dsharp =
static member abs: input: Tensor -> Tensor
static member acos: input: Tensor -> Tensor
static member add: a: Tensor * b: Tensor -> Tensor
static member arange: endVal: float * ?startVal: float * ?step: float * ?device: Device * ?dtype: Dtype * ?backend: Backend -> Tensor + 1 overload
static member arangeLike: input: Tensor * endVal: float * ?startVal: float * ?step: float * ?device: Device * ?dtype: Dtype * ?backend: Backend -> Tensor + 1 overload
static member argmax: input: Tensor -> int[] + 1 overload
static member argmin: input: Tensor -> int[] + 1 overload
static member asin: input: Tensor -> Tensor
static member atan: input: Tensor -> Tensor
static member backends: unit -> Backend list
... <summary>
Tensor operations
</summary>
static member DiffSharp.dsharp.config: unit -> DiffSharp.Device * DiffSharp.Dtype * DiffSharp.Backend * DiffSharp.Printer static member DiffSharp.dsharp.config: configuration: (DiffSharp.Device * DiffSharp.Dtype * DiffSharp.Backend * DiffSharp.Printer) -> unit static member DiffSharp.dsharp.config: ?device: DiffSharp.Device * ?dtype: DiffSharp.Dtype * ?backend: DiffSharp.Backend * ?printer: DiffSharp.Printer -> unit
Multiple items module Backend
from DiffSharp <summary>
Contains functions and settings related to backend specifications.
</summary>
-------------------- type Backend =
| Reference
| Torch
| Other of name: string * code: int
override ToString: unit -> string
member Name: string <summary>
Represents a backend for DiffSharp tensors
</summary>
union case DiffSharp.Backend.Reference: DiffSharp.Backend <summary>
The reference backend
</summary>
static member DiffSharp.dsharp.seed: ?seed: int -> unit
type Tensor =
private | TensorC of primalRaw: RawTensor
| TensorF of primal: Tensor * derivative: Tensor * nestingTag: uint32
| TensorR of primal: Tensor * derivative: Tensor ref * parentOp: TensorOp * fanout: uint32 ref * nestingTag: uint32
interface IConvertible
interface IComparable
override Equals: other: obj -> bool
override GetHashCode: unit -> int
member GetSlice: bounds: int[,] -> Tensor
override ToString: unit -> string
member abs: unit -> Tensor
member acos: unit -> Tensor
member add: b: Tensor -> Tensor + 1 overload
member addSlice: location: seq<int> * b: Tensor -> Tensor
... <summary>
Represents a multi-dimensional data type containing elements of a single data type.
</summary> <example>
A tensor can be constructed from a list or sequence using <see cref="M:DiffSharp.dsharp.tensor(System.Object)" /><code>
let t = dsharp.tensor([[1.; -1.]; [1.; -1.]])
</code></example>
Multiple items type Conv2d =
inherit Model
new: inChannels: int * outChannels: int * ?kernelSize: int * ?stride: int * ?padding: int * ?dilation: int * ?kernelSizes: seq<int> * ?strides: seq<int> * ?paddings: seq<int> * ?dilations: seq<int> * ?bias: bool -> Conv2d
override ToString: unit -> string
override forward: value: Tensor -> Tensor
member bias: Tensor
member weight: Tensor <summary>A model that applies a 2D convolution over an input signal composed of several input planes</summary>
-------------------- new: inChannels: int * outChannels: int * ?kernelSize: int * ?stride: int * ?padding: int * ?dilation: int * ?kernelSizes: seq<int> * ?strides: seq<int> * ?paddings: seq<int> * ?dilations: seq<int> * ?bias: bool -> Conv2d
static member dsharp.relu: input: Tensor -> Tensor
static member dsharp.flatten: startDim: int * ?endDim: int -> (Tensor -> Tensor) static member dsharp.flatten: input: Tensor * ?startDim: int * ?endDim: int -> Tensor
val decoder: Model<Tensor,Tensor>
static member dsharp.unflatten: dim: int * unflattenedShape: seq<int> -> (Tensor -> Tensor) static member dsharp.unflatten: input: Tensor * dim: int * unflattenedShape: seq<int> -> Tensor
Multiple items type ConvTranspose2d =
inherit Model
new: inChannels: int * outChannels: int * ?kernelSize: int * ?stride: int * ?padding: int * ?dilation: int * ?kernelSizes: seq<int> * ?strides: seq<int> * ?paddings: seq<int> * ?dilations: seq<int> * ?bias: bool -> ConvTranspose2d
override ToString: unit -> string
override forward: value: Tensor -> Tensor
member bias: Tensor
member weight: Tensor <summary>A model that applies a 2D transposed convolution operator over an input image composed of several input planes.</summary>
-------------------- new: inChannels: int * outChannels: int * ?kernelSize: int * ?stride: int * ?padding: int * ?dilation: int * ?kernelSizes: seq<int> * ?strides: seq<int> * ?paddings: seq<int> * ?dilations: seq<int> * ?bias: bool -> ConvTranspose2d
static member dsharp.sigmoid: input: Tensor -> Tensor
val model: VAE
Multiple items type VAE =
inherit VAEBase
new: xShape: seq<int> * zDim: int * encoder: Model * decoder: Model -> VAE
override ToString: unit -> string
override decode: z: Tensor -> Tensor
override encode: x: Tensor -> Tensor * Tensor <summary>Variational auto-encoder</summary>
-------------------- new: xShape: seq<int> * zDim: int * encoder: Model * decoder: Model -> VAE
member DataLoader.epoch: ?numBatches: int -> seq<int * Tensor * Tensor>
val i: int
member ModelBase.reverseDiff: ?nestingTag: uint32 -> unit
val l: Tensor
member VAEBase.loss: x: Tensor * ?normalize: bool -> Tensor
member Optimizer.step: unit -> unit
val print: x: 'a -> unit <summary>
Print the given value to the console using the '%A' printf format specifier
</summary>
val validLoss: Tensor
Multiple items module Seq
from DiffSharp.Util <summary>
Contains extensions to the F# Seq module.
</summary>
-------------------- module Seq
from Microsoft.FSharp.Collections <summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
val sumBy: projection: ('T -> 'U) -> source: seq<'T> -> 'U (requires member (+) and member get_Zero) <summary>Returns the sum of the results generated by applying the function to each element of the sequence.</summary> <remarks>The generated elements are summed using the <c>+</c> operator and <c>Zero</c> property associated with the generated type.</remarks> <param name="projection">A function to transform items from the input sequence into the type that will be summed.</param> <param name="source">The input sequence.</param> <returns>The computed sum.</returns> <example id="sumby-1"><code lang="fsharp">
let input = [ "aa"; "bbb"; "cc" ]
input |> Seq.sumBy (fun s -> s.Length)
</code>
Evaluates to <c>7</c>.
</example>