Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Mikrodenetleyicileri kullanmaya başlayın

Bu belge, bir modelin nasıl eğitileceğini ve bir mikro denetleyici kullanarak nasıl çıkarım yapılacağını açıklar.

Merhaba Dünya örneği

Hello World örneği, Mikrodenetleyiciler için TensorFlow Lite'ı kullanmanın mutlak temellerini göstermek için tasarlanmıştır. Bir sinüs fonksiyonunu kopyalayan bir modeli eğitir ve çalıştırırız, yani tek bir sayıyı girdi olarak alır ve sayının sinüs değerini verir. Mikrodenetleyiciye yerleştirildiğinde, öngörüleri ya LED'leri yanıp sönmek ya da bir animasyonu kontrol etmek için kullanılır.

Uçtan uca iş akışı aşağıdaki adımları içerir:

  1. Bir model eğitin (Python'da): Bir modeli cihaz üzerinde kullanım için eğitmek, dönüştürmek ve optimize etmek için bir jupyter dizüstü bilgisayar.
  2. Çalıştırma çıkarımı (C ++ 11'de): C ++ kitaplığını kullanarak model üzerinde çıkarım yapan uçtan uca bir birim testi.

Desteklenen bir cihaz alın

Kullanacağımız örnek uygulama aşağıdaki cihazlarda test edilmiştir:

Mikrodenetleyiciler için TensorFlow Lite'da desteklenen platformlar hakkında daha fazla bilgi edinin.

Bir model eğitin

Kendi modelinizi eğitmek için Google colaboratory'ı kullanın. Daha fazla ayrıntı için README.md bakın:

Merhaba Dünya Eğitimi README.md

Çıkarım çalıştır

Modeli cihazınızda çalıştırmak için README.md talimatları README.md :

Merhaba Dünya README.md

Aşağıdaki bölümlerde Örnekteki yürümek hello_world_test.cc Microcontrollers TensorFlow Lite kullanarak çıkarım çalıştırmak gösterilmiştir, birim testi. Modeli yükler ve birkaç kez çıkarım yapar.

1. Kitaplık başlıklarını ekleyin

TensorFlow Lite for Microcontrollers kitaplığını kullanmak için aşağıdaki başlık dosyalarını eklemeliyiz:

#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

2. Model başlığını ekleyin

Mikrodenetleyiciler için TensorFlow Lite yorumlayıcısı, modelin bir C ++ dizisi olarak sağlanmasını bekler. Model, model.h ve model.cc dosyalarında tanımlanmıştır. Başlık aşağıdaki satıra dahildir:

#include "tensorflow/lite/micro/examples/hello_world/model.h"

3. Birim testi çerçeve başlığını ekleyin

Bir birim testi oluşturmak için, aşağıdaki satırı ekleyerek Mikrodenetleyiciler için TensorFlow Lite birim test çerçevesini dahil ediyoruz:

#include "tensorflow/lite/micro/testing/micro_test.h"

Test, aşağıdaki makrolar kullanılarak tanımlanır:

TF_LITE_MICRO_TESTS_BEGIN

TF_LITE_MICRO_TEST(LoadModelAndPerformInference) {
  . // add code here
  .
}

TF_LITE_MICRO_TESTS_END

Şimdi yukarıdaki makroda bulunan kodu tartışıyoruz.

4. Günlük kaydını ayarlayın

Günlük kaydı oluşturmak için, bir tflite::ErrorReporter işaretçisi için bir işaretçi kullanılarak oluşturulan tflite::MicroErrorReporter örneği:

tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = &micro_error_reporter;

Bu değişken yorumlayıcıya aktarılır ve bu da günlükleri yazmasına izin verir. Mikrodenetleyiciler genellikle günlük kaydı için çeşitli mekanizmalara sahip olduklarından, tflite::MicroErrorReporter uygulaması, özel cihazınız için özelleştirilmek üzere tasarlanmıştır.

5. Bir model yükleyin

Aşağıdaki kodda, model verileri kullanılarak örneği char dizisi, g_model bildirilmiştir, model.h . Daha sonra şema sürümünün kullandığımız sürümle uyumlu olduğundan emin olmak için modeli kontrol ederiz:

const tflite::Model* model = ::tflite::GetModel(g_model);
if (model->version() != TFLITE_SCHEMA_VERSION) {
  TF_LITE_REPORT_ERROR(error_reporter,
      "Model provided is schema version %d not equal "
      "to supported version %d.\n",
      model->version(), TFLITE_SCHEMA_VERSION);
}

6. İşlem çözümleyicisini örnekleyin

Bir AllOpsResolver örneği bildirildi. Bu, yorumlayıcı tarafından model tarafından kullanılan işlemlere erişmek için kullanılacaktır:

tflite::AllOpsResolver resolver;

AllOpsResolver , çok fazla bellek kullanan Mikrodenetleyiciler için TensorFlow Lite'da bulunan tüm işlemleri yükler. Belirli bir model bu işlemlerin yalnızca bir alt kümesini kullanacağından, gerçek dünya uygulamalarının yalnızca gerekli işlemleri yüklemesi önerilir.

Bu, farklı bir sınıf olan MicroMutableOpResolver kullanılarak yapılır. Nasıl kullanılacağını Micro konuşma örneğinin micro_speech_test.cc .

7. Bellek ayırın

Giriş, çıkış ve ara diziler için belirli bir miktarda belleği önceden tahsis etmemiz gerekir. Bu, uint8_t boyutunun bir uint8_t dizisi olarak tensor_arena_size :

const int tensor_arena_size = 2 * 1024;
uint8_t tensor_arena[tensor_arena_size];

Gereken boyut, kullandığınız modele bağlı olacaktır ve deneme yoluyla belirlenmesi gerekebilir.

8. Tercümanı örnekleyin

Daha önce oluşturulan değişkenleri ileterek bir tflite::MicroInterpreter örneği oluşturuyoruz:

tflite::MicroInterpreter interpreter(model, resolver, tensor_arena,
                                     tensor_arena_size, error_reporter);

9. Tensörleri ayırın

Yorumlayıcıya, modelin tensörleri için tensor_arena bellek tensor_arena :

interpreter.AllocateTensors();

10. Giriş şeklini doğrulayın

MicroInterpreter örneği bize .input(0) çağırarak modelin giriş tensörüne bir işaretçi sağlayabilir; burada 0 , ilk (ve tek) giriş tensörünü temsil eder:

  // Obtain a pointer to the model's input tensor
  TfLiteTensor* input = interpreter.input(0);

Ardından, şeklinin ve türünün beklediğimiz gibi olduğunu doğrulamak için bu tensörü inceleriz:

// Make sure the input has the properties we expect
TF_LITE_MICRO_EXPECT_NE(nullptr, input);
// The property "dims" tells us the tensor's shape. It has one element for
// each dimension. Our input is a 2D tensor containing 1 element, so "dims"
// should have size 2.
TF_LITE_MICRO_EXPECT_EQ(2, input->dims->size);
// The value of each element gives the length of the corresponding tensor.
// We should expect two single element tensors (one is contained within the
// other).
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
// The input is a 32 bit floating point value
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, input->type);

Numaralama değeri kTfLiteFloat32 TensorFlow Lite veri türlerinden biri için bir referans ve tanımlanmıştır common.h .

11. Bir giriş değeri sağlayın

Modele bir girdi sağlamak için, girdi tensörünün içeriğini aşağıdaki gibi ayarlıyoruz:

input->data.f[0] = 0.;

Bu durumda, 0 temsil eden bir kayan nokta değeri giriyoruz.

12. Modeli çalıştırın

Modeli çalıştırmak için tflite::MicroInterpreter Invoke() tflite::MicroInterpreter :

TfLiteStatus invoke_status = interpreter.Invoke();
if (invoke_status != kTfLiteOk) {
  TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed\n");
}

Çalıştırmanın başarılı olup olmadığını belirlemek için bir TfLiteStatus dönüş değeri kontrol edebiliriz. Olası değerler TfLiteStatus tanımlanan common.h vardır kTfLiteOk ve kTfLiteError .

Aşağıdaki kod, değerin kTfLiteOk , yani çıkarımın başarıyla çalıştırıldığını iddia eder.

TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, invoke_status);

