Je souhaite obtenir des informations sur une formation complète concernant le thème DIVI dispensé
par un organisme de formation certifié par l’état.
Que la formation soit finançable par mon CPF (idéalement) ou autre


TensorFlow Java peut s’exécuter sur n’importe quelle machine virtuelle Java pour créer, former et déployer des modèles d’apprentissage automatique. Il prend en charge à la fois l’exécution du processeur et du GPU en mode graphique ou en mode impatient et dispose d’une API riche pour utiliser TensorFlow dans un environnement JVM. Java et d’autres langages JVM tels que Scala et Kotlin sont largement utilisés dans les grandes et petites entreprises du monde entier, ce qui fait de TensorFlow Java un choix stratégique pour l’adoption de l’apprentissage automatique à grande échelle.

exigence

TensorFlow Java s’exécute sur Java 8 et versions ultérieures et prend immédiatement 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 publication, indépendant de
Runtime TensorFlow. Par conséquent, la version ne correspond pas à la version de l’environnement d’exécution TensorFlow sur lequel elle s’exécute. Contactez TensorFlow Java
Tableau des versions
pour répertorier toutes les versions disponibles et leur affectation avec le runtime TensorFlow.

Artefacts

Il y a
différentes façons pour ajouter TensorFlow Java à votre projet. Il est plus facile de dépendre du
tensorflow-core-platform Artefact contenant à la fois l’API TensorFlow Java Core et les dépendances natives requises pour s’exécuter sur toutes les plates-formes prises en charge.

Au lieu de la version CPU pure, vous pouvez également choisir l’une des extensions suivantes:

  • tensorflow-core-platform-mkl: Prise en charge d’Intel® MKL-DNN sur toutes les plates-formes
  • tensorflow-core-platform-gpu: Prise en charge de CUDA® sur les plates-formes Linux et Windows
  • tensorflow-core-platform-mkl-gpu: Prise en charge d’Intel® MKL-DNN et CUDA® sur les plates-formes Linux.

De plus, il existe une dépendance distincte sur le tensorflow-framework La bibliothèque peut être ajoutée pour tirer parti de divers utilitaires d’apprentissage automatique basés sur TensorFlow dans la JVM.

Installation avec Maven

Comment ajouter TensorFlow à votre Maven Application, ajoutez une dépendance à son Artefacts à votre projet pom.xml Déposer. Par example,

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

Réduisez le nombre de dépendances

Il est important de noter que l’ajout d’une dépendance à un tensorflow-core-platform
Artifact importe 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 utiliser l’option pour exclure les artefacts inutiles des autres plates-formes
Exclusion de dépendance Maven
Fonctionnalité.

Une autre façon de choisir les plateformes à inclure dans votre application consiste à définir les propriétés système JavaCPP sur votre ligne de commande Maven ou sur la vôtre
pom.xml. Veuillez noter JavaCPP
Documentation
pour plus de détails.

Utilisation des instantanés

Les derniers instantanés de développement Java TensorFlow du référentiel source Java TensorFlow sont disponibles sur le site Web Type de sona OSS Dépôt Nexus. Pour être dépendant de ces artefacts, vous devez 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

Comment ajouter TensorFlow à votre Gradle Application, ajoutez une dépendance à son Artefacts à votre projet build.gradle Déposer. Par example,

repositories {
    mavenCentral()
}

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

Réduisez 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 à Gradle JavaCPP
Documentation pour plus de détails.

Installation à partir des sources

Lisez ce qui suit pour créer et éventuellement personnaliser TensorFlow Java à partir des sources
Manuel.

Exemple de programme

Cet exemple montre comment utiliser TensorFlow pour créer un projet Apache Maven. Tout d’abord, ajoutez la dépendance TensorFlow aux projets pom.xml Déposer:

<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.1</version>
        </dependency>
    </dependencies>
</project>

Construisez 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 de TensorFlow et un calcul simple.

Succès! TensorFlow Java est configuré.



Source link

Recent Posts