TensorFlow Lite में हस्ताक्षर

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

TensorFlow Lite, TensorFlow मॉडल के इनपुट/आउटपुट विनिर्देशों को TensorFlow Lite मॉडल में बदलने का समर्थन करता है। इनपुट/आउटपुट विनिर्देशों को "हस्ताक्षर" कहा जाता है। सहेजे गए मॉडल का निर्माण या ठोस कार्य बनाते समय हस्ताक्षर निर्दिष्ट किए जा सकते हैं।

TensorFlow Lite में हस्ताक्षर निम्नलिखित विशेषताएं प्रदान करते हैं:

  • वे TensorFlow मॉडल के हस्ताक्षरों का सम्मान करके परिवर्तित TensorFlow Lite मॉडल के इनपुट और आउटपुट निर्दिष्ट करते हैं।
  • एकल TensorFlow Lite मॉडल को एकाधिक प्रवेश बिंदुओं का समर्थन करने की अनुमति दें।

हस्ताक्षर तीन टुकड़ों से बना है:

  • इनपुट: हस्ताक्षर में इनपुट नाम से इनपुट टेंसर में इनपुट के लिए मानचित्र।
  • आउटपुट: सिग्नेचर में आउटपुट नाम से आउटपुट टेंसर तक आउटपुट मैपिंग के लिए मैप।
  • हस्ताक्षर कुंजी: वह नाम जो ग्राफ़ के प्रवेश बिंदु की पहचान करता है।

सेट अप

import tensorflow as tf

उदाहरण मॉडल

मान लें कि हमारे पास TensorFlow मॉडल के रूप में दो कार्य हैं, उदाहरण के लिए, एन्कोडिंग और डिकोडिंग:

class Model(tf.Module):

  @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.float32)])
  def encode(self, x):
    result = tf.strings.as_string(x)
    return {
         "encoded_result": result
    }

  @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.string)])
  def decode(self, x):
    result = tf.strings.to_number(x)
    return {
         "decoded_result": result
    }

हस्ताक्षर के अनुसार, उपरोक्त TensorFlow मॉडल को संक्षेप में प्रस्तुत किया जा सकता है:

  • हस्ताक्षर

    • कुंजी: सांकेतिक शब्दों में बदलना
    • इनपुट: {"x"}
    • आउटपुट: {"encoded_result"}
  • हस्ताक्षर

    • कुंजी: डिकोड
    • इनपुट: {"x"}
    • आउटपुट: {"डिकोडेड_रिज़ल्ट"}

एक मॉडल को सिग्नेचर के साथ कन्वर्ट करें

TensorFlow Lite कन्वर्टर API उपरोक्त हस्ताक्षर जानकारी को परिवर्तित TensorFlow Lite मॉडल में लाएगा।

यह रूपांतरण कार्यक्षमता TensorFlow संस्करण 2.7.0 से शुरू होने वाले सभी कनवर्टर API पर उपलब्ध है। उदाहरण उपयोग देखें।

सहेजे गए मॉडल से

model = Model()

# Save the model
SAVED_MODEL_PATH = 'content/saved_models/coding'

tf.saved_model.save(
    model, SAVED_MODEL_PATH,
    signatures={
      'encode': model.encode.get_concrete_function(),
      'decode': model.decode.get_concrete_function()
    })

# Convert the saved model using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_PATH)
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS,  # enable TensorFlow Lite ops.
    tf.lite.OpsSet.SELECT_TF_OPS  # enable TensorFlow ops.
]
tflite_model = converter.convert()

# Print the signatures from the converted model
interpreter = tf.lite.Interpreter(model_content=tflite_model)
signatures = interpreter.get_signature_list()
print(signatures)
2021-11-15 12:17:48.388332: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: content/saved_models/coding/assets
2021-11-15 12:17:48.727484: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-11-15 12:17:48.727522: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded
2021-11-15 12:17:48.727529: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:372] Ignored change_concat_input_ranges.
2021-11-15 12:17:48.767576: W tensorflow/compiler/mlir/lite/flatbuffer_export.cc:1891] TFLite interpreter needs to link Flex delegate in order to run the model since it contains the following Select TFop(s):
Flex ops: FlexAsString, FlexStringToNumber
Details:
    tf.AsString(tensor<?xf32>) -> (tensor<?x!tf_type.string>) : {device = "", fill = "", precision = -1 : i64, scientific = false, shortest = false, width = -1 : i64}
    tf.StringToNumber(tensor<?x!tf_type.string>) -> (tensor<?xf32>) : {device = "", out_type = f32}
See instructions: https://www.tensorflow.org/lite/guide/ops_select
{'decode': {'inputs': ['x'], 'outputs': ['decoded_result']}, 'encode': {'inputs': ['x'], 'outputs': ['encoded_result']} }
INFO: Created TensorFlow Lite delegate for select TF ops.
INFO: TfLiteFlexDelegate delegate: 1 nodes delegated out of 1 nodes with 1 partitions.

केरस मॉडल . से

# Generate a Keras model.
keras_model = tf.keras.Sequential(
    [
        tf.keras.layers.Dense(2, input_dim=4, activation='relu', name='x'),
        tf.keras.layers.Dense(1, activation='relu', name='output'),
    ]
)

# Convert the keras model using TFLiteConverter.
# Keras model converter API uses the default signature automatically.
converter = tf.lite.TFLiteConverter.from_keras_model(keras_model)
tflite_model = converter.convert()

# Print the signatures from the converted model
interpreter = tf.lite.Interpreter(model_content=tflite_model)

signatures = interpreter.get_signature_list()
print(signatures)
INFO:tensorflow:Assets written to: /tmp/tmplhr7j714/assets
INFO:tensorflow:Assets written to: /tmp/tmplhr7j714/assets
2021-11-15 12:17:49.368226: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-11-15 12:17:49.368264: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded
{'serving_default': {'inputs': ['x_input'], 'outputs': ['output']} }

