Instale o TensorFlow Java

TensorFlow Java pode ser executado em qualquer JVM para a construção, formação e implantação de modelos de aprendizagem de máquina. Ele é compatível com a execução de CPU e GPU, no modo gráfico ou ansioso, e apresenta uma API rica 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 adotar o aprendizado de máquina em grande escala.

Requisitos

O TensorFlow Java é executado em Java 8 e superior e oferece suporte para as seguintes plataformas prontas para uso:

  • 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

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

Artefatos

várias maneiras de adicionar TensorFlow Java para seu projeto. O mais fácil é adicionar uma dependência no tensorflow-core-platform artefato, que inclui tanto a API TensorFlow Java Core e as dependências nativos de que necessita para funcionar em todas as plataformas suportadas.

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

  • 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 : O suporte para Intel® MKL-DNN e CUDA® na plataforma Linux.

Além disso, uma dependência separada no tensorflow-framework biblioteca pode ser adicionado a beneficiar de um rico conjunto de utilitários para a aprendizagem de máquina baseada em TensorFlow na JVM.

Instalando com Maven

Para incluir TensorFlow em sua Maven aplicativo, adicione uma dependência de seus artefatos para o seu projeto pom.xml arquivo. 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 notar que a adição de uma dependência em um tensorflow-core-platform artefato irá importar bibliotecas nativas para todas as plataformas suportadas, o que pode aumentar significativamente o tamanho do seu projeto.

Se você deseja atingir um subconjunto das plataformas disponíveis, em seguida, você pode excluir os artefatos desnecessários de outras plataformas usando o Exclusão Maven Dependência recurso.

Outra maneira de selecionar quais as plataformas que você deseja incluir em sua aplicação é para propriedades de conjunto do sistema JavaCPP, em sua linha de comando Maven ou em seu pom.xml . Por favor, veja JavaCPP documentação para mais detalhes.

Usando instantâneos

Os últimos snapshots de desenvolvimento TensorFlow Java a partir do repositório de origem TensorFlow Java estão disponíveis no OSS Sonatype repositório Nexus. Para dependem desses artefatos, certifique-se de configurar o repositório OSS instantâneos 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 TensorFlow em sua Gradle aplicativo, adicione uma dependência de seus artefatos para o seu projeto build.gradle arquivo. 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 os plug-ins Gradle JavaCPP para reduzir esse número de dependências.

Por favor, leia a Gradle JavaCPP documentação para mais detalhes.

Instalando a partir de fontes

Para construir TensorFlow Java a partir de fontes, e, possivelmente, personalizá-lo, por favor leia as seguintes instruções .

Programa de exemplo

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

<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>

Criar 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! TensorFlow Java está configurado.