Merge branch 'develop' into main

Author: nbortolotti

interpreter.go

@@ -0,0 +1,82 @@
+package tflitego
+
+/*
+#include <stdio.h>
+#include <tensorflow/lite/c/c_api.h>
+#cgo LDFLAGS: -ltensorflowlite_c
+#cgo linux LDFLAGS: -lm -ldl -lrt
+*/
+import "C"
+import (
+	"fmt"
+)
+
+// TfLiteStatus represents TFLiteStatus
+type TfLiteStatus int
+
+// options to represent TFLiteStatus
+const (
+	TfLiteOk TfLiteStatus = iota
+	TfLiteError
+	TfLiteDelegateError
+	TfLiteApplicationError
+)
+
+// TfLiteInterpreter represents a  TensorFlow Lite Interpreter .
+type TfLiteInterpreter struct {
+	interpreter *C.TfLiteInterpreter
+}
+
+// NewInterpreter create new TfLiteInterpreter.
+func NewInterpreter(tfmodel *TFLiteModel, opts *InterpreterOptions) (*TfLiteInterpreter, error) {
+	var o *C.TfLiteInterpreterOptions
+	if opts != nil {
+		o = opts.options
+	}
+	i := C.TfLiteInterpreterCreate(tfmodel.model, o)
+	if i == nil {
+		return nil, fmt.Errorf("unable to create new TFLiteInterpreter")
+	}
+	return &TfLiteInterpreter{interpreter: i}, nil
+}
+
+// Delete represents the delete instance of Interpreter.
+func (TfLiteInterpreter *TfLiteInterpreter) Delete() {
+	if TfLiteInterpreter != nil {
+		C.TfLiteInterpreterDelete(TfLiteInterpreter.interpreter)
+	}
+
+}
+
+// GetInputTensor return  tfLiteTensor using index.
+func (TfLiteInterpreter *TfLiteInterpreter) GetInputTensor(index int) (*TfLiteTensor, error) {
+	t := C.TfLiteInterpreterGetInputTensor(TfLiteInterpreter.interpreter, C.int32_t(index))
+	if t == nil {
+		return nil, fmt.Errorf("unable to retrieve Input Tensor")
+	}
+	return &TfLiteTensor{tensor: t}, nil
+}
+
+// AllocateTensors allocate tensors for the interpreter.
+func (TfLiteInterpreter *TfLiteInterpreter) AllocateTensors() TfLiteStatus {
+	if TfLiteInterpreter != nil {
+		s := C.TfLiteInterpreterAllocateTensors(TfLiteInterpreter.interpreter)
+		return TfLiteStatus(s)
+	}
+	return TfLiteError
+}
+
+// Invoke invoke interpreter
+func (TfLiteInterpreter *TfLiteInterpreter) Invoke() TfLiteStatus {
+	s := C.TfLiteInterpreterInvoke(TfLiteInterpreter.interpreter)
+	return TfLiteStatus(s)
+}
+
+// GetOutputTensor return output TfLiteTensor specified by index.
+func (TfLiteInterpreter *TfLiteInterpreter) GetOutputTensor(index int) *TfLiteTensor {
+	t := C.TfLiteInterpreterGetOutputTensor(TfLiteInterpreter.interpreter, C.int32_t(index))
+	if t == nil {
+		return nil
+	}
+	return &TfLiteTensor{tensor: t}
+}

model.go

@@ -0,0 +1,33 @@
+package tflitego
+
+/*
+#include <stdio.h>
+#include <tensorflow/lite/c/c_api.h>
+#cgo LDFLAGS: -ltensorflowlite_c
+#cgo linux LDFLAGS: -lm -ldl -lrt
+*/
+import "C"
+import (
+	"fmt"
+)
+
+// TFLiteModel represents a TensorFlow Lite Model.
+type TFLiteModel struct {
+	model *C.TfLiteModel
+}
+
+// NewTFLiteModelFromFile creates a new TensorFlow Lite Model from File.
+func NewTFLiteModelFromFile(modelPath string) (*TFLiteModel, error) {
+	m := C.TfLiteModelCreateFromFile(C.CString(modelPath))
+	if m == nil {
+		return nil, fmt.Errorf("unable to create the model")
+	}
+	return &TFLiteModel{model: m}, nil
+}
+
+// Delete delete instance of TF Lite model.
+func (TFLiteModel *TFLiteModel) Delete() {
+	if TFLiteModel != nil {
+		C.TfLiteModelDelete(TFLiteModel.model)
+	}
+}

options.go

