converter = tf.lite.TFLiteConverter.from_concrete_functions([atan.get_concrete_function()], atan) converter.allow_custom_ops = True tflite_model = converter.convert()At this point, if you run it with the default interpreter using commands such as follows: ```python interpreter = tf.lite.Interpreter(model_content=tflite_model) interpreter.allocate_tensors() ``` You will still get the error: ```none Encountered unresolved custom op: Atan. ``` ### Create and register the operator. ```c++ #include "tensorflow/lite/c/c_api.h" #include "tensorflow/lite/c/c_api_opaque.h" ``` TensorFlow Lite custom operators are defined using a simple pure-C API that consists of an opaque type (`TfLiteOperator`) and related functions. `TfLiteOperator` is an opaque type: ```c++ typedef struct TfLiteOperator TfLiteOperator; ``` `TfLiteOperator` stores the operator's identity and implementation. (Note that the operator is distinct from its operands, which are stored in the TF Lite graph nodes for nodes that call the operator.) Instances of this type are constructed with calls to `TfLiteOperatorCreate` and can be destroyed by calling `TfLiteOperatorDelete`. The operator's identity is set via the parameters to the constructor function `TfLiteOperatorCreate`: ```c++ TfLiteOperator* TfLiteOperatorCreate( TfLiteBuiltinOperator builtin_code, // Normally `TfLiteBuiltinCustom`. const char* custom_name, // The name of the custom op. int version // Normally `1` for the first version of a custom op. ); ``` The operator implementation can define "methods" with the following signatures. All of these methods are optional, but for an operator to be successfully evaluated, the operator implementation needs to define and set (using the setter functions) at least the `Prepare` and `Invoke` methods. ```c++ // Initializes the op from serialized data. void* Init(TfLiteOpaqueContext* context, const char* buffer, size_t length); // Deallocates the op. // The pointer `buffer` is the data previously returned by an Init invocation. void Free(TfLiteOpaqueContext* context, void* buffer); // Called when the inputs that this node depends on have been resized. TfLiteStatus Prepare(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node); // Called when the node is executed. (Should read node inputs and write to // node outputs). TfLiteStatus Invoke(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node); // Retrieves the async kernel. TfLiteAsyncKernel AsyncKernel(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node); ``` The function *names* (or namespace prefixes, for C++) in your op implementation don't have to match the function names in the above code snippet, since the TF Lite custom ops API will only use their addresses. Indeed we recommend that you declare them in an anonymous namespace or as static functions. But it is a good idea to include your operator name as a namespace or prefix on these function names:
namespace my_namespace::my_custom_op {
void* Init(TfLiteOpaqueContext* context,
const char* buffer, size_t length) { ... }
// ... plus definitions of Free, Prepare, and Invoke ...
}
void* MyCustomOpInit(TfLiteOpaqueContext* context,
const char* buffer, size_t length) { ... }
// ... plus definitions of MyCustomOpFree, MyCustomOpPrepare, and
// MyCustomOpInvoke.
namespace my_namespace::my_custom_op {
namespace {
void* Init(TfLiteOpaqueContext* context,
const char* buffer, size_t length) { ... }
void Free(TfLiteOpaqueContext* context, void* buffer) { ... }
TfLiteStatus Prepare(TfLiteOpaqueContext* context,
TfLiteOpaqueNode* node) { ... }
TfLiteStatus Invoke(TfLiteOpaqueContext* context,
TfLiteOpaqueNode* node) {... }
};
const TfLiteOperator* MyCustomOpRegistrationExternal() {
// Singleton instance, intentionally never destroyed.
static const TfLiteOperator* my_custom_op = ()[] {
TfLiteOperator* r =
TfLiteOperatorCreate(
kTfLiteBuiltinCustom, "MyCustomOp", /*version=*/ 1);
TfLiteOperatorSetInit(r, Init);
TfLiteOperatorSetFree(r, Free);
TfLiteOperatorSetPrepare(r, Prepare);
TfLiteOperatorSetInvoke(r, Eval);
return r;
};
return my_custom_op;
}
} // namespace my_namespace
static void* MyCustomOpInit(TfLiteOpaqueContext* context, const char* buffer,
size_t length) { ... }
static void MyCustomOpFree(TfLiteOpaqueContext* context, void* buffer) { ... }
static TfLiteStatus MyCustomOpPrepare(TfLiteOpaqueContext* context,
TfLiteOpaqueNode* node) { ... }
static TfLiteStatus MyCustomOpInvoke(TfLiteOpaqueContext* context,
TfLiteOpaqueNode* node) {... }
static TfLiteOperator* MyCustomOpCreate() {
const TfLiteOperator* r =
TfLiteOperatorCreate(
kTfLiteBuiltinCustom, "MyCustomOp", /*version=*/ 1);
TfLiteOperatorSetInit(r, MyCustomOpInit);
TfLiteOperatorSetFree(r, MyCustomOpFree);
TfLiteOperatorSetPrepare(r, MyCustomOpPrepare);
TfLiteOperatorSetInvoke(r, MyCustomOpEval);
return r;
}
const TfLiteOperator* MyCustomOpRegistrationExternal() {
// Singleton instance, intentionally never destroyed.
static const TfLiteOperator* my_custom_op = MyCustomOpCreate();
return my_custom_op;
}
namespace atan_op {
namespace {
TfLiteStatus AtanPrepare(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node) {
TF_LITE_OPAQUE_ENSURE_EQ(context, TfLiteOpaqueNodeNumInputs(node), 1);
TF_LITE_OPAQUE_ENSURE_EQ(context, TfLiteOpaqueNodeNumOutputs(node), 1);
const TfLiteOpaqueTensor* input = TfLiteOpaqueNodeGetInput(context, node, 0);
TfLiteOpaqueTensor* output = TfLiteOpaqueNodeGetOutput(context, node, 0);
int num_dims = TfLiteOpaqueTensorNumDimensions(input);
TfLiteIntArray* output_size = TfLiteIntArrayCreate(num_dims);
for (int i=0; i < num_dims; ++i) {
output_size->data[i] = input->dims->data[i];
}
return TfLiteOpaqueContextResizeTensor(context, output, output_size);
}
TfLiteStatus AtanEval(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node) {
const TfLiteOpaqueTensor* input = TfLiteOpaqueNodeGetInput(context, node, 0);
TfLiteOpaqueTensor* output = TfLiteOpaqueNodeGetOutput(context, node, 0);
float* input_data = static_cast(TfLiteOpaqueTensorData(input));
float* output_data = static_cast(TfLiteOpaqueTensorData(output));
size_t count = 1;
int num_dims = TfLiteOpaqueTensorNumDimensions(input);
for (int i = 0; i < num_dims; ++i) {
count *= input->dims->data[i];
}
for (size_t i = 0; i < count; ++i) {
output_data[i] = atan(input_data[i]);
}
return kTfLiteOk;
}
} // anonymous namespace
const TfLiteOperator* AtanOpRegistrationExternal() {
// Singleton instance, intentionally never destroyed.
static const TfLiteOperator* atan_op = ()[] {
auto* r = TfLiteOperatorCreate(
kTfLiteBuiltinCustom, "ATAN", /*version=*/ 1);
TfLiteOperatorSetPrepare(r, Prepare);
TfLiteOperatorSetInvoke(r, Eval);
return r;
};
return atan_op;
}
} // namespace atan_op
static TfLiteStatus AtanPrepare(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node) {
TF_LITE_OPAQUE_ENSURE_EQ(context, TfLiteOpaqueNodeNumInputs(node), 1);
TF_LITE_OPAQUE_ENSURE_EQ(context, TfLiteOpaqueNodeNumOutputs(node), 1);
const TfLiteOpaqueTensor* input = TfLiteOpaqueNodeGetInput(context, node, 0);
TfLiteOpaqueTensor* output = TfLiteOpaqueNodeGetOutput(context, node, 0);
int num_dims = TfLiteOpaqueTensorNumDimensions(input);
TfLiteIntArray* output_size = TfLiteIntArrayCreate(num_dims);
for (int i = 0; i < num_dims; ++i) {
output_size->data[i] = input->dims->data[i];
}
return TfLiteOpaqueContextResizeTensor(context, output, output_size);
}
static TfLiteStatus AtanEval(TfLiteOpaqueContext* context, TfLiteOpaqueNode* node) {
const TfLiteOpaqueTensor* input = TfLiteOpaqueNodeGetInput(context, node, 0);
TfLiteOpaqueTensor* output = TfLiteOpaqueNodeGetOutput(context, node, 0);
float* input_data = static_cast(TfLiteOpaqueTensorData(input));
float* output_data = static_cast(TfLiteOpaqueTensorData(output));
size_t count = 1;
int num_dims = TfLiteOpaqueTensorNumDimensions(input);
for (int i = 0; i < num_dims; ++i) {
count *= input->dims->data[i];
}
for (size_t i = 0; i < count; ++i) {
output_data[i] = atan(input_data[i]);
}
return kTfLiteOk;
}
static const TfLiteOperator* AtanOpCreate() {
TfLiteOperator* r = TfLiteOperatorCreate(
kTfLiteBuiltinCustom, "ATAN", /*version=*/ 1);
TfLiteOperatorSetPrepare(r, Prepare);
TfLiteOperatorSetInvoke(r, Eval);
return r;
}
const TfLiteOperator* AtanOpRegistrationExternal() {
// Singleton instance, intentionally never destroyed.
static const TfLiteOperator* atan_op = AtanOpCreate();
return atan_op;
}