ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

การอนุมาน TensorFlow Lite

อนุมานระยะหมายถึงกระบวนการของการดำเนินการรูปแบบ TensorFlow Lite บนอุปกรณ์เพื่อการคาดการณ์ให้อยู่บนพื้นฐานของการป้อนข้อมูล ที่จะดำเนินการอนุมานที่มีรูปแบบ TensorFlow Lite คุณต้องเรียกใช้งานผ่านล่าม ล่าม TensorFlow Lite ได้รับการออกแบบมาให้มีความบางและรวดเร็ว ล่ามใช้การเรียงลำดับกราฟแบบคงที่และตัวจัดสรรหน่วยความจำแบบกำหนดเอง (ไดนามิกน้อยกว่า) เพื่อให้แน่ใจว่ามีการโหลด การเริ่มต้น และเวลาแฝงในการดำเนินการน้อยที่สุด

หน้านี้อธิบายถึงวิธีการเข้าถึงล่าม TensorFlow Lite และดำเนินการอนุมานโดยใช้ C ++, Java และงูหลามรวมทั้งเชื่อมโยงไปยังแหล่งข้อมูลอื่น ๆ สำหรับแต่ละ แพลตฟอร์มได้รับการสนับสนุน

แนวคิดที่สำคัญ

การอนุมาน TensorFlow Lite มักทำตามขั้นตอนต่อไปนี้:

  1. กำลังโหลดโมเดล

    คุณต้องโหลด .tflite รุ่นในหน่วยความจำที่มีกราฟการดำเนินการรูปแบบของ

  2. การแปลงข้อมูล

    ข้อมูลอินพุตดิบสำหรับโมเดลโดยทั่วไปไม่ตรงกับรูปแบบข้อมูลอินพุตที่โมเดลคาดหวัง ตัวอย่างเช่น คุณอาจต้องปรับขนาดรูปภาพหรือเปลี่ยนรูปแบบรูปภาพเพื่อให้เข้ากันได้กับโมเดล

  3. การอนุมานการวิ่ง

    ขั้นตอนนี้เกี่ยวข้องกับการใช้ TensorFlow Lite API เพื่อดำเนินการกับโมเดล มันเกี่ยวข้องกับสองสามขั้นตอน เช่น การสร้างล่าม และการจัดสรรเทนเซอร์ ตามที่อธิบายไว้ในส่วนต่อไปนี้

  4. ล่ามเอาท์พุท

    เมื่อคุณได้รับผลลัพธ์จากการอนุมานแบบจำลอง คุณต้องตีความเทนเซอร์อย่างมีความหมายซึ่งเป็นประโยชน์ในแอปพลิเคชันของคุณ

    ตัวอย่างเช่น โมเดลอาจส่งคืนเฉพาะรายการความน่าจะเป็น การทำแผนที่ความน่าจะเป็นกับหมวดหมู่ที่เกี่ยวข้องและนำเสนอต่อผู้ใช้ปลายทางของคุณนั้นขึ้นอยู่กับคุณ

แพลตฟอร์มที่รองรับ

TensorFlow APIs อนุมานจะมีให้สำหรับส่วนใหญ่ที่พบโทรศัพท์มือถือ / ฝังตัวแพลตฟอร์มเช่น Android , iOS และ ลินุกซ์ ในการเขียนโปรแกรมภาษาหลาย

ในกรณีส่วนใหญ่ การออกแบบ API สะท้อนให้เห็นความต้องการประสิทธิภาพมากกว่าการใช้งานง่าย TensorFlow Lite ได้รับการออกแบบมาเพื่อการอนุมานที่รวดเร็วบนอุปกรณ์ขนาดเล็ก ดังนั้นจึงไม่น่าแปลกใจที่ API จะพยายามหลีกเลี่ยงสำเนาที่ไม่จำเป็นโดยเสียความสะดวก ในทำนองเดียวกัน ความสอดคล้องกับ TensorFlow API ไม่ใช่เป้าหมายที่ชัดเจน และคาดว่าจะมีความแตกต่างกันระหว่างภาษา

ในไลบรารีทั้งหมด TensorFlow Lite API ช่วยให้คุณสามารถโหลดโมเดล ฟีดอินพุต และดึงเอาต์พุตการอนุมานได้

แพลตฟอร์ม Android

