ncs

package module
Version: v0.0.0-...-0163013 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 25, 2020 License: Apache-2.0 Imports: 5 Imported by: 3

README

ncs

GoDoc License

Neural Compute Stick V2.0 API Go binding

NCSDK API V2 IS PARTIALLY BROKEN on macOS AT THE MOMENT -- EVERYTHING WORKS FINE ON LINUX

The code in this repository has been tested on the following Linux OS:

Distributor ID:	Ubuntu
Description:	Ubuntu 16.04.5 LTS
Release:	16.04
Codename:	xenial

Linux ubuntu-xenial 4.4.0-134-generic #160-Ubuntu SMP Wed Aug 15 14:58:00 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux

The Movidius NCSDK API coverage provided in this repo should give you all the tools to use Movidius NCS to perform Neural Network inference.

Quick start

On MacOS, clone macos-V2 branch:

$ git clone -b macos-V2 https://github.com/milosgajdos/ncsdk.git

Build ncsdk API libraries:

$ cd api/src && sudo make basicinstall pythoninstall

Test NCSDK example:

$ cd ../../examples/apps/hello_ncs_cpp/ && make run

Example Go program

The example below shows how to create and destroy the basic resource types the NCSDK API 2.0 provides. For more complex examples please see examples

package main

import (
	"log"

	"github.com/milosgajdos/ncs"
)

func main() {
	var err error
	defer func() {
		if err != nil {
			log.Fatalf("Error: %s", err)
		}
	}()
	log.Printf("Attempting to create NCS device handle")
	dev, e := ncs.NewDevice(0)
	if e != nil {
                err = e
		return
	}
	defer dev.Destroy()
	log.Printf("NCS device handle successfully created")

	log.Printf("Attempting to open NCS device")
	err = dev.Open()
	if err != nil {
		return
	}
	defer dev.Close()
	log.Printf("NCS device successfully opened")

	log.Printf("Attempting to create NCS graph handle")
	graph, e := ncs.NewGraph("NCSGraph")
	if e != nil {
                err = e
		return
	}
	defer graph.Destroy()
	log.Printf("NCS graph handle successfully created")

	log.Printf("Attempting to create NCS FIFO handle")
	fifo, e := ncs.NewFifo("TestFIFO", ncs.FifoHostRO)
	defer fifo.Destroy()
	if e != nil {
                err = e
		return
	}
	log.Printf("NCS FIFO handle successfully created")
}

If your Movidius NCS device is plugged in you should see the following output when running the program above:

2018/08/27 00:43:00 Attempting to create NCS device handle
2018/08/27 00:43:00 NCS device handle successfully created
2018/08/27 00:43:00 Attempting to open NCS device
2018/08/27 00:43:03 NCS device successfully opened
2018/08/27 00:43:03 Attempting to create NCS graph handle
2018/08/27 00:43:03 NCS graph handle successfully created
2018/08/27 00:43:03 Attempting to create NCS FIFO handle
2018/08/27 00:43:03 NCS FIFO handle successfully created

Documentation

Overview

For more information about how to install the SDK go here: https://movidius.github.io/ncsdk/install.html

Index

Constants

