README
¶
WORK IN PROGRESS... USE AT OWN RISK :-)
go-torch
LibTorch (PyTorch) bindings for Golang. Library is first and foremost designed for running inference against serialized models exported from Python version of PyTorch. Library can also be used to compile TorchScript applications directly from Go.
Installing
$ go get github.com/orktes/go-torch
Usage
go-torch depends on the LibTorch shared library to be available. For more information refer to https://pytorch.org/cppdocs/. The is also an example Dockerfile which is used for executing tests for the library.
import (
"github.com/orktes/go-torch"
)
Creating Tensors
Supported scalar types:
- torch.Byte
uint8 - torch.Char
int8 - torch.Int
int32 - torch.Long
int64 - torch.Float
float32 - torch.Double
float64
matrix := []float32{
[]float32{1,2,3},
[]float32{4,5,6},
}
tensor, _ := torch.NewTensor(matrix)
tensor.Shape() // [2, 3]
tensor.DType() // torch.Float
Using serialized PyTorch models
For instructions on how to export models for PyTorch refer to the PyTorch documentation
// Load model
module, _ := torch.LoadJITModule("model.pt")
// Create an input tensor
inputTensor, _ := torch.NewTensor([][]float32{
[]float32{1, 2, 3},
})
// Forward propagation
res, _ := module.Forward(inputTensor)
Using TorchScript
Currently supported input and output types
- Tensor
- Tuple (of Tensor and/or nested Tuples)
sumScript = `
def sum(a, b):
return a + b
`
// Compile TorchScript
module, _ := torch.CompileTorchScript(sumScript)
// Create inputs
a, _ := torch.NewTensor([]float32{1})
b, _ := torch.NewTensor([]float32{2})
res, _ := module.RunMethod("sum", a, b)
fmt.Printf("[1] + [2] = %+v\n", res.(*torch.Tensor).Value())
// output: [1] + [2] = [3]
Acknowledgements
Lots of the functionality related to converting Golang types to PyTorch Tensors are a shameless copy on what Google is doing with their Go Tensorflow bindings. Therefore big part of the credit definetely goes to The TensorFlow Authors.
LICENSE
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type DType ¶
type DType C.Torch_DataType
DType tensor scalar data type
const ( // Byte byte tensors (go type uint8) Byte DType = C.Torch_Byte // Char char tensor (go type int8) Char DType = C.Torch_Char // Int int tensor (go type int32) Int DType = C.Torch_Int // Long long tensor (go type int64) Long DType = C.Torch_Long // Float tensor (go type float32) Float DType = C.Torch_Float // Double tensor (go type float64) Double DType = C.Torch_Double )
type Error ¶
type Error struct {
// contains filtered or unexported fields
}
Error errors returned by torch functions
type JITModule ¶
type JITModule struct {
// contains filtered or unexported fields
}
JITModule is a jit compiled PyTorch module
func LoadJITModule ¶
LoadJITModule loads module from file
type JITModuleMethod ¶
type JITModuleMethod struct {
Module *JITModule
Name string
// contains filtered or unexported fields
}
JITModuleMethod is single method from a JITModule
func (*JITModuleMethod) Run ¶
func (m *JITModuleMethod) Run(inputs ...interface{}) (interface{}, error)
Run executes given method with tensors as input
type JITModuleMethodArgument ¶
JITModuleMethodArgument contains information of a single method argument
type Tensor ¶
type Tensor struct {
// contains filtered or unexported fields
}
Tensor holds a multi-dimensional array of elements of a single data type.
func NewTensor ¶
NewTensor converts from a Go value to a Tensor. Valid values are scalars, slices, and arrays. Every element of a slice must have the same length so that the resulting Tensor has a valid shape.
func NewTensorWithShape ¶
NewTensorWithShape converts a single dimensional Go array or slice into a Tensor with given shape
Source Files