Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Biblioteca de tareas de TensorFlow Lite

La biblioteca de tareas de TensorFlow Lite contiene un conjunto de bibliotecas específicas de tareas potentes y fáciles de usar para que los desarrolladores de aplicaciones creen experiencias de aprendizaje automático con TFLite. Proporciona interfaces de modelo optimizadas listas para usar para tareas populares de aprendizaje automático, como clasificación de imágenes, preguntas y respuestas, etc. Las interfaces de modelo están diseñadas específicamente para cada tarea para lograr el mejor rendimiento y usabilidad. La biblioteca de tareas funciona en varias plataformas y es compatible con Java, C ++ y Swift.

Qué esperar de la biblioteca de tareas

  • API limpias y bien definidas que pueden utilizar quienes no son expertos en ML
    La inferencia se puede hacer con solo 5 líneas de código. Use las API potentes y fáciles de usar en la biblioteca de tareas como bloques de construcción para ayudarlo a desarrollar fácilmente el aprendizaje automático con TFLite en dispositivos móviles.

  • Procesamiento de datos complejo pero común
    Admite la visión común y la lógica de procesamiento del lenguaje natural para convertir sus datos y el formato de datos requerido por el modelo. Proporciona la misma lógica de procesamiento que se puede compartir para el entrenamiento y la inferencia.

  • Ganancia de alto rendimiento
    El procesamiento de datos no tardaría más de unos pocos milisegundos, lo que garantiza una experiencia de inferencia rápida con TensorFlow Lite.

  • Extensibilidad y personalización
    Puede aprovechar todos los beneficios que ofrece la infraestructura de la biblioteca de tareas y crear fácilmente sus propias API de inferencia de Android / iOS.

Tareas admitidas

A continuación se muestra la lista de los tipos de tareas admitidos. Se espera que la lista crezca a medida que continuamos habilitando más y más casos de uso.

Ejecutar biblioteca de tareas con delegados

Los delegados permiten la aceleración de hardware de los modelos TensorFlow Lite mediante el aprovechamiento de los aceleradores en el dispositivo, tales como el GPU y la Coral Edge TPU . Utilizarlos para operaciones de redes neuronales proporciona enormes beneficios en términos de latencia y eficiencia energética. Por ejemplo, las GPU pueden proporcionar hasta un 5 veces más veloz en la latencia en los dispositivos móviles, y Coral Edge TPU inferencia 10 veces más rápidas que las CPU de escritorio.

La biblioteca de tareas proporciona una configuración sencilla y opciones alternativas para configurar y utilizar delegados. Los siguientes aceleradores ahora son compatibles con la API de tareas:

Delegado núcleo ML para iOS, y aceleración en soportes API web del Grupo de Java / Swift / son muy pronto.

Ejemplo de uso de GPU en Android en Java

Paso 1. Añadir la biblioteca de complementos GPU delegado de su módulo de build.gradle archivo:

dependencies {
    // Import Task Library dependency for vision, text, or audio.

    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.3.0'
}

Paso 2. Configurar delegado GPU en las opciones de tareas a través de BaseOptions . Por ejemplo, puede configurar GPU en ObjectDetecor de la siguiente manera:

// Turn on GPU delegation.
BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
// Configure other options in ObjectDetector
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(baseOptions)
        .setMaxResults(1)
        .build();

// Create ObjectDetector from options.
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Ejemplo de uso de GPU en Android en C ++

Paso 1. Depende del complemento de delegado de GPU en su destino de compilación de bazel, como:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:gpu_plugin", # for GPU
]

Otras opciones de delegado incluyen:

"//tensorflow_lite_support/acceleration/configuration:nnapi_plugin", # for NNAPI
"//tensorflow_lite_support/acceleration/configuration:hexagon_plugin", # for Hexagon

Paso 2. Configure el delegado de GPU en las opciones de tareas. Por ejemplo, puede configurar GPU en BertQuestionAnswerer de la siguiente manera:

// Initialization
BertQuestionAnswererOptions options;
// Load the TFLite model.
auto base_options = options.mutable_base_options();
base_options->mutable_model_file()->set_file_name(model_file);
// Turn on GPU delegation.
auto tflite_settings = base_options->mutable_compute_settings()->mutable_tflite_settings();
tflite_settings->set_delegate(Delegate::GPU);
// (optional) Turn on automatical fallback to TFLite CPU path on delegation errors.
tflite_settings->mutable_fallback_settings()->set_allow_automatic_fallback_on_execution_error(true);

// Create QuestionAnswerer from options.
std::unique_ptr<QuestionAnswerer> answerer = BertQuestionAnswerer::CreateFromOptions(options).value();

// Run inference on GPU.
std::vector<QaAnswer> results = answerer->Answer(context_of_question, question_to_ask);

Explorar la configuración de aceleración más avanzadas aquí .

Ejemplo de uso de Coral Edge TPU en C ++

Paso 1. Dependa del complemento de delegado de Coral Edge TPU en su destino de compilación de bazel, como:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:edgetpu_coral_plugin", # for Coral Edge TPU
]

Paso 2. Configure Coral Edge TPU en las opciones de la tarea. Por ejemplo, puede configurar Coral borde de TPU en ImageClassifier de la siguiente manera:

// Initialization
ImageClassifierOptions options;
// Load the TFLite model.
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
// Turn on Coral Edge TPU delegation.
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->set_delegate(Delegate::EDGETPU_CORAL);
// Create ImageClassifier from options.
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference on Coral Edge TPU.
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Paso 3. Instalar el libusb-1.0-0-dev paquete de la siguiente manera. Si ya está instalado, salte al siguiente paso.

# On the Linux
sudo apt-get install libusb-1.0-0-dev

# On the macOS
port install libusb
# or
brew install libusb

Paso 4. Compile con las siguientes configuraciones en su comando bazel:

# On the Linux
--define darwinn_portable=1 --linkopt=-lusb-1.0

# On the macOS, add '--linkopt=-lusb-1.0 --linkopt=-L/opt/local/lib/' if you are
# using MacPorts or '--linkopt=-lusb-1.0 --linkopt=-L/opt/homebrew/lib' if you
# are using Homebrew.
--define darwinn_portable=1 --linkopt=-L/opt/local/lib/ --linkopt=-lusb-1.0

# Windows is not supported yet.

Pruebe la herramienta de demostración tareas de la Biblioteca de la CLI con sus dispositivos Coral Edge TPU. Explora más en los modelos Edge TPU pretrained y configuración avanzada del borde TPU .