13. Çıktıyı alın

Modelin çıktısı tensör çağırarak elde edilebilir output(0) ile tflite::MicroInterpreter , 0 ilk (ve tek) çıkışı tensörünün temsil eder.

Örnekte, modelin çıktısı, bir 2B tensör içinde bulunan tek bir kayan nokta değeridir:

TfLiteTensor* output = interpreter.output(0);
TF_LITE_MICRO_EXPECT_EQ(2, output->dims->size);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, output->type);

Değeri doğrudan çıktı tensöründen okuyabilir ve beklediğimizin bu olduğunu iddia edebiliriz:

// Obtain the output value from the tensor
float value = output->data.f[0];
// Check that the output value is within 0.05 of the expected value
TF_LITE_MICRO_EXPECT_NEAR(0., value, 0.05);

14. Çıkarımı tekrar çalıştırın

Kodun geri kalanı birkaç kez daha çıkarım yapar. Her durumda, giriş tensörüne bir değer atar, yorumlayıcıyı çağırır ve sonucu çıkış tensöründen okuruz:

input->data.f[0] = 1.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.841, value, 0.05);

input->data.f[0] = 3.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.141, value, 0.05);

input->data.f[0] = 5.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(-0.959, value, 0.05);

15. Uygulama kodunu okuyun

Bu birim testini main_functions.cc sonra, main_functions.cc bulunan örneğin uygulama kodunu main_functions.cc . Benzer bir süreci izler, ancak kaç çıkarımın çalıştırıldığına bağlı olarak bir girdi değeri oluşturur ve modelin çıktısını kullanıcıya gösteren cihaza özgü bir işlevi çağırır.