Crie o TensorFlow Lite para iOS

Este documento descreve como criar a biblioteca do TensorFlow Lite iOS por conta própria. Normalmente, você não precisa criar localmente a biblioteca iOS do TensorFlow Lite. Se você quiser apenas usá-lo, a maneira mais fácil é usar as versões estáveis ​​ou noturnas pré-criadas dos TensorFlow Lite CocoaPods. Consulte o início rápido do iOS para obter mais detalhes sobre como usá-los em seus projetos iOS.

Construindo localmente

Em alguns casos, você pode querer usar uma versão local do TensorFlow Lite, por exemplo, quando quiser fazer alterações locais no TensorFlow Lite e testar essas alterações em seu aplicativo iOS ou preferir usar uma estrutura estática para nossa dinâmica fornecida. Para criar uma estrutura universal do iOS para o TensorFlow Lite localmente, você precisa criá-la usando o Bazel em uma máquina macOS.

Instalar o Xcode

Se você ainda não o fez, precisará instalar o Xcode 8 ou posterior e as ferramentas usando xcode-select :

xcode-select --install

Se esta for uma nova instalação, você precisará aceitar o contrato de licença para todos os usuários com o seguinte comando:

sudo xcodebuild -license accept

Instalar Bazel

Bazel é o principal sistema de compilação do TensorFlow. Instale o Bazel de acordo com as instruções no site do Bazel . Certifique-se de escolher uma versão entre _TF_MIN_BAZEL_VERSION e _TF_MAX_BAZEL_VERSION no arquivo configure.py na raiz do repositório tensorflow .

Configurar WORKSPACE e .bazelrc

Execute o script ./configure no diretório raiz de checkout do TensorFlow e responda "Sim" quando o script perguntar se você deseja criar o TensorFlow com suporte para iOS.

Depois que o Bazel estiver configurado corretamente com suporte para iOS, você poderá criar a estrutura do TensorFlowLiteC com o comando a seguir.

bazel build --config=ios_fat -c opt --cxxopt=--std=c++17 \
  //tensorflow/lite/ios:TensorFlowLiteC_framework

Esse comando gerará o arquivo TensorFlowLiteC_framework.zip no diretório bazel-bin/tensorflow/lite/ios/ no diretório raiz do TensorFlow. Por padrão, a estrutura gerada contém um binário "fat", contendo armv7, arm64 e x86_64 (mas não i386). Para ver a lista completa de sinalizadores de compilação usados ​​quando você especifica --config=ios_fat , consulte a seção de configurações do iOS no arquivo .bazelrc .

Crie a estrutura estática do TensorFlowLiteC

Por padrão, apenas distribuímos a estrutura dinâmica via Cocoapods. Se você quiser usar a estrutura estática, crie a estrutura estática do TensorFlowLiteC com o seguinte comando:

bazel build --config=ios_fat -c opt --cxxopt=--std=c++17 \
  //tensorflow/lite/ios:TensorFlowLiteC_static_framework

O comando gerará um arquivo chamado TensorFlowLiteC_static_framework.zip no bazel-bin/tensorflow/lite/ios/ no diretório raiz do TensorFlow. Essa estrutura estática pode ser usada exatamente da mesma maneira que a dinâmica.

Crie estruturas TFLite seletivamente

Você pode criar estruturas menores visando apenas um conjunto de modelos usando compilação seletiva, que ignorará operações não utilizadas em seu conjunto de modelos e incluirá apenas os kernels operacionais necessários para executar o determinado conjunto de modelos. O comando é o seguinte:

bash tensorflow/lite/ios/build_frameworks.sh \
  --input_models=model1.tflite,model2.tflite \
  --target_archs=x86_64,armv7,arm64

O comando acima gerará a estrutura estática bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteC_framework.zip para operações integradas e personalizadas do TensorFlow Lite; e, opcionalmente, gera a estrutura estática bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteSelectTfOps_framework.zip se seus modelos contiverem operações Select TensorFlow. Observe que o sinalizador --target_archs pode ser usado para especificar suas arquiteturas de implantação.

Use em seu próprio aplicativo

Desenvolvedores CocoaPods

Existem três CocoaPods para TensorFlow Lite:

  • TensorFlowLiteSwift : fornece as APIs Swift para TensorFlow Lite.
  • TensorFlowLiteObjC : fornece as APIs Objective-C para o TensorFlow Lite.
  • TensorFlowLiteC : pod base comum, que incorpora o runtime principal do TensorFlow Lite e expõe as APIs C básicas usadas pelos dois pods acima. Não se destina a ser usado diretamente pelos usuários.

Como desenvolvedor, você deve escolher o pod TensorFlowLiteSwift ou TensorFlowLiteObjC com base no idioma em que seu aplicativo está escrito, mas não em ambos. As etapas exatas para usar compilações locais do TensorFlow Lite diferem, dependendo de qual parte exata você gostaria de compilar.

Usando APIs locais Swift ou Objective-C