บน Android การอนุมาน TensorFlow Lite สามารถทำได้โดยใช้ Java หรือ C++ API Java API ให้ความสะดวกและสามารถใช้ได้โดยตรงภายในคลาสกิจกรรม Android ของคุณ C++ API มีความยืดหยุ่นและความเร็วมากกว่า แต่อาจต้องเขียน JNI wrappers เพื่อย้ายข้อมูลระหว่างเลเยอร์ Java และ C++

ดูด้านล่างสำหรับรายละเอียดเกี่ยวกับการใช้ ภาษา C ++ และ Java หรือตาม QuickStart Android สำหรับการกวดวิชาและเป็นตัวอย่างรหัส

เครื่องสร้างโค้ด wrapper ของ Android TensorFlow Lite

สำหรับรูปแบบ TensorFlow Lite เพิ่มขึ้นด้วย เมตาดาต้าที่ นักพัฒนาสามารถใช้เครื่องกำเนิดไฟฟ้า TensorFlow Lite Android: รหัสเสื้อคลุมเพื่อสร้างแพลตฟอร์มรหัสเฉพาะเสื้อคลุม รหัสห่อหุ้มเอาความจำเป็นในการติดต่อโดยตรงกับ ByteBuffer บน Android แต่นักพัฒนาสามารถโต้ตอบกับรูปแบบ TensorFlow Lite กับวัตถุพิมพ์เช่น Bitmap และ Rect สำหรับข้อมูลเพิ่มเติมโปรดดูที่ TensorFlow Lite Android: กำเนิดรหัสเสื้อคลุม

แพลตฟอร์ม iOS

บน iOS TensorFlow Lite สามารถใช้ได้กับห้องสมุดพื้นเมือง iOS เขียนใน สวิฟท์ และ วัตถุประสงค์ -C นอกจากนี้คุณยังสามารถใช้ C API โดยตรงในรหัส Objective-C

ดูด้านล่างสำหรับรายละเอียดเกี่ยวกับการใช้ สวิฟท์ , Objective-C และ C API หรือตาม QuickStart iOS ของคุณ สำหรับการกวดวิชาและเป็นตัวอย่างรหัส

แพลตฟอร์มลินุกซ์

บนแพลตฟอร์มลินุกซ์ (รวมทั้ง ราสเบอร์รี่ Pi ) คุณสามารถเรียกใช้การหาข้อสรุปโดยใช้ API TensorFlow Lite ที่มีอยู่ใน C ++ และ งูหลาม ที่แสดงในส่วนต่อไปนี้

การวิ่งโมเดล

การรันโมเดล TensorFlow Lite มีขั้นตอนง่ายๆ ไม่กี่ขั้นตอน:

  1. โหลดโมเดลลงในหน่วยความจำ
  2. สร้าง Interpreter ขึ้นอยู่กับรูปแบบที่มีอยู่
  3. ตั้งค่าเทนเซอร์อินพุต (เลือกปรับขนาดเทนเซอร์อินพุตหากไม่ต้องการขนาดที่กำหนดไว้ล่วงหน้า)
  4. เรียกใช้การอนุมาน
  5. อ่านค่าเทนเซอร์เอาต์พุต

ส่วนต่อไปนี้จะอธิบายวิธีการทำตามขั้นตอนเหล่านี้ในแต่ละภาษา

โหลดและรันโมเดลใน Java

แพลตฟอร์ม: Android

ชวา API สำหรับการทำงานกับการอนุมาน TensorFlow Lite ถูกออกแบบมาสำหรับการใช้งานกับ Android ดังนั้นจึงสามารถใช้ได้เป็นพึ่งพาห้องสมุด Android: org.tensorflow:tensorflow-lite

ใน Java คุณจะใช้ Interpreter ระดับการโหลดรูปแบบและรูปแบบไดรฟ์การอนุมาน ในหลายกรณี นี่อาจเป็น API เดียวที่คุณต้องการ

คุณสามารถเริ่มต้น Interpreter ใช้ .tflite ไฟล์:

public Interpreter(@NotNull File modelFile);

หรือกับ MappedByteBuffer :

public Interpreter(@NotNull MappedByteBuffer mappedByteBuffer);

ในทั้งสองกรณีคุณจะต้องให้ถูกต้องแบบ TensorFlow Lite หรือ API พ่น IllegalArgumentException ถ้าคุณใช้ MappedByteBuffer ในการเริ่มต้น Interpreter จะต้องยังคงไม่เปลี่ยนแปลงสำหรับทั้งชีวิตของ Interpreter

วิธีที่ต้องการในการอนุมานบนโมเดลคือการใช้ลายเซ็น - มีให้สำหรับโมเดลที่แปลงโดยเริ่มต้น Tensorflow 2.5

