Installer TensorFlow Java

TensorFlow Java peut s'exécuter sur n'importe quelle JVM pour créer, entraîner et déployer des modèles de machine learning. Compatible avec les processeurs et les GPU, que ce soit en mode graphique ou en mode rapide, TensorFlow Java propose une API riche qui permet d'utiliser TensorFlow dans un environnement JVM. Java et d'autres langages JVM, comme Scala et Kotlin, sont souvent utilisés dans de grandes et petites entreprises du monde entier, ce qui fait de TensorFlow Java un choix stratégique pour l'intégration à grande échelle du machine learning.

Attention : L'API TensorFlow Java n'est pas couverte par les Garanties de stabilité de l'API TensorFlow.

Exigences

TensorFlow Java s'exécute sur Java 8 et versions ultérieures et fonctionne sans configuration supplémentaire avec les plates-formes suivantes :

• Ubuntu 16.04 ou version ultérieure (64 bits et x86)
• macOS 10.12.6 (Sierra) ou version ultérieure (64 bits et x86)
• Windows 7 ou version ultérieure (64 bits et x86)

Remarque : Pour utiliser TensorFlow sur Android, consultez la page TensorFlow Lite*.

Versions

TensorFlow Java dispose de son propre cycle de publication, qui est indépendant de celui de TensorFlow. Par conséquent, sa version ne correspond pas à celle de l'environnement d'exécution TensorFlow dans lequel elle s'exécute. Consultez le tableau des versions de TensorFlow Java pour obtenir la liste de toutes les versions disponibles ainsi que leur mappage avec celles de l'environnement d'exécution TensorFlow.

Artefacts

Il existe plusieurs façons d'ajouter TensorFlow Java à votre projet. La plus simple consiste à ajouter une dépendance à l'artefact tensorflow-core-platform, qui comprend à la fois l'API Core TensorFlow Java et les dépendances natives dont elle a besoin pour s'exécuter sur toutes les plateformes compatibles.

Outre la version pour processeur uniquement, vous pouvez choisir l'une des extensions suivantes :

• tensorflow-core-platform-mkl : compatibilité avec la bibliothèque Intel® MKL-DNN sur toutes les plates-formes
• tensorflow-core-platform-gpu : compatibilité avec la bibliothèque CUDA® sur les plates-formes Linux et Windows
• tensorflow-core-platform-mkl-gpu : compatibilité avec les bibliothèques Intel® MKL-DNN et CUDA® sur les plateformes Linux et Windows

Vous pouvez également ajouter une dépendance supplémentaire à la bibliothèque tensorflow-framework pour bénéficier d'un ensemble complet d'utilitaires pour le machine learning basé sur TensorFlow dans l'environnement JVM.

Installer avec Maven

Pour utiliser TensorFlow dans votre application Maven, ajoutez une dépendance à ses artefacts dans le fichier pom.xml de votre projet. Exemple :

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

Réduire le nombre de dépendances

Il est important de noter que l'ajout d'une dépendance à un artefact tensorflow-core-platform entraînera l'importation de bibliothèques natives pour toutes les plateformes compatibles, ce qui peut augmenter considérablement la taille de votre projet.

Pour cibler seulement un sous-ensemble des plates-formes disponibles, vous pouvez exclure les artefacts superflus provenant des autres plates-formes à l'aide de la fonctionnalité Exclusion des dépendances Maven.

Pour sélectionner les plates-formes que vous souhaitez inclure à votre application, vous pouvez également définir les propriétés du système JavaCPP dans votre ligne de commande Maven ou dans votre fichier pom.xml. Pour plus d'informations, reportez-vous à la documentation de JavaCPP.

Utiliser Snapshots

Les derniers instantanés de développement du dépôt source de TensorFlow Java sont disponibles sur le dépôt Nexus Sonatype OSS. Pour utiliser ces artefacts comme dépendances, veillez à configurer le dépôt OSS Snapshots dans votre fichier 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>

Installer avec Gradle

Pour utiliser TensorFlow dans votre application Gradle, ajoutez une dépendance à ses artefacts au fichier build.gradle de votre projet. Exemple :

repositories {
    mavenCentral()
}

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

Réduire le nombre de dépendances

Exclure les artefacts natifs de TensorFlow Java avec Gradle n'est pas aussi facile qu'avec Maven. Nous vous recommandons d'utiliser les plug-ins JavaCPP de Gradle pour réduire le nombre des dépendances.

Pour plus d'informations, reportez-vous à la documentation Gradle JavaCPP.

Installer à partir de la source

Pour compiler TensorFlow Java à partir de la source et éventuellement personnaliser sa configuration, veuillez consulter ces instructions.

Remarque : Seules les versions officielles de TensorFlow sont prises en charge par ses développeurs. Toute compilation personnalisée est au seul risque de l'utilisateur*.

Exemple de programme

Cet exemple montre comment créer un projet Apache Maven avec TensorFlow. Tout d'abord, ajoutez la dépendance TensorFlow au fichier pom.xml du projet :

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

Créez le fichier source 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();
  }
}

Compilez et exécutez :

mvn -q compile exec:java

La commande affiche : TensorFlow version and a simple calculation.

Opération réussie. TensorFlow Java est désormais configuré.