Crie o TensorFlow Lite para iOS

Este documento descreve como criar a biblioteca do TensorFlow Lite para iOS por conta própria. Normalmente, você não precisa criar localmente a biblioteca TensorFlow Lite iOS. Se você quiser apenas usá-lo, a maneira mais fácil é usar as versões estáveis ​​pré-construídas ou noturnas do 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 em vez da dinâmica fornecida. Para criar localmente uma estrutura iOS universal para o TensorFlow Lite, você precisa construí-la usando o Bazel em uma máquina macOS.

Instale o Xcode

Se ainda não o fez, você 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

Instale o 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 TensorFlowLiteC com o comando a seguir.

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

Este comando irá 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 "gordo", 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 uma estrutura estática do TensorFlowLiteC

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

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

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

Construir seletivamente estruturas TFLite

Você pode construir estruturas menores visando apenas um conjunto de modelos usando construçã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 irá 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 APIs Swift para TensorFlow Lite.
  • TensorFlowLiteObjC : fornece as APIs Objective-C para TensorFlow Lite.
  • TensorFlowLiteC : pod base comum, que incorpora o tempo de execução 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 na linguagem em que seu aplicativo foi escrito, mas não ambos. As etapas exatas para usar compilações locais do TensorFlow Lite são diferentes, dependendo de qual parte exata você deseja compilar.

Usando APIs locais Swift ou Objective-C

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

  1. Faça alterações nas APIs Swift ou Objective-C em sua verificação tensorflow .

  2. Abra o arquivo 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 construindo suas APIs Swift ou Objective-C com base na 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 maneira para apontar para o caminho local para o diretório raiz tensorflow .
    Para rápido:
    pod 'TensorFlowLiteSwift', :path => '<your_tensorflow_root_dir>'
    Para Objetivo-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 novamente o espaço de trabalho gerado ( <project>.xcworkspace ) e reconstrua seu aplicativo no Xcode.

Usando o núcleo local do TensorFlow Lite

Você pode configurar um repositório privado de especificações CocoaPods e publicar sua estrutura TensorFlowLiteC personalizada 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 Bazel

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

Para rápido:

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

Para Objetivo-C:

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

Ao criar o projeto do seu 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 dependência do TensorFlow Lite ao seu projeto. Se ainda desejar adicionar a estrutura TensorFlowLiteC manualmente, você precisará adicionar a estrutura TensorFlowLiteC como uma estrutura incorporada ao projeto do seu 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 exata de configurações do projeto para isso pode variar dependendo da versão do Xcode.

  • Xcode 11: vá para a guia 'Geral' do editor de projeto do destino do seu aplicativo e adicione TensorFlowLiteC.framework na seção 'Frameworks, Libraries, and Embedded Content'.
  • Xcode 10 e anteriores: vá para a guia 'Geral' do editor de projeto do destino do seu aplicativo e adicione TensorFlowLiteC.framework em 'Binários incorporados'. A estrutura também deve ser adicionada automaticamente na seção 'Estruturas e Bibliotecas Vinculadas'.

Quando você adiciona a estrutura como um binário incorporado, o Xcode também atualiza a entrada 'Framework Search Paths' na guia 'Build Settings' para incluir o diretório pai da sua estrutura. 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 forem 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 .