try (Interpreter interpreter = new Interpreter(file_of_tensorflowlite_model)) {
  Map<String, Object> inputs = new HashMap<>();
  inputs.put("input_1", input1);
  inputs.put("input_2", input2);
  Map<String, Object> outputs = new HashMap<>();
  outputs.put("output_1", output1);
  interpreter.runSignature(inputs, outputs, "mySignature");
}

runSignature วิธีการใช้เวลาสามข้อโต้แย้ง:

  • ปัจจัยการผลิต: แผนที่สำหรับปัจจัยการผลิตจากการป้อนข้อมูลชื่อในลายเซ็นไปยังวัตถุการป้อนข้อมูล

  • ขาออก: แผนที่สำหรับการทำแผนที่เอาท์พุทเอาท์พุทจากชื่อในลายเซ็นให้กับข้อมูลออก

  • ลายเซ็นชื่อ [ตัวเลือก]: ชื่อลายเซ็น (สามารถถูกทิ้งไว้ว่างเปล่าถ้าแบบมีลายเซ็นเดี่ยว)

อีกวิธีหนึ่งในการรันการอนุมานเมื่อโมเดลไม่มีลายเซ็นที่กำหนดไว้ เพียงโทร Interpreter.run() ตัวอย่างเช่น:

try (Interpreter interpreter = new Interpreter(file_of_a_tensorflowlite_model)) {
  interpreter.run(input, output);
}

run() วิธีการใช้เวลาเพียงหนึ่งการป้อนข้อมูลและผลตอบแทนเพียงหนึ่งเอาท์พุท ดังนั้นหากโมเดลของคุณมีหลายอินพุตหรือหลายเอาต์พุต ให้ใช้:

interpreter.runForMultipleInputsOutputs(inputs, map_of_indices_to_outputs);

ในกรณีนี้แต่ละรายการใน inputs สอดคล้องกับเมตริกซ์เข้าและ map_of_indices_to_outputs แผนที่ดัชนีของเทนเซอร์ส่งออกไปยังข้อมูลการส่งออกที่สอดคล้องกัน

ในทั้งสองกรณีดัชนีเมตริกซ์ควรตรงกับค่าที่คุณมอบให้ TensorFlow Lite แปลง เมื่อคุณสร้างแบบจำลอง โปรดทราบว่าคำสั่งของเทนเซอร์ใน input จะต้องตรงกับคำสั่งที่ได้รับการ TensorFlow Lite แปลง

Interpreter ชั้นนอกจากนี้ยังมีฟังก์ชั่นที่สะดวกสำหรับคุณที่จะได้รับการป้อนข้อมูลดัชนีของรูปแบบใด ๆ หรือการส่งออกโดยใช้ชื่อการดำเนินการ:

public int getInputIndex(String opName);
public int getOutputIndex(String opName);

หาก opName ไม่ได้การดำเนินการที่ถูกต้องในรูปแบบที่มันพ่น IllegalArgumentException

นอกจากนี้ระวังว่า Interpreter เป็นเจ้าของทรัพยากร เพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ ทรัพยากรจะต้องถูกปล่อยหลังจากใช้งานโดย:

interpreter.close();

สำหรับโครงการตัวอย่างเช่นกับ Java, ดู ตัวอย่างการจัดหมวดหมู่ภาพ Android

ชนิดข้อมูลที่รองรับ (ใน Java)

ในการใช้ TensorFlow Lite ชนิดข้อมูลของเทนเซอร์อินพุตและเอาต์พุตต้องเป็นหนึ่งในประเภทพื้นฐานต่อไปนี้:

  • float
  • int
  • long
  • byte

String ประเภทได้รับการสนับสนุน แต่พวกเขาจะถูกเข้ารหัสแตกต่างจากรูปแบบดั้งเดิม โดยเฉพาะอย่างยิ่ง รูปร่างของสตริง เทนเซอร์จะกำหนดจำนวนและการจัดเรียงของสตริงในเทนเซอร์ โดยแต่ละองค์ประกอบจะเป็นสตริงที่มีความยาวผันแปรได้ ในความรู้สึกนี้ (ไบต์) ขนาดของ Tensor ไม่สามารถคำนวณได้จากรูปร่างและพิมพ์เพียงอย่างเดียวและทำให้สายไม่สามารถจัดให้เป็นหนึ่งเดียวแบน ByteBuffer โต้แย้ง

ถ้าชนิดข้อมูลอื่น ๆ รวมทั้งชนิดบรรจุกล่องเช่น Integer และ Float ถูกนำมาใช้เป็น IllegalArgumentException จะถูกโยน

อินพุต

แต่ละคนควรจะป้อนข้อมูลอาร์เรย์หรือหลายมิติอาร์เรย์ของชนิดดั้งเดิมได้รับการสนับสนุนหรือดิบ ByteBuffer ของขนาดที่เหมาะสม ถ้าอินพุตเป็นอาร์เรย์หรืออาร์เรย์หลายมิติ เทนเซอร์อินพุตที่เกี่ยวข้องจะถูกปรับขนาดโดยปริยายเป็นมิติของอาร์เรย์ ณ เวลาอนุมาน ถ้าใส่เป็น ByteBuffer โทรควรแรกด้วยตนเองปรับขนาดเมตริกซ์การป้อนข้อมูลที่เกี่ยวข้อง (ผ่าน Interpreter.resizeInput() ) ก่อนที่จะใช้การอนุมาน

เมื่อใช้ ByteBuffer ชอบใช้บัฟเฟอร์ไบต์โดยตรงเช่นนี้จะช่วยให้ Interpreter เพื่อหลีกเลี่ยงการสำเนาที่ไม่จำเป็น หาก ByteBuffer เป็นบัฟเฟอร์ไบต์ตรงการสั่งซื้อของต้อง ByteOrder.nativeOrder() หลังจากที่ใช้สำหรับการอนุมานแบบจำลองแล้ว จะต้องไม่เปลี่ยนแปลงจนกว่าการอนุมานแบบจำลองจะเสร็จสิ้น

ผลลัพธ์

แต่ละเอาต์พุตควรเป็นอาร์เรย์หรืออาร์เรย์หลายมิติของประเภทพื้นฐานที่รองรับ หรือ ByteBuffer ที่มีขนาดเหมาะสม โปรดทราบว่าบางรุ่นมีเอาต์พุตแบบไดนามิก โดยที่รูปร่างของเทนเซอร์เอาต์พุตอาจแตกต่างกันไปตามอินพุต ไม่มีวิธีตรงไปตรงมาในการจัดการกับ Java inference API ที่มีอยู่ แต่ส่วนขยายที่วางแผนไว้จะทำให้สิ่งนี้เป็นไปได้

โหลดและเรียกใช้โมเดลใน Swift

แพลตฟอร์ม: iOS

Swift API มีให้บริการใน TensorFlowLiteSwift Pod จาก Cocoapods

ครั้งแรกที่คุณจำเป็นต้องนำเข้า TensorFlowLite โมดูล

import TensorFlowLite
// Getting model path
guard
  let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
else {
  // Error handling...
}

do {
  // Initialize an interpreter with the model.
  let interpreter = try Interpreter(modelPath: modelPath)

  // Allocate memory for the model's input `Tensor`s.
  try interpreter.allocateTensors()

  let inputData: Data  // Should be initialized

  // input data preparation...

  // Copy the input data to the input `Tensor`.
  try self.interpreter.copy(inputData, toInputAt: 0)

  // Run inference by invoking the `Interpreter`.
  try self.interpreter.invoke()

  // Get the output `Tensor`
  let outputTensor = try self.interpreter.output(at: 0)

  // Copy output to `Data` to process the inference results.
  let outputSize = outputTensor.shape.dimensions.reduce(1, {x, y in x * y})
  let outputData =
        UnsafeMutableBufferPointer<Float32>.allocate(capacity: outputSize)
  outputTensor.data.copyBytes(to: outputData)

  if (error != nil) { /* Error handling... */ }
} catch error {
  // Error handling...
}

โหลดและรันโมเดลใน Objective-C

แพลตฟอร์ม: iOS

Objective-C API มีให้บริการใน TensorFlowLiteObjC Pod จาก Cocoapods

ครั้งแรกที่คุณจำเป็นต้องนำเข้า TensorFlowLite โมดูล

@import TensorFlowLite;
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];
NSError *error;

// Initialize an interpreter with the model.
TFLInterpreter *interpreter = [[TFLInterpreter alloc] initWithModelPath:modelPath
                                                                  error:&error];
if (error != nil) { /* Error handling... */ }

// Allocate memory for the model's input `TFLTensor`s.
[interpreter allocateTensorsWithError:&error];
if (error != nil) { /* Error handling... */ }

NSMutableData *inputData;  // Should be initialized
// input data preparation...

