Zainstaluj Javę TensorFlow

TensorFlow Java może działać na dowolnej maszynie JVM w celu budowania, trenowania i wdrażania modeli uczenia maszynowego. Obsługuje wykonanie zarówno procesora, jak i procesora graficznego, w trybie graficznym lub chętnym i przedstawia bogate API do korzystania z TensorFlow w środowisku JVM. Java i inne języki JVM, takie jak Scala i Kotlin, są często używane w dużych i małych przedsiębiorstwach na całym świecie, co sprawia, że ​​TensorFlow Java jest strategicznym wyborem przy wdrażaniu uczenia maszynowego na dużą skalę.

Wymagania

TensorFlow Java działa na Javie 8 i nowszych i od razu obsługuje następujące platformy:

  • Ubuntu 16.04 lub nowszy; 64-bitowy, x86
  • macOS 10.12.6 (Sierra) lub nowszy; 64-bitowy, x86
  • Windows 7 lub nowszy; 64-bitowy, x86

Wersje

TensorFlow Java ma swój własny cykl wydawniczy, niezależny od środowiska wykonawczego TensorFlow . W związku z tym jego wersja nie jest zgodna z wersją środowiska wykonawczego TensorFlow, na którym działa. Zapoznaj się z tabelą wersji TensorFlow Java, aby wyświetlić listę wszystkich dostępnych wersji i ich mapowania w środowisku wykonawczym TensorFlow.

Artefakty

Istnieje kilka sposobów dodania języka Java TensorFlow do projektu. Najłatwiej jest dodać zależność od artefaktu tensorflow-core-platform , który obejmuje zarówno interfejs API TensorFlow Java Core, jak i natywne zależności wymagane do działania na wszystkich obsługiwanych platformach.

Zamiast wersji z czystym procesorem możesz także wybrać jedno z następujących rozszerzeń:

  • tensorflow-core-platform-mkl : obsługa Intel® MKL-DNN na wszystkich platformach
  • tensorflow-core-platform-gpu : obsługa CUDA® na platformach Linux i Windows
  • tensorflow-core-platform-mkl-gpu : obsługa Intel® MKL-DNN i CUDA® na platformie Linux.

Ponadto można dodać osobną zależność od biblioteki tensorflow-framework aby skorzystać z bogatego zestawu narzędzi do uczenia maszynowego opartego na TensorFlow na JVM.

Instalacja za pomocą Mavena

Aby uwzględnić TensorFlow w aplikacji Maven , dodaj zależność od jego artefaktów do pliku pom.xml projektu. Na przykład,

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

Zmniejszenie liczby zależności

Należy pamiętać, że dodanie zależności od artefaktu tensorflow-core-platform spowoduje zaimportowanie bibliotek natywnych dla wszystkich obsługiwanych platform, co może znacznie zwiększyć rozmiar projektu.

Jeśli chcesz kierować reklamy na podzbiór dostępnych platform, możesz wykluczyć niepotrzebne artefakty z innych platform, korzystając z funkcji wykluczenia zależności Maven .

Innym sposobem wybrania platform, które chcesz uwzględnić w swojej aplikacji, jest ustawienie właściwości systemu JavaCPP w wierszu poleceń Mavena lub w pliku pom.xml . Więcej szczegółów można znaleźć w dokumentacji JavaCPP.

Korzystanie z migawek

Najnowsze migawki programistyczne Java TensorFlow z repozytorium źródłowego TensorFlow Java są dostępne w repozytorium OSS Sonatype Nexus. Aby polegać na tych artefaktach, pamiętaj o skonfigurowaniu repozytorium migawek OSS w pliku 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>

Instalacja za pomocą Gradle

Aby uwzględnić TensorFlow w aplikacji Gradle , dodaj zależność od jego artefaktów do pliku build.gradle projektu. Na przykład,

repositories {
    mavenCentral()
}

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

Zmniejszenie liczby zależności

Wykluczanie natywnych artefaktów z TensorFlow Java za pomocą Gradle nie jest tak proste, jak w przypadku Mavena. Zalecamy użycie wtyczek Gradle JavaCPP, aby zmniejszyć tę liczbę zależności.

Więcej szczegółów można znaleźć w dokumentacji Gradle JavaCPP.

Instalacja ze źródeł

Aby zbudować Javę TensorFlow ze źródeł i ewentualnie ją dostosować, przeczytaj poniższe instrukcje .

Przykładowy program

Ten przykład pokazuje, jak zbudować projekt Apache Maven za pomocą TensorFlow. Najpierw dodaj zależność TensorFlow do pliku pom.xml projektu:

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

Utwórz plik źródłowy 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();
  }
}

Skompiluj i wykonaj:

mvn -q compile exec:java

Polecenie wypisuje wersję TensorFlow i proste obliczenia.

Sukces! Java TensorFlow jest skonfigurowana.