ठोस कार्यों से

model = Model()

# Convert the concrete functions using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_concrete_functions(
    [model.encode.get_concrete_function(),
     model.decode.get_concrete_function()], model)
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS,  # enable TensorFlow Lite ops.
    tf.lite.OpsSet.SELECT_TF_OPS  # enable TensorFlow ops.
]
tflite_model = converter.convert()

# Print the signatures from the converted model
interpreter = tf.lite.Interpreter(model_content=tflite_model)
signatures = interpreter.get_signature_list()
print(signatures)
INFO:tensorflow:Assets written to: /tmp/tmpc14_l70o/assets
INFO:tensorflow:Assets written to: /tmp/tmpc14_l70o/assets
2021-11-15 12:17:49.538814: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-11-15 12:17:49.538850: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded
{'decode': {'inputs': ['x'], 'outputs': ['decoded_result']}, 'encode': {'inputs': ['x'], 'outputs': ['encoded_result']} }
2021-11-15 12:17:49.572773: W tensorflow/compiler/mlir/lite/flatbuffer_export.cc:1891] TFLite interpreter needs to link Flex delegate in order to run the model since it contains the following Select TFop(s):
Flex ops: FlexAsString, FlexStringToNumber
Details:
    tf.AsString(tensor<?xf32>) -> (tensor<?x!tf_type.string>) : {device = "", fill = "", precision = -1 : i64, scientific = false, shortest = false, width = -1 : i64}
    tf.StringToNumber(tensor<?x!tf_type.string>) -> (tensor<?xf32>) : {device = "", out_type = f32}
See instructions: https://www.tensorflow.org/lite/guide/ops_select

रन सिग्नेचर

TensorFlow अनुमान APIs हस्ताक्षर-आधारित निष्पादन का समर्थन करते हैं:

  • हस्ताक्षर द्वारा निर्दिष्ट इनपुट और आउटपुट के नाम के माध्यम से इनपुट/आउटपुट टेंसर तक पहुंचना।
  • ग्राफ़ के प्रत्येक प्रवेश बिंदु को अलग से चलाना, जिसे हस्ताक्षर कुंजी द्वारा पहचाना जाता है।
  • सेव्डमॉडल की इनिशियलाइज़ेशन प्रक्रिया के लिए समर्थन।

Java, C++ और Python भाषा बाइंडिंग वर्तमान में उपलब्ध हैं। नीचे दिए गए अनुभागों का उदाहरण देखें।

जावा

try (Interpreter interpreter = new Interpreter(file_of_tensorflowlite_model)) {
  // Run encoding signature.
  Map<String, Object> inputs = new HashMap<>();
  inputs.put("x", input);
  Map<String, Object> outputs = new HashMap<>();
  outputs.put("encoded_result", encoded_result);
  interpreter.runSignature(inputs, outputs, "encode");

  // Run decoding signature.
  Map<String, Object> inputs = new HashMap<>();
  inputs.put("x", encoded_result);
  Map<String, Object> outputs = new HashMap<>();
  outputs.put("decoded_result", decoded_result);
  interpreter.runSignature(inputs, outputs, "decode");
}

सी++

SignatureRunner* encode_runner =
    interpreter->GetSignatureRunner("encode");
encode_runner->ResizeInputTensor("x", {100});
encode_runner->AllocateTensors();

TfLiteTensor* input_tensor = encode_runner->input_tensor("x");
float* input = input_tensor->data.f;
// Fill `input`.

encode_runner->Invoke();

const TfLiteTensor* output_tensor = encode_runner->output_tensor(
    "encoded_result");
float* output = output_tensor->data.f;
// Access `output`.

अजगर

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(model_content=tflite_model)

# Print the signatures from the converted model
signatures = interpreter.get_signature_list()
print('Signature:', signatures)

# encode and decode are callable with input as arguments.
encode = interpreter.get_signature_runner('encode')
decode = interpreter.get_signature_runner('decode')

# 'encoded' and 'decoded' are dictionaries with all outputs from the inference.
input = tf.constant([1, 2, 3], dtype=tf.float32)
print('Input:', input)
encoded = encode(x=input)
print('Encoded result:', encoded)
decoded = decode(x=encoded['encoded_result'])
print('Decoded result:', decoded)
Signature: {'decode': {'inputs': ['x'], 'outputs': ['decoded_result']}, 'encode': {'inputs': ['x'], 'outputs': ['encoded_result']} }
Input: tf.Tensor([1. 2. 3.], shape=(3,), dtype=float32)
Encoded result: {'encoded_result': array([b'1.000000', b'2.000000', b'3.000000'], dtype=object)}
Decoded result: {'decoded_result': array([1., 2., 3.], dtype=float32)}

ज्ञात सीमाएं

  • चूंकि टीएफलाइट दुभाषिया थ्रेड सुरक्षा की गारंटी नहीं देता है, उसी दुभाषिया के हस्ताक्षर धावकों को समवर्ती रूप से निष्पादित नहीं किया जाएगा।
  • सी/आईओएस/स्विफ्ट के लिए समर्थन अभी उपलब्ध नहीं है।

अपडेट

  • संस्करण 2.7
    • एकाधिक हस्ताक्षर सुविधा लागू की गई है।
    • संस्करण दो से सभी कनवर्टर एपीआई हस्ताक्षर-सक्षम TensorFlow लाइट मॉडल उत्पन्न करते हैं।
  • संस्करण 2.5
    • हस्ताक्षर सुविधा के माध्यम से उपलब्ध है from_saved_model कनवर्टर एपीआई।