// Get the input `TFLTensor`
TFLTensor *inputTensor = [interpreter inputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy the input data to the input `TFLTensor`.
[inputTensor copyData:inputData error:&error];
if (error != nil) { /* Error handling... */ }

// Run inference by invoking the `TFLInterpreter`.
[interpreter invokeWithError:&error];
if (error != nil) { /* Error handling... */ }

// Get the output `TFLTensor`
TFLTensor *outputTensor = [interpreter outputTensorAtIndex:0 error:&error];
if (error != nil) { /* Error handling... */ }

// Copy output to `NSData` to process the inference results.
NSData *outputData = [outputTensor dataWithError:&error];
if (error != nil) { /* Error handling... */ }

การใช้ C API ในโค้ด Objective-C

ปัจจุบัน Objective-C API ไม่รองรับผู้รับมอบสิทธิ์ เพื่อที่จะได้รับมอบหมายใช้กับรหัส Objective-C, คุณจะต้องเรียกโดยตรงพื้นฐาน C API

#include "tensorflow/lite/c/c_api.h"
TfLiteModel* model = TfLiteModelCreateFromFile([modelPath UTF8String]);
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();

// Create the interpreter.
TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);

// Allocate tensors and populate the input tensor data.
TfLiteInterpreterAllocateTensors(interpreter);
TfLiteTensor* input_tensor =
    TfLiteInterpreterGetInputTensor(interpreter, 0);
TfLiteTensorCopyFromBuffer(input_tensor, input.data(),
                           input.size() * sizeof(float));

// Execute inference.
TfLiteInterpreterInvoke(interpreter);

// Extract the output tensor data.
const TfLiteTensor* output_tensor =
    TfLiteInterpreterGetOutputTensor(interpreter, 0);
TfLiteTensorCopyToBuffer(output_tensor, output.data(),
                         output.size() * sizeof(float));

// Dispose of the model and interpreter objects.
TfLiteInterpreterDelete(interpreter);
TfLiteInterpreterOptionsDelete(options);
TfLiteModelDelete(model);

โหลดและเรียกใช้โมเดลใน C++

แพลตฟอร์ม: Android, iOS และ Linux

ใน C ++, รุ่นถูกเก็บไว้ใน FlatBufferModel ระดับ มันห่อหุ้มโมเดล TensorFlow Lite และคุณสามารถสร้างได้สองสามวิธี ขึ้นอยู่กับตำแหน่งที่จัดเก็บโมเดล:

class FlatBufferModel {
  // Build a model based on a file. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromFile(
      const char* filename,
      ErrorReporter* error_reporter);

  // Build a model based on a pre-loaded flatbuffer. The caller retains
  // ownership of the buffer and should keep it alive until the returned object
  // is destroyed. Return a nullptr in case of failure.
  static std::unique_ptr<FlatBufferModel> BuildFromBuffer(
      const char* buffer,
      size_t buffer_size,
      ErrorReporter* error_reporter);
};

ตอนนี้คุณมีรูปแบบเป็น FlatBufferModel วัตถุคุณสามารถดำเนินการได้ด้วยการ Interpreter เดียว FlatBufferModel สามารถใช้พร้อมกันมากกว่าหนึ่ง Interpreter

ส่วนที่สำคัญของ Interpreter API จะแสดงในโค้ดข้างล่างนี้ ควรสังเกตว่า:

  • เทนเซอร์จะแสดงด้วยจำนวนเต็ม เพื่อหลีกเลี่ยงการเปรียบเทียบสตริง (และการพึ่งพาไลบรารีสตริงแบบตายตัว)
  • ล่ามต้องไม่สามารถเข้าถึงได้จากเธรดที่เกิดขึ้นพร้อมกัน
  • การจัดสรรหน่วยความจำสำหรับเข้าและส่งออกเทนเซอร์จะต้องถูกเรียกโดยการเรียก AllocateTensors() ทันทีหลังจากการปรับขนาดเทนเซอร์

การใช้งาน TensorFlow Lite ที่ง่ายที่สุดกับ C++ มีลักษณะดังนี้:

// Load the model
std::unique_ptr<tflite::FlatBufferModel> model =
    tflite::FlatBufferModel::BuildFromFile(filename);

// Build the interpreter
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> interpreter;
tflite::InterpreterBuilder(*model, resolver)(&interpreter);

// Resize input tensors, if desired.
interpreter->AllocateTensors();

float* input = interpreter->typed_input_tensor<float>(0);
// Fill `input`.

interpreter->Invoke();