@@ -0,0 +1,38 @@
+package tflitego
+
+/*
+#include <stdio.h>
+#include <tensorflow/lite/c/c_api.h>
+#cgo LDFLAGS: -ltensorflowlite_c
+#cgo linux LDFLAGS: -lm -ldl -lrt
+*/
+import "C"
+import (
+	"fmt"
+)
+
+// InterpreterOptions represents a TensorFlow Lite InterpreterOptions.
+type InterpreterOptions struct {
+	options *C.TfLiteInterpreterOptions
+}
+
+// NewInterpreterOptions creates new InterpreterOptions.
+func NewInterpreterOptions() (*InterpreterOptions, error) {
+	o := C.TfLiteInterpreterOptionsCreate()
+	if o == nil {
+		return nil, fmt.Errorf("unable to create an InterpreterOptions")
+	}
+	return &InterpreterOptions{options: o}, nil
+}
+
+// Delete delete instance of InterpreterOptions.
+func (InterpreterOptions *InterpreterOptions) Delete() {
+	if InterpreterOptions != nil {
+		C.TfLiteInterpreterOptionsDelete(InterpreterOptions.options)
+	}
+}
+
+// SetNumThread set number of threads.
+func (InterpreterOptions *InterpreterOptions) SetNumThread(numThreads int) {
+	C.TfLiteInterpreterOptionsSetNumThreads(InterpreterOptions.options, C.int32_t(numThreads))
+}

tensor.go

@@ -0,0 +1,96 @@
+package tflitego
+
+/*
+#include <stdio.h>
+#include <tensorflow/lite/c/c_api.h>
+#cgo LDFLAGS: -ltensorflowlite_c
+#cgo linux LDFLAGS: -lm -ldl -lrt
+*/
+import "C"
+import (
+	"fmt"
+)
+
+// TensorType is types of the tensor.
+type TensorType int
+
+// Tensors type
+const (
+	TfLiteNoType TensorType = iota
+	TfLiteFloat32
+	TfLiteInt32
+	TfLiteUInt8
+	TfLiteInt64
+	TfLiteString
+	TfLiteBool
+	TfLiteInt16
+	TfLiteComplex64
+	TfLiteInt8
+)
+
+// TfLiteTensor represents TensorFlow Lite Tensor.
+type TfLiteTensor struct {
+	tensor *C.TfLiteTensor
+}
+
+// Type return TensorType.
+func (TfLiteTensor *TfLiteTensor) Type() TensorType {
+	return TensorType(C.TfLiteTensorType(TfLiteTensor.tensor))
+}
+
+// NumDims return number of dimensions.
+func (TfLiteTensor *TfLiteTensor) NumDims() int {
+	return int(C.TfLiteTensorNumDims(TfLiteTensor.tensor))
+}
+
+// Dim return dimension of the element specified by index.
+func (TfLiteTensor *TfLiteTensor) Dim(index int) int {
+	return int(C.TfLiteTensorDim(TfLiteTensor.tensor, C.int32_t(index)))
+}
+
+// Shape return shape of the tensor.
+func (TfLiteTensor *TfLiteTensor) Shape() []int {
+	shape := make([]int, TfLiteTensor.NumDims())
+	for i := 0; i < TfLiteTensor.NumDims(); i++ {
+		shape[i] = TfLiteTensor.Dim(i)
+	}
+	return shape
+}
+
+// ByteSize return byte size of the tensor.
+func (TfLiteTensor *TfLiteTensor) ByteSize() uint {
+	return uint(C.TfLiteTensorByteSize(TfLiteTensor.tensor))
+}
+
+// Name return name of the tensor.
+func (TfLiteTensor *TfLiteTensor) Name() string {
+	return C.GoString(C.TfLiteTensorName(TfLiteTensor.tensor))
+}
+
+// SetFloat32 sets float32s.
+func (TfLiteTensor *TfLiteTensor) SetFloat32(v []float32) error {
+	if TfLiteTensor.Type() != TfLiteFloat32 {
+		return fmt.Errorf("type error")
+	}
+	ptr := C.TfLiteTensorData(TfLiteTensor.tensor)
+	if ptr == nil {
+		return fmt.Errorf("bad tensor")
+	}
+	n := TfLiteTensor.ByteSize() / 4
+	to := (*((*[1<<29 - 1]float32)(ptr)))[:n]
+	copy(to, v)
+	return nil
+}
+
+// OperateFloat32 returns float32.
+func (TfLiteTensor *TfLiteTensor) OperateFloat32() []float32 {
+	if TfLiteTensor.Type() != TfLiteFloat32 {
+		return nil
+	}
+	ptr := C.TfLiteTensorData(TfLiteTensor.tensor)
+	if ptr == nil {
+		return nil
+	}
+	n := TfLiteTensor.ByteSize() / 4
+	return (*((*[1<<29 - 1]float32)(ptr)))[:n]
+}

tflite.go

@@ -0,0 +1,21 @@
+package tflitego
+
+/*
+#include <stdio.h>
+#include <tensorflow/lite/c/c_api.h>
+#cgo LDFLAGS: -ltensorflowlite_c
+#cgo linux LDFLAGS: -lm -ldl -lrt
+*/
+import "C"
+import (
+	"fmt"
+)
+
+// TFVersion return TensorFlow Lite version
+func TFVersion() (string, error) {
+	x := C.TfLiteVersion()
+	if x == nil {
+		return "", fmt.Errorf("unable to retrieve TensorFlow Lite version")
+	}
+	return C.GoString(x), nil
+}

utils.go

@@ -1,4 +1,4 @@
-package gotflite
+package tflitego
 
 import "testing"