Criar o TensorFlow Lite para iOS

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

Como criar localmente

Em alguns casos, pode ser útil usar um build local do TensorFlow Lite. Por exemplo, quando você quiser fazer alterações locais no TensorFlow Lite e testar essas mudanças no seu app iOS ou preferir usar um framework estático em vez do dinâmico fornecido. Para criar um framework universal do iOS para o TensorFlow Lite localmente, você precisa criá-lo usando o Bazel em uma máquina macOS.

Instalar o Xcode

Se ainda não tiver feito isso, instale o Xcode 8 ou uma versão mais recente 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 o Bazel

O Bazel é o principal sistema de build do TensorFlow. Instale o Bazel de acordo com as instruções no site do Bazel (link em inglês). Escolha uma versão entre _TF_MIN_BAZEL_VERSION e _TF_MAX_BAZEL_VERSION no arquivo configure.py na raiz do repositório tensorflow.

Configurar o ESPAÇO DE TRABALHO e um arquivo .bazelrc

Execute o script ./configure no diretório raiz de finalização de compra do TensorFlow e responda "Sim" quando o script perguntar se você quer criar o TensorFlow com suporte ao iOS.

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

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

Esse comando gera o arquivo TensorFlowLiteC_framework.zip no diretório bazel-bin/tensorflow/lite/ios/ no diretório raiz do TensorFlow. Por padrão, o framework gerado contém um binário "fat", com armv7, arm64 e x86_64 (mas não i386). Para ver a lista completa de flags de build usadas ao especificar --config=ios_fat, consulte a seção de configurações do iOS no arquivo .bazelrc.

Criar um framework estático do TensorFlowLiteC

Por padrão, só distribuímos o framework dinâmico via Cocoapods. Se, em vez disso, você quiser usar o framework estático, crie o framework estático TensorFlowLiteC com o seguinte comando:

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

O comando gera um arquivo chamado TensorFlowLiteC_static_framework.zip no diretório bazel-bin/tensorflow/lite/ios/ no diretório raiz do TensorFlow. Esse framework estático pode ser usado exatamente da mesma maneira que o dinâmico.

Criar seletivamente frameworks do TFLite

É possível criar frameworks menores direcionados apenas a um conjunto de modelos usando o build seletivo, que pula operações não utilizadas no conjunto de modelos e inclui apenas os kernels de operações necessários para executar o conjunto especificado. 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 vai gerar o framework estático bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteC_framework.zip para operações integradas e personalizadas do TensorFlow Lite e, como opção, gera o framework estático bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteSelectTfOps_framework.zip se os modelos contiverem operações selecionadas do TensorFlow. A sinalização --target_archs pode ser usada para especificar as arquiteturas de implantação.

Use no seu próprio aplicativo

Desenvolvedores do CocoaPods

Há três CocoaPods para o TensorFlow Lite:

  • TensorFlowLiteSwift: fornece as APIs Swift para o TensorFlow Lite.
  • TensorFlowLiteObjC: fornece as APIs Objective-C para o TensorFlow Lite.
  • TensorFlowLiteC: pod de base comum, que incorpora o ambiente de execução principal do TensorFlow Lite e expõe as APIs C de base usadas pelos dois pods acima. Não deve ser usado diretamente pelos usuários.

Como desenvolvedor, escolha o pod TensorFlowLiteSwift ou TensorFlowLiteObjC com base na linguagem em que seu app foi escrito, mas não ambos. As etapas exatas para usar builds locais do TensorFlow Lite variam de acordo com a parte exata que você quer criar.

Como usar APIs Swift ou Objective-C locais

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

  1. Faça mudanças nas APIs Swift ou Objective-C na finalização da compra de tensorflow.

  2. Abra o arquivo TensorFlowLite(Swift|ObjC).podspec e atualize esta linha:
    s.dependency 'TensorFlowLiteC', "#{s.version}"
    para:
    s.dependency 'TensorFlowLiteC', "~> 0.0.1-nightly"
    Isso garante que você esteja criando suas APIs Swift ou Objective-C de acordo com a versão noturna mais recente disponível das APIs TensorFlowLiteC (criada 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 a finalização da compra local do tensorflow. Como alternativa, você pode publicar sua própria versão do TensorFlowLiteC e usá-la. Consulte a seção Como usar o núcleo do TensorFlow Lite local abaixo.

  3. No Podfile do seu projeto iOS, altere a dependência da seguinte maneira para apontar para o caminho local para o diretório raiz 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 no diretório raiz do projeto iOS.
    $ pod update

  5. Abra o espaço de trabalho gerado (<project>.xcworkspace) e recrie seu app no Xcode.

Como usar o TensorFlow Lite Core local

É possível configurar um repositório privado de especificações do CocoaPods e publicar seu framework TensorFlowLiteC personalizado no repositório privado. É possível copiar esse 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, siga as instruções sobre como usar o CocoaPods particular para usá-lo no seu projeto. Também é possível modificar o TensorFlowLite(Swift|ObjC).podspec de modo que ele aponte para seu pod TensorFlowLiteC personalizado e use o pod do Swift ou Objective-C no projeto do app.

Desenvolvedores do Bazel

Se você está usando o Bazel como a principal ferramenta de build, basta adicionar a dependência TensorFlowLite ao destino no arquivo BUILD.

Para Swift:

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

Para Objective-C:

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

Quando você cria o projeto do app, todas as alterações na biblioteca do TensorFlow Lite são selecionadas e integradas ao app.

Modificar as configurações do projeto do Xcode diretamente

É altamente recomendável usar o CocoaPods ou o Bazel para adicionar a dependência do TensorFlow Lite ao seu projeto. Se você ainda quiser adicionar o framework TensorFlowLiteC manualmente, será necessário adicionar o framework TensorFlowLiteC como um framework incorporado ao projeto do app. Descompacte o TensorFlowLiteC_framework.zip gerado no build acima para acessar o diretório TensorFlowLiteC.framework. Esse diretório é o framework real que o Xcode pode entender.

Depois de preparar o TensorFlowLiteC.framework, primeiro é necessário adicioná-lo como um binário incorporado ao destino do app. A seção exata de configurações do projeto pode variar dependendo da sua versão do Xcode.

  • Xcode 11: acesse a guia "Geral" do editor do projeto para o destino do app e adicione o TensorFlowLiteC.framework na seção "Estruturas, bibliotecas e conteúdo incorporado".
  • Xcode 10 e versões anteriores: acesse a guia "Geral" do editor do projeto para o destino do seu app e adicione o TensorFlowLiteC.framework em "Binários incorporados". O framework também precisa ser adicionado automaticamente na seção "Frameworks e bibliotecas vinculados".

Quando você adiciona o framework como um binário incorporado, o Xcode também atualiza a entrada "Caminhos de pesquisa do framework" na guia "Configurações de build" para incluir o diretório pai do framework. Caso isso não aconteça automaticamente, adicione 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 principais no diretório TensorFlowLiteC.framework/Headers.