Esta página se ha traducido con Cloud Translation API.

Instalar TensorFlow Java

TensorFlow Java puede ejecutarse en cualquier JVM para crear, entrenar e implementar modelos de aprendizaje automático. Admite la ejecución tanto de CPU como de 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 lanzamiento, independiente del tiempo de ejecución de TensorFlow . En consecuencia, su versión no coincide con la versión del tiempo de ejecución de TensorFlow en el que se ejecuta. Consulte la tabla de versiones de TensorFlow Java para enumerar todas las versiones disponibles y su asignación con el tiempo de ejecución de TensorFlow.

Artefactos

Hay varias formas de agregar TensorFlow Java a su proyecto. La más sencilla es agregar una dependencia en el artefacto tensorflow-core-platform , que incluye tanto la API TensorFlow Java Core como las dependencias nativas que requiere para ejecutarse en todas las plataformas compatibles.

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

tensorflow-core-platform-mkl : Compatibilidad con Intel® MKL-DNN en todas las plataformas
tensorflow-core-platform-gpu : Compatibilidad con CUDA® en plataformas Linux y Windows
tensorflow-core-platform-mkl-gpu : Compatibilidad con Intel® MKL-DNN y CUDA® en la plataforma Linux.

Además, se puede agregar una dependencia separada de la biblioteca tensorflow-framework para beneficiarse de un amplio conjunto de utilidades para el aprendizaje automático basado en TensorFlow en la JVM.

Instalación con Maven

Para incluir TensorFlow en su aplicación Maven , agregue una dependencia de sus artefactos al archivo pom.xml de su proyecto. 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 agregar una dependencia en un artefacto tensorflow-core-platform importará bibliotecas nativas para todas las plataformas compatibles, lo que puede aumentar significativamente el tamaño de su proyecto.

Si desea apuntar a un subconjunto de las plataformas disponibles, puede excluir los artefactos innecesarios de las otras plataformas utilizando la función de exclusión de dependencia de Maven .

Otra forma de seleccionar qué plataformas desea incluir en su aplicación es configurar las propiedades del sistema JavaCPP, en su línea de comando Maven o en su pom.xml . Consulte la documentación de JavaCPP para obtener más detalles.

Usando instantáneas

Las últimas instantáneas de desarrollo de TensorFlow Java del repositorio de código fuente de TensorFlow Java están disponibles en el repositorio OSS Sonatype Nexus. Para depender de estos artefactos, asegúrese de configurar el repositorio de instantáneas de OSS 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 TensorFlow en su aplicación Gradle , agregue una dependencia de sus artefactos al archivo build.gradle de su proyecto. 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 Gradle JavaCPP para reducir esta cantidad de dependencias.

Lea la documentación de Gradle JavaCPP para obtener más detalles.

Instalación desde fuentes

Para compilar TensorFlow Java a partir de fuentes y posiblemente personalizarlo, lea las siguientes instrucciones .

Programa de ejemplo

Este ejemplo muestra cómo construir un proyecto Apache Maven con TensorFlow. Primero, agregue la dependencia de TensorFlow al archivo pom.xml del proyecto:

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

Cree el archivo fuente 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.