Cette page a été traduite par l'API Cloud Translation.

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 d'apprentissage automatique. Il prend en charge l'exécution CPU et GPU, en mode graphique ou impatient, et présente une API riche pour utiliser TensorFlow dans un environnement JVM. Java et d'autres langages JVM, comme Scala et Kotlin, sont fréquemment utilisés dans les grandes et petites entreprises du monde entier, ce qui fait de TensorFlow Java un choix stratégique pour adopter l'apprentissage automatique à grande échelle.

Exigences

TensorFlow Java s'exécute sur Java 8 et versions ultérieures et prend en charge les plates-formes suivantes :

Ubuntu 16.04 ou supérieur ; 64 bits, x86
macOS 10.12.6 (Sierra) ou version ultérieure ; 64 bits, x86
Windows 7 ou supérieur ; 64 bits, x86

Versions

TensorFlow Java possède son propre cycle de publication, indépendant du runtime TensorFlow . Par conséquent, sa version ne correspond pas à la version du runtime TensorFlow sur lequel il s'exécute. Consultez le tableau de versionnage TensorFlow Java pour répertorier toutes les versions disponibles et leur mappage avec le runtime TensorFlow.

Artefacts

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

Vous pouvez également sélectionner l'une des extensions suivantes au lieu de la version CPU pure :

tensorflow-core-platform-mkl : Prise en charge d'Intel® MKL-DNN sur toutes les plateformes
tensorflow-core-platform-gpu : Prise en charge de CUDA® sur les plateformes Linux et Windows
tensorflow-core-platform-mkl-gpu : Prise en charge d'Intel® MKL-DNN et CUDA® sur la plateforme Linux.

De plus, une dépendance distincte sur la bibliothèque tensorflow-framework peut être ajoutée pour bénéficier d'un riche ensemble d'utilitaires pour l'apprentissage automatique basé sur TensorFlow sur la JVM.

Installation avec Maven

Pour inclure TensorFlow dans votre application Maven , ajoutez une dépendance sur ses artefacts au fichier pom.xml de votre projet. Par exemple,

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

Réduire le nombre de dépendances

Il est important de noter que l'ajout d'une dépendance sur un artefact tensorflow-core-platform importera des bibliothèques natives pour toutes les plates-formes prises en charge, ce qui peut augmenter considérablement la taille de votre projet.

Si vous souhaitez cibler un sous-ensemble des plates-formes disponibles, vous pouvez exclure les artefacts inutiles des autres plates-formes à l'aide de la fonctionnalité d'exclusion de dépendances Maven .

Une autre façon de sélectionner les plates-formes que vous souhaitez inclure dans votre application consiste à définir les propriétés du système JavaCPP, dans votre ligne de commande Maven ou dans votre pom.xml . Veuillez consulter la documentation JavaCPP pour plus de détails.

Utiliser des instantanés

Les derniers instantanés de développement TensorFlow Java du référentiel source TensorFlow Java sont disponibles sur le référentiel OSS Sonatype Nexus. Pour dépendre de ces artefacts, assurez-vous de configurer le référentiel d'instantanés OSS dans votre 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>

Installation avec Gradle

Pour inclure TensorFlow dans votre application Gradle , ajoutez une dépendance sur ses artefacts au fichier build.gradle de votre projet. Par exemple,

repositories {
    mavenCentral()
}

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

Réduire le nombre de dépendances

Exclure des artefacts natifs de TensorFlow Java avec Gradle n'est pas aussi simple qu'avec Maven. Nous vous recommandons d'utiliser les plugins Gradle JavaCPP pour réduire ce nombre de dépendances.

Veuillez lire la documentation Gradle JavaCPP pour plus de détails.

Installation à partir des sources

Pour créer TensorFlow Java à partir de sources et éventuellement le personnaliser, veuillez lire les instructions suivantes.

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.3.3</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);
        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();
  }
}

Compilez et exécutez :

mvn -q compile exec:java

La commande imprime la version TensorFlow et un calcul simple.

Succès! TensorFlow Java est configuré.