Se você estiver usando CocoaPods e quiser apenas testar algumas alterações locais nas APIs Swift ou Objective-C do TensorFlow Lite, siga as etapas aqui.

  1. Faça alterações nas APIs Swift ou Objective-C no checkout do tensorflow .

  2. Abra o TensorFlowLite(Swift|ObjC).podspec e atualize esta linha:
    s.dependency 'TensorFlowLiteC', "#{s.version}"
    ser:
    s.dependency 'TensorFlowLiteC', "~> 0.0.1-nightly"
    Isso é para garantir que você esteja compilando suas APIs Swift ou Objective-C em relação à versão noturna mais recente disponível das APIs TensorFlowLiteC (criadas todas as noites entre 1h e 4h, horário do Pacífico), em vez da versão estável, que pode estar desatualizada em comparação com seu tensorflow local Confira. Como alternativa, você pode optar por publicar sua própria versão do TensorFlowLiteC e usar essa versão (consulte a seção Usando o núcleo local do TensorFlow Lite abaixo).

  3. No Podfile do seu projeto iOS, altere a dependência da seguinte forma para apontar para o caminho local para o diretório raiz do tensorflow .
    Para Swift:
    pod 'TensorFlowLiteSwift', :path => '<your_tensorflow_root_dir>'
    Para Objective-C:
    pod 'TensorFlowLiteObjC', :path => '<your_tensorflow_root_dir>'

  4. Atualize a instalação do pod a partir do diretório raiz do projeto iOS.
    $ pod update

  5. Reabra o espaço de trabalho gerado ( <project>.xcworkspace ) e reconstrua seu aplicativo no Xcode.

Como usar o núcleo local do TensorFlow Lite

Você pode configurar um repositório privado de especificações do CocoaPods e publicar sua estrutura personalizada do TensorFlowLiteC em seu repositório privado. Você pode copiar este arquivo podspec e modificar alguns valores:

  ...
  s.version      = <your_desired_version_tag>
  ...
  # Note the `///`, two from the `file://` and one from the `/path`.
  s.source       = { :http => "file:///path/to/TensorFlowLiteC_framework.zip" }
  ...
  s.vendored_frameworks = 'TensorFlowLiteC.framework'
  ...

Depois de criar seu próprio arquivo TensorFlowLiteC.podspec , você pode seguir as instruções sobre como usar CocoaPods privados para usá-lo em seu próprio projeto. Você também pode modificar o TensorFlowLite(Swift|ObjC).podspec para apontar para seu pod TensorFlowLiteC personalizado e usar o pod Swift ou Objective-C em seu projeto de aplicativo.

Desenvolvedores do Bazel

Se você estiver usando o Bazel como a principal ferramenta de compilação, basta adicionar a dependência do TensorFlowLite ao seu destino no arquivo BUILD .

Para Swift:

swift_library(
  deps = [
      "//tensorflow/lite/swift:TensorFlowLite",
  ],
)

Para Objective-C:

objc_library(
  deps = [
      "//tensorflow/lite/objc:TensorFlowLite",
  ],
)

Ao criar seu projeto de aplicativo, todas as alterações na biblioteca do TensorFlow Lite serão selecionadas e incorporadas ao seu aplicativo.

Modifique as configurações do projeto Xcode diretamente

É altamente recomendável usar CocoaPods ou Bazel para adicionar a dependência do TensorFlow Lite ao seu projeto. Se você ainda quiser adicionar a estrutura do TensorFlowLiteC manualmente, precisará adicionar a estrutura do TensorFlowLiteC como uma estrutura incorporada ao seu projeto de aplicativo. Descompacte o TensorFlowLiteC_framework.zip gerado a partir da compilação acima para obter o diretório TensorFlowLiteC.framework . Este diretório é a estrutura real que o Xcode pode entender.

Depois de preparar o TensorFlowLiteC.framework , primeiro você precisa adicioná-lo como um binário incorporado ao destino do seu aplicativo. A seção de configurações exatas do projeto para isso pode variar dependendo da sua versão do Xcode.

  • Xcode 11: Vá para a guia 'Geral' do editor de projeto para o destino do seu aplicativo e adicione o TensorFlowLiteC.framework na seção 'Frameworks, Libraries, and Embedded Content'.
  • Xcode 10 e abaixo: Vá para a guia 'General' do editor de projeto para o destino do seu aplicativo e adicione o TensorFlowLiteC.framework em 'Embedded Binaries'. A estrutura também deve ser adicionada automaticamente na seção 'Estruturas e bibliotecas vinculadas'.

Quando você adiciona o framework como um binário embutido, o Xcode também atualiza a entrada 'Framework Search Paths' na guia 'Build Settings' para incluir o diretório pai do seu framework. Caso isso não aconteça automaticamente, você deve adicionar manualmente o diretório pai do diretório TensorFlowLiteC.framework .

Depois que essas duas configurações estiverem concluídas, você poderá importar e chamar a API C do TensorFlow Lite, definida pelos arquivos de cabeçalho no diretório TensorFlowLiteC.framework/Headers .