Aprenda o que há de mais recente em aprendizado de máquina, IA generativa e muito mais no WiML Symposium 2023 Registre-se

Esta página foi traduzida pela API Cloud Translation.

Instale o TensorFlow Java

O TensorFlow Java pode ser executado em qualquer JVM para criar, treinar e implantar modelos de machine learning. Ele oferece suporte à execução de CPU e GPU, em modo gráfico ou ansioso, e apresenta uma API avançada para usar o TensorFlow em um ambiente JVM. Java e outras linguagens JVM, como Scala e Kotlin, são frequentemente usadas em grandes e pequenas empresas em todo o mundo, o que torna o TensorFlow Java uma escolha estratégica para a adoção de machine learning em grande escala.

Requisitos

O TensorFlow Java é executado em Java 8 e superior e oferece suporte imediato às seguintes plataformas:

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

Versões

O TensorFlow Java tem seu próprio ciclo de lançamento, independente do tempo de execução do TensorFlow . Conseqüentemente, sua versão não corresponde à versão do tempo de execução do TensorFlow em que é executado. Consulte a tabela de versionamento Java do TensorFlow para listar todas as versões disponíveis e seu mapeamento com o tempo de execução do TensorFlow.

Artefatos

Existem várias maneiras de adicionar o TensorFlow Java ao seu projeto. O mais fácil é adicionar uma dependência ao artefato tensorflow-core-platform , que inclui a API TensorFlow Java Core e as dependências nativas necessárias para execução em todas as plataformas suportadas.

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

tensorflow-core-platform-mkl : Suporte para Intel® MKL-DNN em todas as plataformas
tensorflow-core-platform-gpu : Suporte para CUDA® em plataformas Linux e Windows
tensorflow-core-platform-mkl-gpu : Suporte para Intel® MKL-DNN e CUDA® na plataforma Linux.

Além disso, uma dependência separada na biblioteca tensorflow-framework pode ser adicionada para se beneficiar de um rico conjunto de utilitários para aprendizado de máquina baseado em TensorFlow na JVM.

Instalando com Maven

Para incluir o TensorFlow em seu aplicativo Maven , adicione uma dependência de seus artefatos ao arquivo pom.xml do seu projeto. Por exemplo,

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

Reduzindo o número de dependências

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

Se desejar atingir um subconjunto de plataformas disponíveis, você poderá excluir os artefatos desnecessários de outras plataformas usando o recurso Exclusão de dependência do Maven .

Outra maneira de selecionar quais plataformas você deseja incluir em sua aplicação é definir as propriedades do sistema JavaCPP, na linha de comando do Maven ou no seu pom.xml . Consulte a documentação do JavaCPP para obter mais detalhes.

Usando instantâneos

Os snapshots de desenvolvimento Java mais recentes do TensorFlow do repositório de origem Java do TensorFlow estão disponíveis no repositório OSS Sonatype Nexus. Para depender desses artefatos, certifique-se de configurar o repositório de snapshots do OSS em seu 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.4.0-SNAPSHOT</version>
    </dependency>
</dependencies>

Instalando com Gradle

Para incluir o TensorFlow em seu aplicativo Gradle , adicione uma dependência de seus artefatos ao arquivo build.gradle do seu projeto. Por exemplo,

repositories {
    mavenCentral()
}

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

Reduzindo o número de dependências

Excluir artefatos nativos do TensorFlow Java com Gradle não é tão fácil quanto com Maven. Recomendamos que você use plug-ins Gradle JavaCPP para reduzir esse número de dependências.

Leia a documentação do Gradle JavaCPP para obter mais detalhes.

Instalando a partir de fontes

Para criar o TensorFlow Java a partir de fontes e possivelmente personalizá-lo, leia as instruções a seguir.

Exemplo de programa

Este exemplo mostra como construir um projeto Apache Maven com 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.3.3</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);
        TInt32 x = TInt32.scalarOf(10);
        Tensor dblX = dbl.call(x)) {
      System.out.println(x.getInt() + " doubled is " + ((TInt32)dblX).getInt());
    }
  }

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

Compilar e executar:

mvn -q compile exec:java

O comando imprime a versão do TensorFlow e um cálculo simples.

Sucesso! O TensorFlow Java está configurado.