ML Community Day is November 9! Join us for updates from TensorFlow, JAX, and more Learn more

Instalar o TensorFlow Java

O TensorFlow Java pode ser executado em qualquer JVM para o desenvolvimento, o treinamento e a implantação de modelos de machine learning. É compatível com a execução em CPU e GPU, em modo de grafo ou antecipado, e apresenta uma API avançada para usar o TensorFlow em um ambiente de JVM. Java e outras linguagens de JVM, como Scala e Kotlin, são usadas com frequência em pequenas e grandes empresas no mundo todo. Isso torna o TensorFlow Java uma opção estratégica para adotar machine learning em larga escala.

Requisitos

O TensorFlow Java pode ser executado em Java 8 e versões posteriores, e é compatível de fábrica com as seguintes plataformas:

  • Ubuntu 16.04 ou superior; 64 bits, x86
  • macOS 10.12.6 (Sierra) ou superior; 64-bit, x86
  • Windows 7 ou superior; 64 bits, x86

Versões

O TensorFlow Java tem seu próprio ciclo de versões, independente do ambiente de execução do TensorFlow. Consequentemente, suas versões não correspondem às versões do ambiente de execução do TensorFlow em que é executado. Consulte a tabela de controle de versões do TensorFlow Java para listar todas as versões disponíveis e sua correlação com o ambiente de execução do TensorFlow.

Artefatos

Existem várias maneiras de adicionar o TensorFlow Java ao seu projeto. A mais fácil é adicionar uma dependência no artefato tensorflow-core-platform, que inclui tanto a API Core do TensorFlow Java quanto as dependências nativas que ele requer para ser executado em todas as plataformas compatíveis.

Você também pode selecionar uma das extensões a seguir, em vez da versão pura de CPU:

  • tensorflow-core-platform-mkl: compatível com Intel® MKL-DNN em todas as plataformas
  • tensorflow-core-platform-gpu: compatível com CUDA® em plataformas Linux e Windows
  • tensorflow-core-platform-mkl-gpu: compatível com Intel® MKL-DNN e CUDA® em plataformas Linux e Windows

Além disso, uma dependência separada da biblioteca tensorflow-framework pode ser adicionada para aproveitar um conjunto avançado de utilitários para machine learning com base no TensorFlow em JVM.

Instalação com Maven

Para incluir o TensorFlow no seu aplicativo Maven, adicione uma dependência nos artefatos à fila pom.xml do seu projeto. Por exemplo,

<dependency>
  <groupId>org.tensorflow</groupId>
  <artifactId>tensorflow-core-platform</artifactId>
  <version>0.2.0</version>
</dependency>

Redução no número de dependências

É importante observar que adicionar uma dependência a um artefato tensorflow-core-platform importará bibliotecas nativas para todas as plataformas compatíveis, o que pode aumentar significativamente o tamanho do seu projeto.

Se você quiser usar somente um subconjunto das plataformas compatíveis, exclua os artefatos desnecessários de outras plataformas usando o recurso de exclusão de dependências do Maven.

Outra maneira de selecionar as plataformas que você quer incluir no seu aplicativo é definindo as propriedades do sistema JavaCPP na linha de comando do Maven ou no pom.xml. Consulte a documentação do JavaCPP para saber mais.

Uso de snapshots

Os últimos snapshots de desenvolvimento do TensorFlow Java para o repositório de origem dele estão disponíveis no repositório OSS Sonatype Nexus. Para que os artefatos funcionem corretamente, configure o repositório de snapshots do OSS no pom.xml.

<repositories>
    <repository>
        <id>tensorflow-snapshots</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>org.tensorflow</groupId>
        <artifactId>tensorflow-core-platform</artifactId>
        <version>0.3.0-SNAPSHOT</version>
    </dependency>
</dependencies>

Instalação com Gradle

Para incluir o TensorFlow no seu aplicativo Gradle, adicione uma dependência aos artefatos à fila build.gradle do seu projeto. Por exemplo,

repositories {
    mavenCentral()
}

dependencies {
    compile group: 'org.tensorflow', name: 'tensorflow-core-platform', version: '0.2.0'
}

Redução no número de dependências

Excluir os artefatos nativos do TensorFlow Java com Gradle não é tão fácil como com Maven. Recomendamos usar plugins do Gradle JavaCPP para reduzir o número de dependências.

Consulte a documentação do Gradle JavaCPP para saber mais.

Instalação da origem

Para criar o TensorFlow Java da origem e poder personalizá-lo, leia as seguintes instruções.

Programa de exemplo

Este exemplo mostra como criar um projeto do Apache Maven com o TensorFlow. Primeiro adicione a dependência do TensorFlow ao arquivo pom.xml do projeto:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.myorg</groupId>
    <artifactId>hellotensorflow</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <exec.mainClass>HelloTensorFlow</exec.mainClass>
    <!-- Minimal version for compiling TensorFlow Java is JDK 8 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
    <!-- Include TensorFlow (pure CPU only) for all supported platforms -->
        <dependency>
            <groupId>org.tensorflow</groupId>
            <artifactId>tensorflow-core-platform</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>
</project>

Crie o arquivo de origem src/main/java/HelloTensorFlow.java:

import org.tensorflow.ConcreteFunction;
import org.tensorflow.Signature;
import org.tensorflow.Tensor;
import org.tensorflow.TensorFlow;
import org.tensorflow.op.Ops;
import org.tensorflow.op.core.Placeholder;
import org.tensorflow.op.math.Add;
import org.tensorflow.types.TInt32;

public class HelloTensorFlow {

  public static void main(String[] args) throws Exception {
    System.out.println("Hello TensorFlow " + TensorFlow.version());

    try (ConcreteFunction dbl = ConcreteFunction.create(HelloTensorFlow::dbl);
        Tensor<TInt32> x = TInt32.scalarOf(10);
        Tensor<TInt32> dblX = dbl.call(x).expect(TInt32.DTYPE)) {
      System.out.println(x.data().getInt() + " doubled is " + dblX.data().getInt());
    }
  }

  private static Signature dbl(Ops tf) {
    Placeholder<TInt32> x = tf.placeholder(TInt32.DTYPE);
    Add<TInt32> dblX = tf.math.add(x, x);
    return Signature.builder().input("x", x).output("dbl", dblX).build();
  }
}

Compile e execute:

mvn -q compile exec:java

O comando imprime: TensorFlow version and a simple calculation.

Pronto. O TensorFlow Java está configurado.