View Source
const (
	// MaxNameSize is the maximum length of device or graph name size
	MaxNameSize = 28
	// ThermalBufferSize is the size of the temperature buffer as returned when querying device
	ThermalBufferSize = 100
	// DebugBufferSize is the size of the debug information buffer as returned by API
	DebugBufferSize = 120
	// VersionMaxSize is the max length of various version options (HW, firmewre etc.) as returned by API
	VersionMaxSize = 4
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Device

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

Device is Neural Compute Stick (NCS) device

func NewDevice

func NewDevice(index int) (*Device, error)

NewDevice creates new NCS device handle and returns it.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceCreate.html

func (*Device) Close

func (d *Device) Close() error

Close closes the communication channel with NCS device. It returns error if it fails to close the communication channel.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceClose.html

func (*Device) Destroy

func (d *Device) Destroy() error

Destroy destroys NCS device handle and frees associated resources. This function must be called for every device that was initialized with NewDevice().

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceDestroy.html

func (*Device) GetOption

func (d *Device) GetOption(opt DeviceOption) ([]byte, error)

GetOption queries the value of an option for the device and returns it encoded in a byte slice. It returns error if it fails to retrieve the option value.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceGetOption.html

func (*Device) GetOptionWithByteSize

func (d *Device) GetOptionWithByteSize(opt DeviceOption, size uint) ([]byte, error)

GetOptionsWithSize queries NCS device options and returns it encoded in a byte slice of size elements. This function is similar to GetOption(), however as opposed to GetOption() which first queries the NCS device for the size of the requested options, it attempts to request the options data by specifying its size in raw bytes explicitly, hence it returns the queried options data faster. It returns error if it fails to retrieve the options or if the requested size of the options is invalid.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceGetOption.html

func (*Device) Open

func (d *Device) Open() error

Open initializes NCS device and opens device communication channel. It returns error if it fails to open or initialize the communication channel with the device.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncDeviceOpen.html

type DeviceHWVersion

type DeviceHWVersion int

DeviceHWVersion defines neural compute device hardware version

const (
	MA2450 DeviceHWVersion = iota
	MA2480
)

func (DeviceHWVersion) String

func (hw DeviceHWVersion) String() string

String implements fmt.Stringer interface

type DeviceOption

type DeviceOption int

DeviceOption defines NCS device options. The options starting with RW are both gettable and settable. The options starting with RO are only gettable.

const (
	// RODeviceThermalStats queries device temperatures in degrees Celsius.
	// This option returns []float64 array of max temperatures for the last ThermalBufferSize seconds.
	RODeviceThermalStats DeviceOption = (2000 + iota)
	// RODeviceThermalThrottling queries temperature throttling level.
	RODeviceThermalThrottle
	// RODeviceState queries the state of the device.
	RODeviceState
	// RODeviceMemoryUsed queries current memory in use on the device in bytes.
	RODeviceMemoryUsed
	// RODeviceMemorySize queries total memory available on the device in bytes.
	RODeviceMemorySize
	// RODeviceMaxFifoCount queries maximum number of FIFOs that can be allocated for the device.
	RODeviceMaxFifoCount
	// RODeviceAllocatedFifoCount queries number of FIFOs currently allocated for the device.
	RODeviceAllocatedFifoCount
	// RODeviceMaxMaxGraphCount queries the maximum number of graphs that can be allocated for the device.
	RODeviceMaxGraphCount
	// RODeviceAllocatedGraphCount queries the number of graphs currently allocated for the device.
	RODeviceAllocatedGraphCount
	// RODeviceClassLimit queries the highest device option class supported.
	RODeviceClassLimit
	// RODeviceFirmwareVersion queries the version of the firmware currently running on the device.
	RODeviceFirmwareVersion
	// RODeviceDebugInfo queries more detailed info when the result of API call is StatusMyriadError.
	RODeviceDebugInfo
	// RODeviceMVTensorVersion queries the version of the mvtensor library that was linked with the API.
	RODeviceMVTensorVersion
	// RODeviceName queries the internal name of the device.
	RODeviceName
	// RODeviceMaxExecutors is reserved for future use.
	RODeviceMaxExecutors
	// RODeviceHWVersion queries the hardware version of the device.
	RODeviceHWVersion
)

func (DeviceOption) Decode

func (do DeviceOption) Decode(data []byte, count int) (interface{}, error)

Decode decodes options data encoded in raw bytes and returns it in its native type. The returned data can be asserted into its native type. If the data contains more than one element you need to specify the number of expected elements via count. It returns error if the data fails to be decoded into the option native type.

func (DeviceOption) String

func (do DeviceOption) String() string

String implements fmt.Stringer interface for DeviceOption

func (DeviceOption) Value

func (do DeviceOption) Value() int

Value returns option value as integer

type DeviceState

type DeviceState int

DeviceState represents NCS device state

const (
	// DeviceCreated means NCS device handle has been created.
	DeviceCreated DeviceState = iota
	// DeviceOpened means NCS device handle has been opened.
	DeviceOpened
	// DeviceClosed means NCS device handle has been closed.
	DeviceClosed
)

func (DeviceState) String

func (ds DeviceState) String() string

String implements fmt.Stringer interface

type DeviceThermalThrottle

type DeviceThermalThrottle int

DeviceThermalThrottle defines thermal throttle level

const (
	// NoThrottle means no limit reached
	NoThrottle DeviceThermalThrottle = iota
	// LowerGuard means means lower guard temperature threshold of chip sensor has been reached
	// Short throttling time is in action between inferences to protect the device
	LowerGuard
	// UpperGuards means upper guard temperature of chip sensor has been reached
	// Long throttling time is in action between inferences to protect the device
	UpperGuard
)

func (DeviceThermalThrottle) String

func (dt DeviceThermalThrottle) String() string

String implements fmt.Stringer interface

type Fifo

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

Fifo is NCSDK FIFO queue

func NewFifo

func NewFifo(name string, t FifoType) (*Fifo, error)

NewFifo creates new FIFO queue with given name and returns it It returns error if it fails to create new queue

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoCreate.html

func (*Fifo) Allocate

func (f *Fifo) Allocate(d *Device, td *TensorDesc, numElem uint) error

Allocate allocates memory for a FIFO for the specified device based on the number of elements the FIFO will hold and tensorDesc, which describes the expected shape of the FIFO’s elements It returns error when it fails to allocate FIFO

More information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoAllocate.html

func (*Fifo) Destroy

func (f *Fifo) Destroy() error

Destroy destroys NCS FIFO handle and frees associated resources. This function must be called for every FIFO handle that was initialized with NewFifo()

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoDestroy.html

func (*Fifo) GetOption

func (f *Fifo) GetOption(opt FifoOption) ([]byte, error)

GetOptions queries FIFO options and returns it encoded in a byte slice It returns error if it fails to retrieve the options

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoGetOption.html

func (*Fifo) GetOptionWithByteSize

func (f *Fifo) GetOptionWithByteSize(opt FifoOption, size uint) ([]byte, error)

GetOptionsWithSize queries NCS fifo options and returns it encoded in a byte slice of size elements. This function is similar to GetOption(), however as opposed to GetOption() which first queries the NCS device for the size of the requested options, it attempts to request the options data by specifying its size in raw bytes explicitly, hence it returns the queried options data faster. It returns error if it fails to retrieve the options or if the requested size of the options is invalid.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoGetOption.html

func (*Fifo) ReadElem

func (f *Fifo) ReadElem() (*Tensor, error)

ReadElem reads an element from a FIFO, usually the result of an inference as a tensor, along with the associated user-defined data If it fails to read the element it returns error

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoReadElem.html

func (*Fifo) RemoveElem

func (f *Fifo) RemoveElem() error

RemoveElem removes an element from a FIFO If it fails to remove the element it returns error THIS FUNCTION IS NOT IMPLEMENTED YET

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoRemoveElem.html

func (*Fifo) WriteElem

func (f *Fifo) WriteElem(data []byte, metaData interface{}) error

WriteElem writes an element to a FIFO, usually an input tensor for inference along with some metadata If it fails to write the element it returns error

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoWriteElem.html

type FifoDataType

type FifoDataType int

FifoDataType defines possible data types for FIFOs.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoDataType_t.html

const (
	// FifoFP16 data is in half precision (16 bit) floating point format (FP16).
	FifoFP16 FifoDataType = iota
	// FifoFP32 data is in full precision (32 bit) floating point format (FP32).
	FifoFP32
)

func (FifoDataType) String

func (fd FifoDataType) String() string

String implements fmt.Stringer interface

type FifoOption

type FifoOption int

FifoOption is FIFO option which can be used to query and set various FIFO properties. The options starting with RW are both gettable and settable. The options starting with RO are only gettable. All settable options except for RWFifoHostTensorDesc must be set before FIFO is allocated.

const (
	// RWFifoType configure the fifo type to either of FifoType options
	RWFifoType FifoOption = iota
	// RWFifoConsumerCount is number of consumers of elements before the element is removed
	RWFifoConsumerCount
	// RWFifoDataType configures fifo data type to either of FifoDataType options
	RWFifoDataType
	// RWFifoDontBlock configures to return StatusOutOfMemory instead of blocking
	RWFifoNoBlock
	// ROFifoCapacity allows to query number of maximum elements in the buffer
	ROFifoCapacity
	// ROFifoReadFillLevel allows to query number of tensors in the read buffer
	ROFifoReadFillLevel
	// ROFifoWriteFillLevel allows to query number of tensors in a write buffer
	ROFifoWriteFillLevel
	// ROFifoGraphTensorDescriptor allows to query the tensor descriptor of the FIFO
	ROFifoGraphTensorDesc
	// ROFifoState allows to query FifoState
	ROFifoState
	// ROFifoName allows to query FIFO name
	ROFifoName
	// ROFifoElemDataSize allows to query element data size in bytes
	ROFifoElemDataSize
	// RWFifoHostTensorDesc is tensor descriptor, defaults to none strided channel minor
	RWFifoHostTensorDesc
)

func (FifoOption) Decode

func (fo FifoOption) Decode(data []byte, count int) (interface{}, error)

Decode decodes options data encoded in raw bytes and returns it in its native type. The returned data can be asserted into its native type. If the data contains more than one element you need to specify the number of expected elements via count. It returns error if the data fails to be decoded into the option native type.

func (FifoOption) String

func (fo FifoOption) String() string

String implements fmt.Stringer interface

func (FifoOption) Value

func (fo FifoOption) Value() int

Value returns option value as integer

type FifoOpts

type FifoOpts struct {
	// Type is FIFO type
	Type FifoType
	// DataType is FIFO data type
	DataType FifoDataType
	// NumElem is a max number of elements that the FIFO will be able to contain
	NumElem int
}

FifoOpts specifies FIFO configuration options

type FifoQueue

type FifoQueue struct {
	// In is an inbound queue
	In *Fifo
	// Out is an outbound queue
	Out *Fifo
}

FifoQueue is a FIFO queue used for NCS inference.

type FifoState

type FifoState int

FifoState represents FIFO state

const (
	// FifoCreated means FIFO has been created.
	FifoCreated FifoState = iota
	// FifoAllocated means FIFO has been allocated.
	FifoAllocated
)

func (FifoState) String

func (fs FifoState) String() string

String implements fmt.Stringer interface

type FifoType

type FifoType int

FifoType defines FIFO access types.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncFifoType_t.html

const (
	// FifoHostRO allows Read Only API access and Read-Write Graph access
	FifoHostRO FifoType = iota
	// FifoHostWO allows Write Only API acess and Read Only Graph access
	FifoHostWO
)

type Graph

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

Graph is NCSDK neural network graph

func NewGraph

func NewGraph(name string) (*Graph, error)

NewGraph creates new Graph with given name and returns it It returns error if it fails to create new graph

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphCreate.html

func (*Graph) Allocate

func (g *Graph) Allocate(d *Device, graphData []byte) error

Allocate allocates a graph on NCS device. This function sends graphData to NCS device. It does not allocate input or output FIFO queues. You have to either allocate them separately or use either AllocateWithFifosDefault() or AllocateWithFifosOpts() functions whcih conveniently create and allocate the FIFO queues. It returns error if it fails to allocate the graph on the device

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphAllocate.html

func (*Graph) AllocateWithFifosDefault

func (g *Graph) AllocateWithFifosDefault(d *Device, graphData []byte) (*FifoQueue, error)

AllocateWithFifosDefault allocates a graph and creates and allocates FIFO queues with default parameters for inference. Both FIFOs have FifoDataType set to FifoFP32. Inbound FIFO queue is initialized with FifoHostWO type and outbound FIFO queue with FifoHostRO type. It returns FifoQueue or error if it fails to allocate the graph.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphAllocateWithFifos.html

func (*Graph) AllocateWithFifosOpts

func (g *Graph) AllocateWithFifosOpts(d *Device, graphData []byte, inOpts *FifoOpts, outOpts *FifoOpts) (*FifoQueue, error)

AllocateWithFifosOpts allocates a graph and creates and allocates FIFO queues for inference. This function is similar to AllocateWithFifosDefault, but rather than initializing FIFOs with default values it accepts parameters that allow to specify FIFO queue parameters

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphAllocateWithFifosEx.html

func (*Graph) Destroy

func (g *Graph) Destroy() error

Destroy destroys NCS graph handle and frees associated resources. This function must be called for every graph that was initialized with NewGraph().

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphDestroy.html

func (*Graph) GetOption

func (g *Graph) GetOption(opt GraphOption) ([]byte, error)

GetOption queries the value of an option for a graph and returns it encoded in a byte slice It returns error if it failed to retrieve the option value

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphGetOption.html

func (*Graph) GetOptionWithByteSize

func (g *Graph) GetOptionWithByteSize(opt GraphOption, size uint) ([]byte, error)

GetOptionsWithSize queries NCS grapg options and returns it encoded in a byte slice of size elements. This function is similar to GetOption(), however as opposed to GetOption() which first queries the NCS device for the size of the requested options, it attempts to request the options data by specifying its size in raw bytes explicitly, hence it returns the queried options data faster. It returns error if it fails to retrieve the options or if the requested size of the options is invalid.

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphGetOption.html

func (*Graph) QueueInference

func (g *Graph) QueueInference(f *FifoQueue) error

QueueInference queues data for inference to be processed by a graph with specified input and output FIFOs If it fails to queue the data tensor it returns error

For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphQueueInference.html

func (*Graph) QueueInferenceWithFifoElem

func (g *Graph) QueueInferenceWithFifoElem(f *FifoQueue, data []byte, metaData interface{}) error

QueueInferenceWithFifoElem writes an element to a FIFO, usually an input tensor for inference, and queues an inference to be processed by a graph. This is a convenient way to write an input tensor and queue an inference in one call If it fails to queue the data tensor it returns error For more information: https://movidius.github.io/ncsdk/ncapi/ncapi2/c_api/ncGraphQueueInferenceWithFifoElem.html

type GraphOption

type GraphOption int

GraphOption defines graph options The options starting with RW are both gettable and settable The options starting with RO are only gettable

const (
	// ROGraphState is current state of the graph
	ROGraphState GraphOption = (1000 + iota)
	// ROGraphInferenceTime times taken per graph layer for the last inference in milliseconds
	ROGraphInferenceTime
	// ROGraphInputCount is number of inputs expected by the graph
	ROGraphInputCount
	// ROGraphOutputCount is he number of outputs expected by the graph.
	ROGraphOutputCount
	// ROGraphInputTensorDesc is an array of TensorDesc's, which describe the graph inputs in order
	ROGraphInputTensorDesc
	// ROGraphOutputTensorDesc is array of TensorDesc's, which describe the graph outputs in order
	ROGraphOutputTensorDesc
	// ROGraphDebugInfo provides more details when the result of a function call was StatusMyriadError
	ROGraphDebugInfo
	// ROGraphName is the name of the graph
	ROGraphName
	// ROGraphOptionClassLimit returns the highest option class supported
	ROGraphOptionClassLimit
	// ROGraphVersion is graph version
	ROGraphVersion
	// RWGraphExecutorsCount is not implemented yet
	RWGraphExecutorsCount
	// ROGraphInferenceTimeSize size of array for ROGraphInferenceTime option
	ROGraphInferenceTimeSize
)

func (GraphOption) Decode

func (g GraphOption) Decode(data []byte, count int) (interface{}, error)

Decode decodes options data encoded in raw bytes and returns it in its native type. The returned data then can be asserted into its native type. If the data contains more than one element you need to specify the number of expected elements via count. It returns error if the data fails to be decoded into the option native type.

func (GraphOption) String

func (g GraphOption) String() string

String implements fmt.Stringer interface for GraphOption

func (GraphOption) Value

func (g GraphOption) Value() int

Value returns option value as integer

type GraphState

type GraphState int

GraphState defines states of a network graph

const (
	// GraphCreated means the graph has been created, but it may not be initialized
	GraphCreated GraphState = iota
	// GraphAllocated means the graph has been initialized, and the graph has been allocated for a device
	GraphAllocated
	// GraphWaitingForInput means the graph is waiting for input.
	GraphWaitingForInput
	// GraphRunning means the graph is currently running an inference
	GraphRunning
)

func (GraphState) String

func (gs GraphState) String() string

String implements fmt.Stringer interface for GraphState

type Option

type Option interface {
	// Value returns Option value as its integer code
	Value() int
	// Decode decodes raw byte slice option data as returned from NCS
	Decode([]byte, int) (interface{}, error)
}

Option is NCS option

type Status

type Status int

Status is the NCSDK API status code as returned by most API calls. It usually reports the status of the Neural Compute Stick.

const (
	// StatusOK means the API function call worked as expected
	StatusOK Status = -iota
	// StatusBusy means device is busy, retry later.
	StatusBusy
	// StatusError means an unexpected error was encountered during the API function call.
	StatusError
	// StatusOutOfMemory means the host is out of memory.
	StatusOutOfMemory
	// StatusDeviceNotFound means no device has been found at the given index or name.
	StatusDeviceNotFound
	// StatusInvalidParameters means at least one of the given parameters is wrong.
	StatusInvalidParameters
	// StatusTimeout means there was a timeout in the communication with the device.
	StatusTimeout
	// StatusCmdNotFound means the file to boot the device was not found.
	StatusCmdNotFound
	// StatusNotAllocated means the graph or fifo has not been allocated..
	StatusNotAllocated
	// StatusUnauthorized means an unauthorized operation has been attempted.
	StatusUnauthorized
	// StatusUnsupportedGraphFile means the graph file version is not supported.
	StatusUnsupportedGraphFile
	// StatusUnsupportedConfigFile is reserved for future use.
	StatusUnsupportedConfigFile
	// StatusUnsupportedFeature means the operation used a feature unsupported by this firmware version.
	StatusUnsupportedFeature
	// StatusMyriadError when an error has been reported by device, use MVNC_DEBUG_INFO.
	StatusMyriadError
	// StatusInvalidDataLength means an invalid data length has been passed when getting or setting an option.
	StatusInvalidDataLength
	// StatusInvalidHandle means an invalid handle has been passed to a function.
	StatusInvalidHandle
)

func (Status) String

func (s Status) String() string

String method implements fmt.Stringer interface

type Tensor

type Tensor struct {
	// Data contains raw tensor data
	Data []byte
	// MetaData contains tensor metadata
	MetaData interface{}
}

Tensor is graph tensor as returned from NCS

type TensorDesc

type TensorDesc struct {
	// BatchSize contains number of elements.
	BatchSize uint
	// Channels contains number of channels (when dealing with digital images).
	Channels uint
	// Width is data width (i.e. number of matrix columns).
	Width uint
	// Height is data height (i.e. number of matrix rows).
	Height uint
	// Size is the total data size in the tensor.
	Size uint
	// CStride is channel stride (Stride in the channels' dimension).
	CStride uint
	// WStride is width stride (Stride in the horizontal dimension).
	WStride uint
	// HStride is height stride (Stride in the vertical dimension).
	HStride uint
	// DataType is data type of the tensor.
	DataType FifoDataType
}

TensorDesc describes NCS graph inputs and outputs

Directories

Path Synopsis
examples

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL