README

TensorFlow in Go

Construct and execute TensorFlow graphs in Go.

GoDoc

WARNING: The API defined in this package is not stable and can change without notice. The same goes for the package path: (github.com/tensorflow/tensorflow/tensorflow/go).

Quickstart

Refer to Installing TensorFlow for Go

Building the TensorFlow C library from source

If the "Quickstart" instructions above do not work (perhaps the release archives are not available for your operating system or architecture, or you're using a different version of CUDA/cuDNN), then the TensorFlow C library must be built from source.

Prerequisites
Build
  1. Download the source code

    go get -d github.com/tensorflow/tensorflow/tensorflow/go
    
  2. Build the TensorFlow C library:

    cd ${GOPATH}/src/github.com/tensorflow/tensorflow
    ./configure
    bazel build -c opt //tensorflow:libtensorflow.so
    

    This can take a while (tens of minutes, more if also building for GPU).

  3. Make libtensorflow.so and libtensorflow_framework.so available to the linker. This can be done by either:

    a. Copying it to a system location, e.g.,

    sudo cp ${GOPATH}/src/github.com/tensorflow/tensorflow/bazel-bin/tensorflow/libtensorflow.so /usr/local/lib
    sudo cp ${GOPATH}/src/github.com/tensorflow/tensorflow/bazel-bin/tensorflow/libtensorflow_framework.so /usr/local/lib
    

    OR

    b. Setting environment variables:

    export LIBRARY_PATH=${GOPATH}/src/github.com/tensorflow/tensorflow/bazel-bin/tensorflow
    # Linux
    export LD_LIBRARY_PATH=${GOPATH}/src/github.com/tensorflow/tensorflow/bazel-bin/tensorflow
    # OS X
    export DYLD_LIBRARY_PATH=${GOPATH}/src/github.com/tensorflow/tensorflow/bazel-bin/tensorflow
    
  4. Build and test:

    go generate github.com/tensorflow/tensorflow/tensorflow/go/op
    go test github.com/tensorflow/tensorflow/tensorflow/go
    
Generate wrapper functions for ops

Go functions corresponding to TensorFlow operations are generated in op/wrappers.go. To regenerate them:

Prerequisites:

go generate github.com/tensorflow/tensorflow/tensorflow/go/op

Support

Use stackoverflow and/or Github issues.

Contributions

Contributions are welcome. If making any signification changes, probably best to discuss on a Github issue before investing too much time. Github pull requests are used for contributions.

Expand ▾ Collapse ▴

Documentation

Overview

    Package tensorflow is a Go binding to TensorFlow.

    The API is subject to change and may break at any time.

    TensorFlow (www.tensorflow.org) is an open source software library for numerical computation using data flow graphs. This package provides functionality to build and execute such graphs and depends on TensorFlow being available. For installation instructions see https://github.com/tensorflow/tensorflow/blob/master/tensorflow/go/README.md

    Example
    Output:
    
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func TypeOf

    func TypeOf(dt DataType, shape []int64) reflect.Type

      TypeOf converts from a DataType and Shape to the equivalent Go type.

      func Version

      func Version() string

        Version returns a string describing the version of the underlying TensorFlow runtime.

        Types

        type Consumer

        type Consumer struct {
        	// Op is the Operation that is consuming the output of another operation.
        	Op *Operation
        
        	// Index is the index of the input within Op that the output of another
        	// operation is connected to.
        	Index int
        }

          Consumer identifies a specific input of an operation that consumes the output of another operation.

          func (Consumer) DataType

          func (p Consumer) DataType() DataType

            DataType returns the type of the input.

            func (Consumer) Producer

            func (p Consumer) Producer() Output

              Producer returns the Output that is connected to this Consumer.

              type Context

              type Context struct {
              	// contains filtered or unexported fields
              }

                Context for executing operations eagerly.

                A Context allows operations to be executed immediately. It encapsulates information such as the available devices, resource manager etc. It also allows the user to configure execution using a ConfigProto, as they can configure a Session when executing a Graph.

                func NewContext

                func NewContext(options *ContextOptions) (*Context, error)

                  NewContext creates a new context for eager execution. options may be nil to use the default options.

                  func (*Context) ListDevices

                  func (c *Context) ListDevices() ([]Device, error)

                    ListDevices returns the list of devices associated with a Context.

                    type ContextOptions

                    type ContextOptions struct {
                    	// Config is a binary-serialized representation of the
                    	// tensorflow.ConfigProto protocol message
                    	// (https://www.tensorflow.org/code/tensorflow/core/protobuf/config.proto).
                    	Config []byte
                    
                    	// Sets the default execution mode
                    	Async bool
                    }

                      ContextOptions contains configuration information for a session

                      type DataType

                      type DataType C.TF_DataType

                        DataType holds the type for a scalar value. E.g., one slot in a tensor.

                        const (
                        	Float      DataType = C.TF_FLOAT
                        	Double     DataType = C.TF_DOUBLE
                        	Int32      DataType = C.TF_INT32
                        	Uint32     DataType = C.TF_UINT32
                        	Uint8      DataType = C.TF_UINT8
                        	Int16      DataType = C.TF_INT16
                        	Int8       DataType = C.TF_INT8
                        	String     DataType = C.TF_STRING
                        	Complex64  DataType = C.TF_COMPLEX64
                        	Complex    DataType = C.TF_COMPLEX
                        	Int64      DataType = C.TF_INT64
                        	Uint64     DataType = C.TF_UINT64
                        	Bool       DataType = C.TF_BOOL
                        	Qint8      DataType = C.TF_QINT8
                        	Quint8     DataType = C.TF_QUINT8
                        	Qint32     DataType = C.TF_QINT32
                        	Bfloat16   DataType = C.TF_BFLOAT16
                        	Qint16     DataType = C.TF_QINT16
                        	Quint16    DataType = C.TF_QUINT16
                        	Uint16     DataType = C.TF_UINT16
                        	Complex128 DataType = C.TF_COMPLEX128
                        	Half       DataType = C.TF_HALF
                        )

                          Types of scalar values in the TensorFlow type system.

                          type Device

                          type Device struct {
                          	Name, Type       string
                          	MemoryLimitBytes int64
                          }

                            Device structure contains information about a device associated with a session, as returned by ListDevices()

                            func (Device) String

                            func (d Device) String() string

                              String describes d and implements fmt.Stringer.

                              type Graph

                              type Graph struct {
                              	// contains filtered or unexported fields
                              }

                                Graph represents a computation graph. Graphs may be shared between sessions.

                                func NewGraph

                                func NewGraph() *Graph

                                  NewGraph returns a new Graph.

                                  func (*Graph) AddGradients

                                  func (g *Graph) AddGradients(prefix string, y []Output, x []Output, dx []Output) ([]Output, error)

                                    AddGradients adds operations to compute the partial derivatives of the sum of tensors in y with respect to tensors in x, i.e., d(y[0] + y[1] + ...) / d x[0], d(y[0] + y[1] + ... ) / d x[1] etc.

                                    prefix, if non-empty, is the name prefix used for all operations added to the graph to compute these gradients.

                                    func (*Graph) AddOperation

                                    func (g *Graph) AddOperation(args OpSpec) (*Operation, error)

                                      AddOperation adds an operation to g.

                                      func (*Graph) Import

                                      func (g *Graph) Import(def []byte, prefix string) error

                                        Import imports the nodes and edges from a serialized representation of another Graph into g.

                                        Names of imported nodes will be prefixed with prefix.

                                        func (*Graph) ImportWithOptions

                                        func (g *Graph) ImportWithOptions(def []byte, options GraphImportOptions) error

                                          ImportWithOptions imports the nodes and edges from a serialized representation of another Graph into g.

                                          Multiple options can be specified for the newly imported nodes.

                                          func (*Graph) Operation

                                          func (g *Graph) Operation(name string) *Operation

                                            Operation returns the Operation named name in the Graph, or nil if no such operation is present.

                                            func (*Graph) Operations

                                            func (g *Graph) Operations() []Operation

                                              Operations returns a list of all operations in the graph

                                              func (*Graph) WriteTo

                                              func (g *Graph) WriteTo(w io.Writer) (int64, error)

                                                WriteTo writes out a serialized representation of g to w.

                                                Implements the io.WriterTo interface.

                                                type GraphImportOptions

                                                type GraphImportOptions struct {
                                                	// Node prefix
                                                	Prefix string
                                                
                                                	// Execution device
                                                	Device string
                                                	// contains filtered or unexported fields
                                                }

                                                  The GraphImportOptions struct holds parameters for the ImportWithOptions function.

                                                  func (*GraphImportOptions) AddInputMapping

                                                  func (o *GraphImportOptions) AddInputMapping(src string, srcIndex int, dst Output)

                                                    AddInputMapping adds a mapping between an Output in the imported graph and an Ouput in the destination graph that it should be replaced with, where src:srcIndex is the name of the Operation and Output index to replace and dst is the output to replace it with.

                                                    type Input

                                                    type Input interface {
                                                    	// contains filtered or unexported methods
                                                    }

                                                      Input is the interface for specifying inputs to an operation being added to a Graph.

                                                      Operations can have multiple inputs, each of which could be either a tensor produced by another operation (an Output object), or a list of tensors produced by other operations (an OutputList). Thus, this interface is implemented by both Output and OutputList.

                                                      See OpSpec.Input for more information.

                                                      type LibraryHandler

                                                      type LibraryHandler struct {
                                                      	// contains filtered or unexported fields
                                                      }

                                                      func LoadLibrary

                                                      func LoadLibrary(path string) (*LibraryHandler, error)

                                                        Load library content into current context, useful to load ops implementation into non-monolitic TF build. Returns LibraryHandler or nil and error

                                                        type OpSpec

                                                        type OpSpec struct {
                                                        	// Type of the operation (e.g., "Add", "MatMul").
                                                        	Type string
                                                        
                                                        	// Name by which the added operation will be referred to in the Graph.
                                                        	// If omitted, defaults to Type.
                                                        	Name string
                                                        
                                                        	// Inputs to this operation, which in turn must be outputs
                                                        	// of other operations already added to the Graph.
                                                        	//
                                                        	// An operation may have multiple inputs with individual inputs being
                                                        	// either a single tensor produced by another operation or a list of
                                                        	// tensors produced by multiple operations. For example, the "Concat"
                                                        	// operation takes two inputs: (1) the dimension along which to
                                                        	// concatenate and (2) a list of tensors to concatenate. Thus, for
                                                        	// Concat, len(Input) must be 2, with the first element being an Output
                                                        	// and the second being an OutputList.
                                                        	Input []Input
                                                        
                                                        	// Map from attribute name to its value that will be attached to this
                                                        	// operation.
                                                        	Attrs map[string]interface{}
                                                        
                                                        	// Operations that must be executed before executing the operation
                                                        	// being added.
                                                        	ControlDependencies []*Operation
                                                        
                                                        	// The device on which the operation should be executed.
                                                        	// If omitted, an appropriate device will automatically be selected.
                                                        	//
                                                        	// For example, if set of "/device:GPU:0", then the operation will
                                                        	// execute on GPU #0.
                                                        	Device string
                                                        }

                                                          OpSpec is the specification of an Operation to be added to a Graph (using Graph.AddOperation).

                                                          type Operation

                                                          type Operation struct {
                                                          	// contains filtered or unexported fields
                                                          }

                                                            Operation that has been added to the graph.

                                                            func (*Operation) Attr

                                                            func (op *Operation) Attr(name string) (interface{}, error)

                                                              Attr returns the value of an attribute on op. It returns an error if the attribute does not exist.

                                                              func (*Operation) Device

                                                              func (op *Operation) Device() string

                                                                Device returns a specification of the device on which this operation will be executed, or the empty string if there is no such specification.

                                                                func (*Operation) Name

                                                                func (op *Operation) Name() string

                                                                  Name returns the name of the operation.

                                                                  func (*Operation) NumInputs

                                                                  func (op *Operation) NumInputs() int

                                                                    NumInputs returns the number of inputs of op.

                                                                    func (*Operation) NumOutputs

                                                                    func (op *Operation) NumOutputs() int

                                                                      NumOutputs returns the number of outputs of op.

                                                                      func (*Operation) Output

                                                                      func (op *Operation) Output(i int) Output

                                                                        Output returns the i-th output of op.

                                                                        func (*Operation) OutputListSize

                                                                        func (op *Operation) OutputListSize(output string) (int, error)

                                                                          OutputListSize returns the size of the list of Outputs that is produced by a named output of op.

                                                                          An Operation has multiple named outputs, each of which produces either a single tensor or a list of tensors. This method returns the size of the list of tensors for a specific output of the operation, identified by its name.

                                                                          func (*Operation) Type

                                                                          func (op *Operation) Type() string

                                                                            Type returns the name of the operator used by this operation.

                                                                            type Output

                                                                            type Output struct {
                                                                            	// Op is the Operation that produces this Output.
                                                                            	Op *Operation
                                                                            
                                                                            	// Index specifies the index of the output within the Operation.
                                                                            	Index int
                                                                            }

                                                                              Output represents one of the outputs of an operation in the graph. Has a DataType (and eventually a Shape). May be passed as an input argument to a function for adding operations to a graph, or to a Session's Run() method to fetch that output as a tensor.

                                                                              func (Output) Consumers

                                                                              func (p Output) Consumers() []Consumer

                                                                                Consumers returns the inputs that consume this output.

                                                                                func (Output) DataType

                                                                                func (p Output) DataType() DataType

                                                                                  DataType returns the type of elements in the tensor produced by p.

                                                                                  func (Output) Shape

                                                                                  func (p Output) Shape() Shape

                                                                                    Shape returns the (possibly incomplete) shape of the tensor produced p.

                                                                                    type OutputList

                                                                                    type OutputList []Output

                                                                                      OutputList represents a list of Outputs that can be provided as input to another operation.

                                                                                      type PartialRun

                                                                                      type PartialRun struct {
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                        PartialRun enables incremental evaluation of graphs.

                                                                                        PartialRun allows the caller to pause the evaluation of a graph, run arbitrary code that depends on the intermediate computation of the graph, and then resume graph execution. The results of the arbitrary code can be fed into the graph when resuming execution. In contrast, Session.Run executes the graph to compute the requested fetches using the provided feeds and discards all intermediate state (e.g., value of intermediate tensors) when it returns.

                                                                                        For example, consider a graph for unsupervised training of a neural network model. PartialRun can be used to pause execution after the forward pass of the network, let the caller actuate the output (e.g., play a game, actuate a robot etc.), determine the error/loss and then feed this calculated loss when resuming the backward pass of the graph.

                                                                                        Example
                                                                                        Output:
                                                                                        
                                                                                        3 10
                                                                                        

                                                                                        func (*PartialRun) Run

                                                                                        func (pr *PartialRun) Run(feeds map[Output]*Tensor, fetches []Output, targets []*Operation) ([]*Tensor, error)

                                                                                          Run resumes execution of the graph to compute the requested fetches and targets with the provided feeds.

                                                                                          type SavedModel

                                                                                          type SavedModel struct {
                                                                                          	Session    *Session
                                                                                          	Graph      *Graph
                                                                                          	Signatures map[string]Signature
                                                                                          }

                                                                                            SavedModel represents the contents of loaded SavedModel. TODO(jhseu): Add and document metagraphdef when we pregenerate protobufs.

                                                                                            func LoadSavedModel

                                                                                            func LoadSavedModel(exportDir string, tags []string, options *SessionOptions) (*SavedModel, error)

                                                                                              LoadSavedModel creates a new SavedModel from a model previously exported to a directory on disk.

                                                                                              Exported models contain a set of graphs and, optionally, variable values. Tags in the model identify a single graph. LoadSavedModel initializes a session with the identified graph and with variables initialized to from the checkpoints on disk.

                                                                                              The tensorflow package currently does not have the ability to export a model to a directory from Go. This function thus currently targets loading models exported in other languages, such as using tf.saved_model.builder in Python. See: https://www.tensorflow.org/code/tensorflow/python/saved_model/

                                                                                              type Session

                                                                                              type Session struct {
                                                                                              	// contains filtered or unexported fields
                                                                                              }

                                                                                                Session drives a TensorFlow graph computation.

                                                                                                When a Session is created with a given target, a new Session object is bound to the universe of resources specified by that target. Those resources are available to this session to perform computation described in the GraphDef. After creating the session with a graph, the caller uses the Run() API to perform the computation and potentially fetch outputs as Tensors. A Session allows concurrent calls to Run().

                                                                                                func NewSession

                                                                                                func NewSession(graph *Graph, options *SessionOptions) (*Session, error)

                                                                                                  NewSession creates a new execution session with the associated graph. options may be nil to use the default options.

                                                                                                  func (*Session) Close

                                                                                                  func (s *Session) Close() error

                                                                                                    Close a session. This contacts any other processes associated with this session, if applicable. Blocks until all previous calls to Run have returned.

                                                                                                    func (*Session) ListDevices

                                                                                                    func (s *Session) ListDevices() ([]Device, error)

                                                                                                      ListDevices returns the list of devices associated with a Session.

                                                                                                      func (*Session) NewPartialRun

                                                                                                      func (s *Session) NewPartialRun(feeds, fetches []Output, targets []*Operation) (*PartialRun, error)

                                                                                                        NewPartialRun sets up the graph for incremental evaluation.

                                                                                                        All values of feeds, fetches and targets that may be provided to Run calls on the returned PartialRun need to be provided to NewPartialRun.

                                                                                                        See documentation for the PartialRun type.

                                                                                                        func (*Session) Run

                                                                                                        func (s *Session) Run(feeds map[Output]*Tensor, fetches []Output, targets []*Operation) ([]*Tensor, error)

                                                                                                          Run the graph with the associated session starting with the supplied feeds to compute the value of the requested fetches. Runs, but does not return Tensors for operations specified in targets.

                                                                                                          On success, returns the fetched Tensors in the same order as supplied in the fetches argument. If fetches is set to nil, the returned Tensor fetches is empty.

                                                                                                          type SessionOptions

                                                                                                          type SessionOptions struct {
                                                                                                          	// Target indicates the TensorFlow runtime to connect to.
                                                                                                          	//
                                                                                                          	// If 'target' is empty or unspecified, the local TensorFlow runtime
                                                                                                          	// implementation will be used.  Otherwise, the TensorFlow engine
                                                                                                          	// defined by 'target' will be used to perform all computations.
                                                                                                          	//
                                                                                                          	// "target" can be either a single entry or a comma separated list
                                                                                                          	// of entries. Each entry is a resolvable address of one of the
                                                                                                          	// following formats:
                                                                                                          	//   local
                                                                                                          	//   ip:port
                                                                                                          	//   host:port
                                                                                                          	//   ... other system-specific formats to identify tasks and jobs ...
                                                                                                          	//
                                                                                                          	// NOTE: at the moment 'local' maps to an in-process service-based
                                                                                                          	// runtime.
                                                                                                          	//
                                                                                                          	// Upon creation, a single session affines itself to one of the
                                                                                                          	// remote processes, with possible load balancing choices when the
                                                                                                          	// "target" resolves to a list of possible processes.
                                                                                                          	//
                                                                                                          	// If the session disconnects from the remote process during its
                                                                                                          	// lifetime, session calls may fail immediately.
                                                                                                          	Target string
                                                                                                          
                                                                                                          	// Config is a binary-serialized representation of the
                                                                                                          	// tensorflow.ConfigProto protocol message
                                                                                                          	// (https://www.tensorflow.org/code/tensorflow/core/protobuf/config.proto).
                                                                                                          	Config []byte
                                                                                                          }

                                                                                                            SessionOptions contains configuration information for a session.

                                                                                                            type Shape

                                                                                                            type Shape struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              Shape represents the (possibly partially known) shape of a tensor that will be produced by an operation.

                                                                                                              The zero-value of a Shape represents a shape with an unknown number of dimensions.

                                                                                                              func MakeShape

                                                                                                              func MakeShape(shape ...int64) Shape

                                                                                                                MakeShape returns a Shape with the provided size of each dimension.

                                                                                                                A value of -1 implies that the size of the corresponding dimension is not known.

                                                                                                                func ScalarShape

                                                                                                                func ScalarShape() Shape

                                                                                                                  ScalarShape returns a Shape representing a scalar.

                                                                                                                  func (Shape) IsFullySpecified

                                                                                                                  func (s Shape) IsFullySpecified() bool

                                                                                                                    IsFullySpecified returns true iff the size of all the dimensions of s are known.

                                                                                                                    func (Shape) NumDimensions

                                                                                                                    func (s Shape) NumDimensions() int

                                                                                                                      NumDimensions returns the number of dimensions represented by s, or -1 if unknown.

                                                                                                                      func (Shape) Size

                                                                                                                      func (s Shape) Size(dim int) int64

                                                                                                                        Size returns the size of the dim-th dimension of the shape, or -1 if it is unknown.

                                                                                                                        REQUIRES: 0 <= dim < s.NumDimensions()

                                                                                                                        func (Shape) String

                                                                                                                        func (s Shape) String() string

                                                                                                                        func (Shape) ToSlice

                                                                                                                        func (s Shape) ToSlice() ([]int64, error)

                                                                                                                          ToSlice returns the (possibly partially known) shape represented by s as a slice, or an error if the number of dimensions is not known.

                                                                                                                          type Signature

                                                                                                                          type Signature struct {
                                                                                                                          	Inputs, Outputs map[string]TensorInfo
                                                                                                                          	MethodName      string
                                                                                                                          }

                                                                                                                            A Signature defines the signature of a computation supported by a TensorFlow graph.

                                                                                                                            For example, a model with two loss computations, sharing a single input, might have the following signature_def map.

                                                                                                                            Note that across the two Signatures "loss_A" and "loss_B", the input key, output key, and method_name are identical, and will be used by system(s) that implement or rely upon this particular loss method. The output tensor names differ, demonstrating how different outputs can exist for the same method.

                                                                                                                            signature_def {

                                                                                                                            key: "loss_A"
                                                                                                                            value {
                                                                                                                              inputs {
                                                                                                                                key: "input"
                                                                                                                                value {
                                                                                                                                  name: "input:0"
                                                                                                                                  dtype: DT_STRING
                                                                                                                                  tensor_shape: ...
                                                                                                                                }
                                                                                                                              }
                                                                                                                              outputs {
                                                                                                                                key: "loss_output"
                                                                                                                                value {
                                                                                                                                  name: "loss_output_A:0"
                                                                                                                                  dtype: DT_FLOAT
                                                                                                                                  tensor_shape: ...
                                                                                                                                }
                                                                                                                              }
                                                                                                                            }
                                                                                                                            ...
                                                                                                                            method_name: "some/package/compute_loss"
                                                                                                                            

                                                                                                                            } signature_def {

                                                                                                                            key: "loss_B"
                                                                                                                            value {
                                                                                                                              inputs {
                                                                                                                                key: "input"
                                                                                                                                value {
                                                                                                                                  name: "input:0"
                                                                                                                                  dtype: DT_STRING
                                                                                                                                  tensor_shape: ...
                                                                                                                                }
                                                                                                                              }
                                                                                                                              outputs {
                                                                                                                                key: "loss_output"
                                                                                                                                value {
                                                                                                                                  name: "loss_output_B:0"
                                                                                                                                  dtype: DT_FLOAT
                                                                                                                                  tensor_shape: ...
                                                                                                                                }
                                                                                                                              }
                                                                                                                            }
                                                                                                                            ...
                                                                                                                            method_name: "some/package/compute_loss"
                                                                                                                            

                                                                                                                            }

                                                                                                                            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

                                                                                                                              func NewTensor(value interface{}) (*Tensor, error)

                                                                                                                                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 ReadTensor

                                                                                                                                func ReadTensor(dataType DataType, shape []int64, r io.Reader) (*Tensor, error)

                                                                                                                                  ReadTensor constructs a Tensor with the provided type and shape from the serialized tensor contents in r.

                                                                                                                                  See also WriteContentsTo.

                                                                                                                                  func (*Tensor) DataType

                                                                                                                                  func (t *Tensor) DataType() DataType

                                                                                                                                    DataType returns the scalar datatype of the Tensor.

                                                                                                                                    func (*Tensor) Reshape

                                                                                                                                    func (t *Tensor) Reshape(new_shape []int64) error

                                                                                                                                      Reshape updates tensor's shape in place if this is possible or returns an error otherwise.

                                                                                                                                      func (*Tensor) Shape

                                                                                                                                      func (t *Tensor) Shape() []int64

                                                                                                                                        Shape returns the shape of the Tensor.

                                                                                                                                        func (*Tensor) Value

                                                                                                                                        func (t *Tensor) Value() interface{}

                                                                                                                                          Value converts the Tensor to a Go value. For now, not all Tensor types are supported, and this function may panic if it encounters an unsupported DataType.

                                                                                                                                          The type of the output depends on the Tensor type and dimensions. For example: Tensor(int64, 0): int64 Tensor(float64, 3): [][][]float64

                                                                                                                                          func (*Tensor) WriteContentsTo

                                                                                                                                          func (t *Tensor) WriteContentsTo(w io.Writer) (int64, error)

                                                                                                                                            WriteContentsTo writes the serialized contents of t to w.

                                                                                                                                            Returns the number of bytes written. See ReadTensor for reconstructing a Tensor from the serialized form.

                                                                                                                                            WARNING: WriteContentsTo is not comprehensive and will fail if t.DataType() is non-numeric (e.g., String). See https://github.com/tensorflow/tensorflow/issues/6003.

                                                                                                                                            type TensorHandle

                                                                                                                                            type TensorHandle struct {
                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                            }

                                                                                                                                              TensorHandle is a handle to a tensor on a device.

                                                                                                                                              A Tensor referenced by a TensorHandle may be on any device, whereas a Tensor always resides in the host CPU's memory.

                                                                                                                                              A Tensor referenced by a TensorHandle may not have been computed yet. For example, a TensorHandle might reference the output of an operation that has not finished executing. Because of this, various methods, such as Shape() may block until the tensor has been instantiated.

                                                                                                                                              This allows multiple operations to be performed on tensors on a device (e.g. a GPU) without sending these values back to the host CPU in between every operation.

                                                                                                                                              func NewTensorHandle

                                                                                                                                              func NewTensorHandle(t *Tensor) (*TensorHandle, error)

                                                                                                                                                NewTensorHandle creates a new tensor handle from a tensor.

                                                                                                                                                func (*TensorHandle) BackingDeviceName

                                                                                                                                                func (th *TensorHandle) BackingDeviceName() (string, error)

                                                                                                                                                  BackingDeviceName returns the name of the device in whose memory the tensor handle resides. This function will block till the operation that produces `h` has completed.

                                                                                                                                                  WARNING: The implementation currently returns the same as DeviceName(). After TensoFlow 1.13's C library is released, this implementation will be updated to return what the documentation says!

                                                                                                                                                  func (*TensorHandle) CopyToDevice

                                                                                                                                                  func (th *TensorHandle) CopyToDevice(c *Context, deviceName string) (*TensorHandle, error)

                                                                                                                                                    CopyToDevice creates a new TensorHandle with the same contents as this TensorHandle but placed in the memory of the device 'deviceName'. If source and destination are the same device, then this creates a new handle that shares the underlying buffer. Otherwise, it currently requires at least one of the source or destination devices to be CPU (i.e., for the source or destination tensor to be placed in host memory).

                                                                                                                                                    func (*TensorHandle) DataType

                                                                                                                                                    func (th *TensorHandle) DataType() DataType

                                                                                                                                                      DataType returns the TensorHandle's datatype.

                                                                                                                                                      func (*TensorHandle) DeviceName

                                                                                                                                                      func (th *TensorHandle) DeviceName() (string, error)

                                                                                                                                                        DeviceName returns the name of the device of the operation that produced the TensorHandle. If the handle was produced by a copy, it returns the destination device of the copy. Note that returned device name is not always the device holding the tensor handle's memory. If you want the latter, use BackingDeviceName. This function will block till the operation that produces th has completed.

                                                                                                                                                        func (*TensorHandle) Shape

                                                                                                                                                        func (th *TensorHandle) Shape() ([]int64, error)

                                                                                                                                                          Shape returns the shape of the Tensor referenced by th.

                                                                                                                                                          func (*TensorHandle) ToTensor

                                                                                                                                                          func (th *TensorHandle) ToTensor() (*Tensor, error)

                                                                                                                                                            ToTensor returns the Tensor referenced by th. It may block if this tensor is not yet computed.

                                                                                                                                                            type TensorInfo

                                                                                                                                                            type TensorInfo struct {
                                                                                                                                                            	Name  string
                                                                                                                                                            	DType DataType
                                                                                                                                                            	Shape Shape
                                                                                                                                                            }

                                                                                                                                                              A TensorInfo contains the information about a Tensor necessary for feeding or retrieval.

                                                                                                                                                              Directories

                                                                                                                                                              Path Synopsis
                                                                                                                                                              Command genop generates a Go source file with functions for TensorFlow ops.
                                                                                                                                                              Command genop generates a Go source file with functions for TensorFlow ops.
                                                                                                                                                              Package op defines functions for adding TensorFlow operations to a Graph.
                                                                                                                                                              Package op defines functions for adding TensorFlow operations to a Graph.