Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Instala TensorFlow para Java

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

Requisitos

TensorFlow para Java se ejecuta en Java 8 y versiones posteriores, y admite las siguientes plataformas de manera predeterminada:

  • Ubuntu 16.04 o versiones posteriores; 64 bits, x86
  • macOS 10.12.6 (Sierra) o versiones posteriores; 64 bits, x86
  • Windows 7 o versiones posteriores; 64 bits, x86

Versiones

TensorFlow para Java tiene su propio ciclo de actualización, que es independiente del entorno de ejecución de TensorFlow. En consecuencia, su versión no coincide con la versión del entorno de ejecución de TensorFlow en la que se ejecuta. Consulta la tabla de versiones de TensorFlow para Java a fin de conocer todas las versiones disponibles y su correspondencia con el entorno de ejecución de TensorFlow.

Artefactos

Existen varias formas de agregar TensorFlow para Java a tu proyecto. La más fácil es agregar una dependencia en el artefacto tensorflow-core-platform, que incluye la API principal de TensorFlow para Java y las dependencias nativas que requiere para ejecutarse en todas las plataformas compatibles.

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

  • 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 plataformas Linux y Windows

Además, se puede agregar una dependencia independiente de la biblioteca tensorflow-framework a fin de obtener beneficios de un variado conjunto de utilidades para el aprendizaje automático basado en TensorFlow en JVM.

Instalación con Maven

Para incluir TensorFlow en tu aplicación de Maven, agrega una dependencia en sus artefactos en el archivo pom.xml de tu proyecto. Por ejemplo:

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

Reducción de la cantidad de dependencias

Es importante tener en cuenta que al agregar una dependencia en un artefacto tensorflow-core-platform, se importarán bibliotecas nativas para todas las plataformas compatibles, lo que puede aumentar significativamente el tamaño de tu proyecto.

Si deseas orientarte a un subconjunto de plataformas disponibles, puedes excluir los artefactos innecesarios de otras plataformas con la función de exclusión de dependencias de Maven.

Otra forma de seleccionar qué plataformas quieres incluir en tu aplicación es configurar las propiedades del sistema JavaCPP en tu línea de comandos de Maven o en tu pom.xml. Consulta la documentación de JavaCPP para obtener más detalles.

Uso de instantáneas

Las instantáneas más recientes del desarrollo de TensorFlow para Java del repositorio de código fuente de TensorFlow para Java están disponibles en el repositorio de Nexus OSS Sonatype. Para depender de esos artefactos, asegúrate de configurar el repositorio de instantáneas de OSS en tu 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>

Instalación con Gradle

Para incluir TensorFlow en tu aplicación de Gradle, agrega una dependencia en sus artefactos en el archivo build.gradle de tu proyecto. Por ejemplo:

repositories {
    mavenCentral()
}

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

Reducción de la cantidad de dependencias

Excluir artefactos nativos de TensorFlow para Java con Gradle no es tan fácil como lo es con Maven. Te recomendamos que uses los complementos de Gradle JavaCPP a fin de reducir la cantidad de dependencias.

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

Instalación desde fuentes

Para compilar TensorFlow para Java desde fuentes, y posiblemente personalizarlo, lee las siguientes instrucciones.

Programa de ejemplo

En este ejemplo, se muestra cómo compilar un proyecto de Apache Maven con TensorFlow. Primero, agrega 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.2.0</version>
        </dependency>
    </dependencies>
</project>

Crea 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);
        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();
  }
}

Compila y ejecuta:

mvn -q compile exec:java

El comando muestra: TensorFlow version and a simple calculation.

¡Listo! TensorFlow para Java está configurado.