Criar LiteRT para iOS

Este documento descreve como criar a biblioteca LiteRT para iOS por conta própria. Normalmente, você não precisa criar a biblioteca LiteRT do iOS localmente. Se você se quiser usá-lo, a maneira mais fácil é usar a versão estável pré-criada do LiteRT CocoaPods. Consulte iOS guia de início rápido para mais detalhes sobre como usá-los no seu iOS projetos.

Como criar localmente

Em alguns casos, você pode usar uma versão local do LiteRT para exemplo quando você quiser fazer alterações locais no LiteRT e testá-las alterações em seu aplicativo iOS ou preferir usar um framework estático em nossas um dinâmico. Para criar um framework iOS universal para o LiteRT localmente, você precisa criá-lo usando o Bazel em uma máquina macOS.

Instalar o Xcode

Se você ainda não tiver feito isso, instale o Xcode 8 ou posterior e as ferramentas usando xcode-select:

xcode-select --install

Se esta for uma nova instalação, será necessário 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 sistema de build principal do TensorFlow. Instale o Bazel de acordo com instruções no site do Bazel. Certifique-se de escolher versão entre _TF_MIN_BAZEL_VERSION e _TF_MAX_BAZEL_VERSION em Arquivo configure.py na raiz do repositório tensorflow.

Configurar o ESPAÇO DE TRABALHO e o .bazelrc

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

Depois que o Bazel estiver configurado corretamente com o suporte ao iOS, você vai poder criar o 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 em bazel-bin/tensorflow/lite/ios/ no diretório raiz do TensorFlow. Por padrão, o framework gerado contém um rótulo com armv7, arm64 e x86_64 (mas não i386). Para conferir a lista completa de flags de build usadas ao você especificar --config=ios_fat, consulte a seção de configurações do iOS na arquivo .bazelrc.

Criar o framework estático TensorFlowLiteC

Por padrão, distribuímos o framework dinâmico somente pelo Cocoapods. Se você quiser para usar o framework estático, crie a classe TensorFlowLiteC estática com o seguinte comando:

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

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

Crie estruturas do TFLite seletivamente

É possível criar frameworks menores que segmentam apenas um conjunto de modelos usando que vai pular operações não utilizadas no seu conjunto de modelos e incluir apenas as Kernels de operação necessários para executar um 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 vai gerar o framework estático bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteC_framework.zip para TensorFlow Operações integradas e personalizadas do Lite e, opcionalmente, gera o framework estático bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteSelectTfOps_framework.zip se seus modelos contêm operações selecionadas do TensorFlow. A sinalização --target_archs pode ser usado para especificar as arquiteturas de implantação.

Use no seu próprio aplicativo

Desenvolvedores de CocoaPods

Existem três CocoaPods para LiteRT:

  • TensorFlowLiteSwift: fornece as APIs Swift para LiteRT.
  • TensorFlowLiteObjC: fornece as APIs Objective-C para LiteRT.
  • TensorFlowLiteC: pod base comum, que incorpora o núcleo do LiteRT e expõe as APIs C de base usadas pelos dois pods acima. Não destinado a diretamente usados pelos usuários.

Como desenvolvedor, escolha TensorFlowLiteSwift ou TensorFlowLiteObjC com base no idioma em que o app é escrito, mas mas não os dois. As etapas exatas para usar builds locais do LiteRT são diferentes, dependendo da parte exata que você quer criar.

Como usar APIs locais do Swift ou Objective-C

Se estiver usando CocoaPods e quiser testar apenas algumas alterações locais no APIs Swift ou APIs Objective-C da LiteRT siga estas etapas.

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

  2. Abra o arquivo TensorFlowLite(Swift|ObjC).podspec e atualize esta linha:

    de s.dependency 'TensorFlowLiteC', "#{s.version}" para ser:
    s.dependency 'TensorFlowLiteC', "~> 0.0.1-nightly" de
    Isso serve para garantir que você está criando suas APIs Swift ou Objective-C com a versão noturna mais recente disponível das APIs TensorFlowLiteC (construído todas as noites entre 01h00 e 04h00, horário do Pacífico) em vez do Stable que pode estar desatualizada em comparação com a finalização da compra local no tensorflow. Como alternativa, você pode optar por publicar sua própria versão do TensorFlowLiteC e usar essa versão (consulte Como usar o LiteRT local principal abaixo).

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

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

Usar o núcleo LiteRT local

Configure um repositório privado de especificações de CocoaPods e publique seu repositório TensorFlowLiteC ao seu repositório particular. É possível copiar este podspec e modifique 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 o CocoaPods privado para usá-lo na sua próprio projeto. Também é possível modificar o TensorFlowLite(Swift|ObjC).podspec para aponte para seu pod TensorFlowLiteC personalizado e use Swift ou Objective-C pod no projeto do app.

Desenvolvedores do Bazel

Se você estiver usando o Bazel como a ferramenta de build principal, basta adicionar TensorFlowLite para o 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ê criar seu projeto de aplicativo, todas as alterações na biblioteca LiteRT serão e ser incorporada ao seu aplicativo.

Modificar as configurações do projeto do Xcode diretamente

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

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

  • Xcode 11: acesse a página "Geral" do editor do projeto para o destino do app, e adicione o TensorFlowLiteC.framework em "Frameworks, bibliotecas e Conteúdo incorporado' nesta seção.
  • Xcode 10 e versões anteriores: acesse a página "Geral" do editor do projeto para sua destino do app e adicione o TensorFlowLiteC.framework em "Embedded Binários". A estrutura também deve ser adicionada automaticamente em "Vinculado "Frameworks e bibliotecas" nesta seção.

Quando você adiciona a estrutura como um binário incorporado, o Xcode também atualiza a "Caminhos de pesquisa do framework" em "Configurações da versão" para incluir o elemento pai do seu framework. Caso isso não aconteça automaticamente, precisa adicionar manualmente o diretório pai do TensorFlowLiteC.framework diretório.

Quando essas duas configurações forem concluídas, você poderá importar e chamar a função A API C da LiteRT, definida pelos arquivos de cabeçalho em TensorFlowLiteC.framework/Headers.