Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Responsable Qt & Livres


    Avatar de dourouc05
    Homme Profil pro
    Ingénieur de recherche
    Inscrit en
    août 2008
    Messages
    23 688
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur de recherche
    Secteur : Enseignement

    Informations forums :
    Inscription : août 2008
    Messages : 23 688
    Points : 149 037
    Points
    149 037

    Par défaut Julia se lance maintenant sur les TPU de Google

    Les processeurs tensoriels de Google parlent maintenant Julia,
    XLA.jl est une manière très simple de lancer ses calculs sur un TPU

    Google avait quelque peu étonné en annonçant qu'il développait ses propres processeurs : plus précisément, des accélérateurs pour les réseaux neuronaux, dénommés TPU (tensor processing unit). La première génération s'est limitée à l'inférence, la deuxième s'est étendue vers l'apprentissage de ces réseaux neuronaux, en apportant des avantages en performance brute et, surtout, en efficacité énergétique par rapport aux processeurs graphiques. Google est en train d'ouvrir l'accès à ce matériel par le biais de sa plateforme infonuagique, mais reste la difficulté de programmer ces processeurs très spécifiques. Pour cela, Google a déjà proposé son compilateur XLA, spécifique à TensorFlow. Il se focalise sur les opérations d'algèbre linéaire utilisées dans TensorFlow et cible plusieurs types de processeurs (les x86 traditionnels, les cartes graphiques NVIDIA par le truchement de CUDA, mais aussi les TPU).

    Julia, au contraire, est un langage de programmation orienté performance, d'abord prévu pour le calcul scientifique (et donc l'algèbre linéaire), mais qui s'est vite étendu notamment à l'apprentissage automatique et à l'apprentissage profond en particulier. Le langage est aussi construit autour du choix précis de la fonction à appeler : les types de tous les arguments sont pris en compte pour spécialiser un maximum le code (et donc augmenter sa performance). Ce système permet, notamment, d'interagir avec les TPU sans difficulté : il suffit de définir des tableaux d'un type spécifique (qui indique que ces données doivent être hébergées sur un TPU et les calculs doivent y être effectués), le reste se passe automatiquement. Ainsi, le moteur d'exécution transfère les données au bon endroit, les rapatrie en cas de besoin. L'utilisateur ne voit pas les détails d'implémentation, ni le lien avec le compilateur XLA et son langage HLO.



    En guise de tests, les développeurs de XLA.jl (le lien entre Julia et le compilateur XLA) se sont bien évidemment lancés dans des réseaux neuronaux, l'architecture VGG19 en particulier (utilisée dans la reconnaissance d'images). Pour ce faire, ils ont utilisé les paquets Julia Flux.jl (réseaux neuronaux) et Zygote.jl (différentiation automatique). En termes de performance, le résultat est intéressant. Ils ont comparé leur solution à l'utilisation de Flux.jl pure sur vingt cœurs (Intel Xeon Silver 4114, 2,20 GHz), à une implémentation équivalente avec PyTorch sur le même processeur, à leur solution simulée (avec un simulateur de TPU fonctionnant sur le même processeur), ainsi qu'à leur solution sur un vrai TPU (en séparant les temps en calcul pur et en temps total — entre l'émission du premier octet vers le TPU à travers Google Cloud et la réception des résultats).


    Et dans le code ? Les changements sont minimes : il suffit d'ouvrir une session avec Google Cloud et d'annoter le code avec une macro (@tpu) et les calculs s'y lancent.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    using XLA
    using Metalhead
    using Flux
    using TensorFlow
    
    # Création du réseau neuronal.
    ic = ImmutableChain(filter(x->!isa(x, Flux.Dropout), VGG19().layers.layers)...)
    
    # Connexion à un TPU distant.
    sess = Session(Graph(); target="grpc://localhost:8470")
    run(sess, TensorFlow.Ops.configure_distributed_tpu())
    
    # Génération des données. 
    x = rand(Float32, 224, 224, 3, 1)
    
    # Lancement du calcul. 
    @tpu ic(x)
    Plus d'informations : Automatic Full Compilation of Julia Programs and ML Models to Cloud TPUs.

    Source : Google Cloud TPUs Now Speak Julia.

    Et vous ?

    Qu'en pensez-vous ?
    Vous souhaitez participer aux rubriques Qt ou PyQt (tutoriels, FAQ, traductions), HPC ? Contactez-moi par MP.

    Créer des applications graphiques en Python avec PyQt5
    Créer des applications avec Qt 5.

    Pas de question d'ordre technique par MP !

  2. #2
    Membre éclairé
    Avatar de Madmac
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    juin 2004
    Messages
    643
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Alimentation

    Informations forums :
    Inscription : juin 2004
    Messages : 643
    Points : 880
    Points
    880
    Billets dans le blog
    1

    Par défaut

    Cela me semble assez logique, les concepteurs du langage ont plus puisé beaucoup dans le Fortran et le Modula.
    intel i7
    OpenSuse Leap 42.2
    Plasma et Cinnamon

  3. #3
    Membre expérimenté
    Homme Profil pro
    Développeur informatique
    Inscrit en
    avril 2017
    Messages
    416
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2017
    Messages : 416
    Points : 1 712
    Points
    1 712

    Par défaut

    D'où tu sors cette info ?
    Dans le code de Julia, il n'y a pas de fortran ni de modula (https://github.com/JuliaLang/julia), la doc officielle ne dit rien de cela (https://docs.julialang.org/en/v1/) et wikipédia non plus (https://en.wikipedia.org/wiki/Julia_...ng_language%29) :
    Influenced by
    C[4] Lisp[4] Lua[9] Mathematica[4] (strictly its Wolfram Language[4][10]) MATLAB[4] Perl[9] Python[9] R[4] Ruby[9] Scheme[11]

Discussions similaires

  1. Google : bientôt des connexions SSL obligatoires sur les API de Google
    Par Idelways dans le forum Général Conception Web
    Réponses: 0
    Dernier message: 21/03/2011, 15h40
  2. [INDEX] Maintenance sur les indexes
    Par guigui_cwoco dans le forum Oracle
    Réponses: 1
    Dernier message: 13/03/2007, 09h13
  3. [RSS] Questions diverses sur les flux RSS (Google et phpBB)
    Par leserapheen dans le forum XML/XSL et SOAP
    Réponses: 1
    Dernier message: 06/10/2006, 15h35
  4. Réponses: 9
    Dernier message: 15/05/2006, 12h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo