Installer TensorFlow Java

Tensorflow Java peut fonctionner sur une machine virtuelle Java pour la construction, la formation et le déploiement de modèles d'apprentissage de la machine. Il prend en charge à la fois l'exécution CPU et GPU, en mode graphique ou en mode avide, et présente une API riche pour l'utilisation de TensorFlow dans un environnement JVM. Java et d'autres langages JVM, tels que 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.

Conditions

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 supérieur ; 64 bits, x86
  • Windows 7 ou supérieur ; 64 bits, x86

Versions

Tensorflow Java a son propre cycle de libération, indépendant du moteur d'exécution tensorflow . Par conséquent, sa version ne correspond pas à la version de l'environnement d'exécution TensorFlow sur lequel il s'exécute. Consultez le tensorflow Java tableau versioning pour répertorier toutes les versions disponibles et leur application avec le moteur d' exécution de tensorflow.

Artefacts

Il y a plusieurs façons d'ajouter tensorflow Java à votre projet. Le plus facile est d'ajouter une dépendance à l' tensorflow-core-platform artefact, qui comprend à la fois l'API Java tensorflow de base et les dépendances natives dont il a besoin pour fonctionner sur toutes les plateformes 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 Intel® MKL-DNN sur toutes les plateformes
  • tensorflow-core-platform-gpu : Prise en charge sur les plateformes Linux CUDA ® et Windows
  • tensorflow-core-platform-mkl-gpu : Prise en charge Intel® MKL-DNN et sur la plateforme Linux CUDA ®.

En outre, une dépendance séparée sur la tensorflow-framework bibliothèque peut être ajoutée à bénéficier d'un riche ensemble d'utilitaires pour l' apprentissage de la machine à base tensorflow sur la machine virtuelle Java.

Installation avec Maven

Pour inclure tensorflow dans votre Maven application, ajoutez une dépendance à l' égard de ses artefacts à votre projet pom.xml fichier. 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 à l' égard d' une tensorflow-core-platform artéfact 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 en utilisant l' exclusion de dépendance Maven fonction.

Une autre façon de sélectionner les plates - formes que vous souhaitez inclure dans votre application est de définir les propriétés du système JavaCPP, dans votre ligne de commande Maven ou dans votre pom.xml . S'il vous plaît voir JavaCPP documentation pour plus de détails.

Utiliser des instantanés

Les derniers tensorflow instantanés Java de développement à partir du référentiel source tensorflow Java sont disponibles sur le logiciel libre Sonatype référentiel Nexus. Pour dépendre de ces artefacts, assurez - vous de configurer le référentiel de l'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 Gradle application, ajoutez une dépendance à l' égard de ses artefacts à votre projet build.gradle fichier. Par exemple,

repositories {
    mavenCentral()
}

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

Réduire le nombre de dépendances

L'exclusion 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.

S'il vous plaît lire à Gradle JavaCPP documentation pour plus de détails.

Installation à partir de sources

Pour construire tensorflow Java à partir de sources, et peut - être personnaliser, s'il vous plaît lire ce qui suit les instructions .

Exemple de programme

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

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

Compiler et exécuter :

mvn -q compile exec:java

La commande imprime la version TensorFlow et un calcul simple.

Succès! TensorFlow Java est configuré.