float* output = interpreter->typed_output_tensor<float>(0);

สำหรับโค้ดตัวอย่างเพิ่มเติมโปรดดูที่ minimal.cc และ label_image.cc

โหลดและเรียกใช้โมเดลใน Python

แพลตฟอร์ม: Linux

งูหลาม API สำหรับการทำงานการอนุมานให้ไว้ใน tf.lite โมดูล จากการที่คุณจะต้องเป็นส่วนใหญ่เท่านั้น tf.lite.Interpreter โหลดรูปแบบและเรียกใช้การอนุมาน

แสดงให้เห็นตัวอย่างต่อไปนี้วิธีการใช้ล่ามหลามโหลด .tflite ไฟล์และเรียกใช้การอนุมานที่มีการป้อนข้อมูลแบบสุ่ม:

ขอแนะนำให้ใช้ตัวอย่างนี้หากคุณกำลังแปลงจาก SavedModel ด้วย SignatureDef ที่กำหนดไว้ มีจำหน่ายตั้งแต่ TensorFlow 2.5

class TestModel(tf.Module):
  def __init__(self):
    super(TestModel, self).__init__()

  @tf.function(input_signature=[tf.TensorSpec(shape=[1, 10], dtype=tf.float32)])
  def add(self, x):
    '''
    Simple method that accepts single input 'x' and returns 'x' + 4.
    '''
    # Name the output 'result' for convenience.
    return {'result' : x + 4}


SAVED_MODEL_PATH = 'content/saved_models/test_variable'
TFLITE_FILE_PATH = 'content/test_variable.tflite'

# Save the model
module = TestModel()
# You can omit the signatures argument and a default signature name will be
# created with name 'serving_default'.
tf.saved_model.save(
    module, SAVED_MODEL_PATH,
    signatures={'my_signature':module.add.get_concrete_function()})

# Convert the model using TFLiteConverter
converter = tf.lite.TFLiteConverter.from_saved_model(SAVED_MODEL_PATH)
tflite_model = converter.convert()
with open(TFLITE_FILE_PATH, 'wb') as f:
  f.write(tflite_model)

# Load the TFLite model in TFLite Interpreter
interpreter = tf.lite.Interpreter(TFLITE_FILE_PATH)
# There is only 1 signature defined in the model,
# so it will return it by default.
# If there are multiple signatures then we can pass the name.
my_signature = interpreter.get_signature_runner()

# my_signature is callable with input as arguments.
output = my_signature(x=tf.constant([1.0], shape=(1,10), dtype=tf.float32))
# 'output' is dictionary with all outputs from the inference.
# In this case we have single output 'result'.
print(output['result'])

อีกตัวอย่างหนึ่งหากโมเดลไม่มีการกำหนด SignatureDefs

import numpy as np
import tensorflow as tf

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path="converted_model.tflite")
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Test the model on random input data.
input_shape = input_details[0]['shape']
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)

ในฐานะที่เป็นทางเลือกในการโหลดแบบเป็น pre-แปลง .tflite ไฟล์คุณสามารถรวมรหัสของคุณกับ TensorFlow Lite แปลงงูหลาม API ( tf.lite.TFLiteConverter ) ที่ช่วยให้คุณสามารถแปลงรูปแบบ TensorFlow ของคุณในรูปแบบ TensorFlow Lite แล้ว เรียกใช้การอนุมาน:

import numpy as np
import tensorflow as tf

img = tf.placeholder(name="img", dtype=tf.float32, shape=(1, 64, 64, 3))
const = tf.constant([1., 2., 3.]) + tf.constant([1., 4., 4.])
val = img + const
out = tf.identity(val, name="out")

# Convert to TF Lite format
with tf.Session() as sess:
  converter = tf.lite.TFLiteConverter.from_session(sess, [img], [out])
  tflite_model = converter.convert()

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

# Continue to get tensors and so forth, as shown above...

สำหรับข้อมูลเพิ่มเติมตัวอย่างรหัสหลามดู label_image.py

เคล็ดลับ: เรียก help(tf.lite.Interpreter) ในสถานีงูใหญ่ที่จะได้รับเอกสารรายละเอียดเกี่ยวกับล่าม

การดำเนินงานที่รองรับ

TensorFlow Lite รองรับชุดย่อยของการดำเนินการ TensorFlow โดยมีข้อจำกัดบางประการ สำหรับรายการเต็มรูปแบบของการดำเนินงานและข้อ จำกัด ดู หน้า TF Lite Ops