Se usó la API de Cloud Translation para traducir esta página.

Instalar TensorFlow Java

TensorFlow Java puede ejecutarse en cualquier JVM para la construcción, la capacitación y la implementación de modelos de aprendizaje automático. Admite la ejecución de CPU y GPU, en modo gráfico o ansioso, y presenta una API enriquecida para usar TensorFlow en un entorno JVM. Java y otros lenguajes JVM, como Scala y Kotlin, se utilizan con frecuencia en empresas grandes y pequeñas de todo el mundo, lo que convierte a TensorFlow Java en una opción estratégica para adoptar el aprendizaje automático a gran escala.

Requisitos

TensorFlow Java se ejecuta en Java 8 y versiones posteriores, y admite las siguientes plataformas listas para usar:

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

Versiones

TensorFlow Java tiene su propio ciclo de liberación, independiente del tiempo de ejecución TensorFlow . En consecuencia, su versión no coincide con la versión del tiempo de ejecución de TensorFlow en el que se ejecuta. Consultar el TensorFlow Java de versiones de mesa para listar todas las versiones disponibles y su asignación con el tiempo de ejecución TensorFlow.

Artefactos

Hay varias formas de añadir TensorFlow Java para su proyecto. La más fácil es añadir una dependencia en el tensorflow-core-platform artefacto, que incluye tanto la API de Java TensorFlow Core y las dependencias nativos que necesita para funcionar en todas las plataformas.

También puede seleccionar una de las siguientes extensiones en lugar de la versión de CPU pura:

tensorflow-core-platform-mkl : Soporte para Intel® MKL-DNN en todas las plataformas
tensorflow-core-platform-gpu : Apoyo a CUDA® en plataformas Linux y Windows
tensorflow-core-platform-mkl-gpu : Soporte para Intel® MKL-DNN y CUDA® en la plataforma Linux.

Además, una dependencia separada en la tensorflow-framework biblioteca se puede añadir a beneficio de un rico conjunto de utilidades para el aprendizaje de máquina basado en TensorFlow en la JVM.

Instalación con Maven

Para incluir en su TensorFlow Maven aplicación, agregue una dependencia de sus artefactos a su proyecto de pom.xml archivo. Por ejemplo,

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

Reducir el número de dependencias

Es importante tener en cuenta que la adición de una dependencia de un tensorflow-core-platform artefacto importará bibliotecas nativas para todas las plataformas compatibles, que pueden aumentar significativamente el tamaño de su proyecto.

Si desea dirigirse a un subconjunto de las plataformas disponibles a continuación, puede excluir los artefactos innecesarios de las otras plataformas utilizando el Exclusión Maven Dependencia función.

Otra forma de seleccionar qué plataformas que desea incluir en su aplicación es a las propiedades de conjunto del sistema JavaCPP, en su línea de comandos Maven o en su pom.xml . Por favor, vea JavaCPP la documentación para más detalles.

Usar instantáneas

Las últimas instantáneas de desarrollo TensorFlow Java desde el repositorio de código fuente de Java TensorFlow están disponibles en el OSS Sonatype repositorio de Nexus. A depender de estos artefactos, asegúrese de configurar repositorio de la OSS instantáneas en su 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>

Instalación con Gradle

Para incluir en su TensorFlow Gradle aplicación, agregue una dependencia de sus artefactos a su proyecto de build.gradle archivo. Por ejemplo,

repositories {
    mavenCentral()
}

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

Reducir el número de dependencias

Excluir artefactos nativos de TensorFlow Java con Gradle no es tan fácil como con Maven. Le recomendamos que utilice los complementos JavaCPP de Gradle para reducir esta cantidad de dependencias.

Por favor, lea en Gradle JavaCPP la documentación para más detalles.

Instalación desde fuentes

Para construir TensorFlow Java de fuentes, y, posiblemente, personalizarlo, por favor, lea las siguientes instrucciones .

Programa de ejemplo

Este ejemplo muestra cómo compilar un proyecto Apache Maven con TensorFlow. En primer lugar, añadir la dependencia a TensorFlow del proyecto pom.xml archivo:

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

Crear el archivo de origen 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 y ejecutar:

mvn -q compile exec:java

El comando imprime la versión de TensorFlow y un cálculo simple.

¡Éxito! TensorFlow Java está configurado.