Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Compilar TensorFlow Lite para iOS

Este documento descreve como construir a biblioteca TensorFlow Lite do 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 pré-construídas estáveis ​​ou noturnas do TensorFlow Lite CocoaPods. Veja iOS iniciar rapidamente para obter mais detalhes sobre como usá-los em seus projetos de iOS.

Construindo localmente

Em alguns casos, você pode desejar usar uma compilaçã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 de nossa dinâmica fornecida. Para criar uma estrutura iOS universal para TensorFlow Lite localmente, você precisa criá-la usando o Bazel em uma máquina macOS.

Instale o Xcode

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

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

Configure a ESPAÇO DE TRABALHO e .bazelrc

Executar o ./configure script no diretório de checkout TensorFlow raiz, e responda "Sim" quando o script pergunta se você deseja construir TensorFlow com suporte iOS.

Uma vez Bazel está devidamente configurado com suporte a iOS, você pode construir o TensorFlowLiteC quadro com o seguinte comando.

bazel build --config=ios_fat -c opt \
  //tensorflow/lite/ios:TensorFlowLiteC_framework

Este comando irá gerar o TensorFlowLiteC_framework.zip arquivo sob bazel-bin/tensorflow/lite/ios/ diretório sob seu diretório TensorFlow raiz. 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 bandeiras construção usado quando especificar --config=ios_fat , consulte a seção iOS configs na .bazelrc arquivo .

Construir estrutura estática TensorFlowLiteC

Por padrão, distribuímos apenas a estrutura dinâmica por meio de Cocoapods. Se você quiser usar a estrutura estática em vez disso, você pode construir o TensorFlowLiteC quadro estático com o seguinte comando:

bazel build --config=ios_fat -c opt \
  //tensorflow/lite/ios:TensorFlowLiteC_static_framework

O comando irá gerar um arquivo chamado TensorFlowLiteC_static_framework.zip sob bazel-bin/tensorflow/lite/ios/ diretório sob seu diretório TensorFlow raiz. 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, o que irá ignorar as 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 TensorFlow Lite embutido e personalizado ops; e, opcionalmente, gera a estrutura estática bazel-bin/tensorflow/lite/ios/tmp/TensorFlowLiteSelectTfOps_framework.zip se os seus modelos contêm ops Select TensorFlow. Note que o --target_archs bandeira pode ser usado para especificar suas arquiteturas de implantação.

Use em seu próprio aplicativo

Desenvolvedores de CocoaPods

Existem três CocoaPods para TensorFlow Lite:

  • TensorFlowLiteSwift : Fornece as APIs Swift para TensorFlow Lite.
  • TensorFlowLiteObjC : Fornece as APIs Objective-C para TensorFlow Lite.
  • TensorFlowLiteC : vagem de base comum, que incorpora o tempo de execução do núcleo TensorFlow Lite e expõe as APIs de base C usados pelo acima duas vagens. Não se destina a ser usado diretamente pelos usuários.

Como um desenvolvedor, você deve optar por TensorFlowLiteSwift ou TensorFlowLiteObjC Pod com base no idioma em que a sua aplicação está escrito, mas não ambos. As etapas exatas para usar compilações locais do TensorFlow Lite variam, dependendo de qual parte exata você gostaria de construir.

Usando APIs locais Swift ou Objective-C

Se você estiver usando CocoaPods, e só deseja testar algumas mudanças locais a do TensorFlow Lite Swift APIs ou Objective-C APIs , siga os passos aqui.

  1. Fazer alterações no Swift ou APIs Objective-C em seu tensorflow checkout.

  2. Abra o TensorFlowLite(Swift|ObjC).podspec arquivo e atualizar esta linha:
    s.dependency 'TensorFlowLiteC', "#{s.version}"
    ser:
    s.dependency 'TensorFlowLiteC', "~> 0.0.1-nightly"
    Isso é para garantir que você está construindo suas APIs Swift ou Objective-C contra a versão mais recente nightly disponíveis de TensorFlowLiteC APIs (construída a cada noite entre 1-4AM Pacific Time) em vez da versão estável, o que pode estar desatualizado em relação ao seu local de tensorflow Confira. Alternativamente, você pode optar por publicar sua própria versão de TensorFlowLiteC e usar essa versão (ver Usando núcleo locais TensorFlow Lite seção abaixo).

  3. No Podfile do seu projeto iOS, alterar a dependência da seguinte forma a apontar para o caminho local para o seu tensorflow diretório raiz.
    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. Reabrir o espaço de trabalho gerados ( <project>.xcworkspace ) e reconstruir a sua aplicação dentro de Xcode.

Usando o núcleo TensorFlow Lite local

Você pode configurar um CocoaPods privadas especs repositório, e publicar seu costume TensorFlowLiteC estrutura para a sua repo 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 o seu próprio TensorFlowLiteC.podspec arquivo, você pode seguir as instruções sobre como usar CocoaPods privadas para usá-lo em seu próprio projeto. Você também pode modificar o TensorFlowLite(Swift|ObjC).podspec para apontar para o costume TensorFlowLiteC pod e uso tanto Swift ou Objective-C pod em seu projeto aplicativo.

Desenvolvedores Bazel

Se você estiver usando Bazel como a principal ferramenta de construção, você pode simplesmente adicionar TensorFlowLite dependência para o seu alvo na sua BUILD arquivo.

Para Swift:

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

Para Objective-C:

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

Ao construir o projeto do seu aplicativo, todas as alterações na biblioteca do TensorFlow Lite serão coletadas e integradas 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 deseja adicionar TensorFlowLiteC quadro manualmente, você precisa adicionar o TensorFlowLiteC quadro como uma estrutura integrada para o seu projeto de aplicativo. Descompacte o TensorFlowLiteC_framework.zip gerada a partir da construção acima para obter a TensorFlowLiteC.framework diretório. Este diretório é a estrutura real que o Xcode pode entender.

Uma vez que você preparou o TensorFlowLiteC.framework , primeiro você precisa adicioná-lo como um binário incorporado ao seu alvo aplicativo. A seção exata de configurações do projeto para isso pode diferir dependendo da sua versão do Xcode.

  • Xcode 11: Vá para a aba 'Geral' do editor de projeto para o seu alvo aplicativo e adicione o TensorFlowLiteC.framework sob a seção 'Frameworks, bibliotecas e incorporado conteúdo'.
  • Xcode 10 e abaixo: Vá para a aba 'Geral' do editor de projeto para o seu alvo aplicativo e adicione o 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 'Caminhos de pesquisa da estrutura' na guia 'Configurações de compilação' para incluir o diretório pai de sua estrutura. No caso de isso não acontecer automaticamente, você deve adicionar manualmente o diretório pai do TensorFlowLiteC.framework diretório.

Uma vez que estas duas configurações são feitas, você deve ser capaz de importar e chamar C API do TensorFlow Lite, definido pelos arquivos de cabeçalho sob TensorFlowLiteC.framework/Headers diretório.