TensorFlow-Java installieren

TensorFlow Java kann für den Aufbau, Training auf jeder JVM laufen und Modelle für maschinelles Lernen einsetzen. Es unterstützt sowohl die CPU- als auch die GPU-Ausführung im Graph- oder Eager-Modus und bietet eine umfangreiche API für die Verwendung von TensorFlow in einer JVM-Umgebung. Java und andere JVM-Sprachen wie Scala und Kotlin werden häufig in großen und kleinen Unternehmen auf der ganzen Welt verwendet, was TensorFlow Java zu einer strategischen Wahl für die Einführung von maschinellem Lernen in großem Maßstab macht.

Anforderungen

TensorFlow Java läuft auf Java 8 und höher und unterstützt standardmäßig die folgenden Plattformen:

  • Ubuntu 16.04 oder höher; 64-Bit, x86
  • macOS 10.12.6 (Sierra) oder höher; 64-Bit, x86
  • Windows 7 oder höher; 64-Bit, x86

Versionen

TensorFlow Java hat einen eigenen Release - Zyklus, unabhängig von der TensorFlow Laufzeit . Folglich stimmt seine Version nicht mit der Version der TensorFlow-Laufzeit überein, auf der es ausgeführt wird. Wenden Sie sich an TensorFlow Java Tabelle Versionierung alle Versionen mit der TensorFlow Laufzeit zur Verfügung und deren Zuordnung zu verzeichnen.

Artefakte

Es gibt mehrere Möglichkeiten , TensorFlow Java zu einem Projekt hinzuzufügen. Am einfachsten ist eine Abhängigkeit von der hinzufügen tensorflow-core-platform Artefakt, das sowohl API die TensorFlow Java Core enthält und die nativen Abhängigkeiten es auf allen unterstützten Plattformen laufen erfordert.

Statt der reinen CPU-Version können Sie auch eine der folgenden Erweiterungen wählen:

  • tensorflow-core-platform-mkl : Unterstützung für Intel® MKL-DNN auf allen Plattformen
  • tensorflow-core-platform-gpu : Unterstützung für CUDA® auf Linux und Windows - Plattformen
  • tensorflow-core-platform-mkl-gpu : Unterstützung für Intel® MKL-DNN und CUDA® auf Linux - Plattform.

Darüber hinaus ist eine separate Abhängigkeit von der tensorflow-framework kann Bibliothek profitieren von einem umfangreichen Satz von Werkzeugen für die TensorFlow-basiertes maschinelles Lernen auf der JVM hinzugefügt werden.

Installation mit Maven

Um TensorFlow in der Einschluss- Maven Anwendung, fügen Sie eine Abhängigkeit von seiner Artefakte zu Ihrem Projekt pom.xml - Datei. Zum Beispiel,

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

Reduzierung der Anzahl von Abhängigkeiten

Es ist wichtig zu beachten , dass eine Abhängigkeit von einer Zugabe von tensorflow-core-platform Artefakt native Bibliotheken für alle unterstützten Plattformen importieren, die erheblich die Größe des Projektes erhöhen.

Wenn Sie eine Teilmenge der verfügbaren Plattformen ansprechen möchten , dann können Sie die unnötigen Artefakte aus den anderen Plattformen schließen die Verwendung von Maven Dependency Ausschluss - Funktion.

Eine weitere Möglichkeit , zu wählen , welche Plattformen Sie in Ihrer Anwendung enthalten sein sollen ist zu Satz JavaCPP Systemeigenschaften in Ihrem Maven Befehlszeile oder in Ihrem pom.xml . Bitte beachten Sie JavaCPP Dokumentation für weitere Details.

Verwenden von Schnappschüssen

Die neuesten TensorFlow Java Entwicklung Schnappschüsse von dem TensorFlow Java - Quellcode - Repository sind auf der verfügbare OSS Sonatype Nexus - Repository. Um auf diesen Artefakte hängen, stellen Sie sicher , dass die OSS - Snapshots Repository in Ihrem konfigurieren 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 mit Gradle

Um TensorFlow in der Einschluss- Gradle Anwendung, eine Abhängigkeit von seinen hinzufügen Artefakte zu Ihrem Projekt build.gradle Datei. Zum Beispiel,

repositories {
    mavenCentral()
}

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

Reduzierung der Anzahl von Abhängigkeiten

Das Ausschließen nativer Artefakte aus TensorFlow Java mit Gradle ist nicht so einfach wie mit Maven. Wir empfehlen, dass Sie Gradle JavaCPP-Plugins verwenden, um diese Anzahl von Abhängigkeiten zu reduzieren.

Bitte lesen Sie bei Gradle JavaCPP Dokumentation für weitere Details.

Von Quellen installieren

TensorFlow Java aus Quellen und möglicherweise anpassen es, lesen Sie bitte die folgenden bauen Anweisungen .

Beispielprogramm

Dieses Beispiel zeigt, wie Sie ein Apache Maven-Projekt mit TensorFlow erstellen. Fügen Sie zunächst die TensorFlow Abhängigkeit zu dem wichtigsten Projekt pom.xml - Datei:

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

Erstellen Sie die Quelldatei 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();
  }
}

Kompilieren und ausführen:

mvn -q compile exec:java

Der Befehl druckt die TensorFlow-Version und eine einfache Berechnung.

Erfolg! TensorFlow-Java ist konfiguriert.