CR

Document Sample
CR Powered By Docstoc
					La technique GPGPU et ses applications
Synthèse Bibliographique


1/12/2010
INSA Lyon, Département IF




Molea Cosmin (CdP)
Lucas Xavier
Martin Loïc
Sommaire
1.     Introduction ................................................................................................................................................. 3
2.     Présentation de la technique GPGPU .......................................................................................................... 4
     2.1.     Caractéristiques de la GPU et de l’architecture parallèle ....................................................................4
     2.2.     Intérêt de la technique GPGPU ............................................................................................................6
     2.3.     Les technologies GPGPU ......................................................................................................................7
3.     Principaux algorithmes utilisés dans les traitements d’image et de vidéo et leur adaptation à la GPU ... 10
     3.1.     SVM (Support Vector Machines)....................................................................................................... 10
     3.2.     KPCA (Kernel Principal Component Analysis) ................................................................................... 12
     3.3.     HOG (Histogram of Oriented Gradient) ............................................................................................ 12
     3.4.     SIFT (Scale Invariant Feature Transform) .......................................................................................... 12
     3.5.     MS (Mean Shift) ................................................................................................................................ 12
     3.6.     Graph Cuts ........................................................................................................................................ 13
4.     Applications dans l’analyse d’image .......................................................................................................... 15
     4.1.     Reconnaissance faciale ..................................................................................................................... 15
     4.2.     Classification des objets .................................................................................................................... 15
5.     Applications dans l’analyse vidéo .............................................................................................................. 16
     5.1.     Suivi en temps réel des objets dans un flux vidéo ............................................................................ 16
     5.2.     Extraction des silhouettes / Segmentation ....................................................................................... 16
6.     Conclusion .................................................................................................................................................. 17
7.     Bibliographie .............................................................................................................................................. 18




Synthèse Bibliographique - La technique GPGPU et ses applications                                                                                           Page 2
   1.          Introduction
        Les applications informatiques ont depuis toujours été évaluées en fonction de leur
« vitesse », ou autrement dit leur « temps d’exécution ». Cette caractéristique très importante des
applications dépend principalement de deux facteurs : le premier est la capacité de traitement des
équipements physiques, désignée souvent par le terme « fréquence » ; le deuxième est représenté par
la complexité des algorithmes contenus dans les applications. Chacun de ces facteurs étant soumis à
une limitation supérieure (dans le cas des équipements physiques à cause des matériaux dont ils sont
réalisés et du processus de fabrication ; dans le cas des algorithmes parce que leur complexité
représente en fait une borne supérieure rigoureusement déterminée du temps d’exécution [11]), il est
bien évident que la performance maximale en termes de vitesse des programmes sera elle aussi
limitée.
        C’est pour cette raison que toute technique qui peut rendre plus rapides une ou plusieurs
classes d’applications est très utile. Une de ces techniques, très en vogue dernièrement, fait l’objet de
la synthèse bibliographique présentée dans ce document.
        Cette technique est connue sous le nom de « GPGPU » (General Purpose computation on
Graphics Processing Units) et consiste à exécuter du code général (normalement conçu pour le CPU)
sur des cartes graphiques (GPU). L’architecture massivement parallèle de ces dernières [8] peut être
exploitée afin de réaliser des applications beaucoup plus rapides que si elles s’exécutaient sur le
CPU. Par contre, tous les algorithmes ne se prêtent pas à l’architecture parallèle des GPU parce tout
simplement il n’est pas possible de les diviser en sous-parties à faire exécuter simultanément sur la
carte graphique.
        Nous avons structuré le document de la manière suivante : dans la section 2 on va présenter
de façon plus détaillée la technique GPGPU; puis dans la section 3 on va illustrer les principaux
algorithmes utilisés dans les traitements d’image et de vidéo et leur adaptation à la GPU; ensuite,
dans les sections 4 et 5 on va présenter quelques applications basées sur cette technique.




Synthèse Bibliographique - La technique GPGPU et ses applications                                 Page 3
   2.          Présentation de la technique GPGPU
       2.1.    Caractéristiques de la GPU et de l’architecture parallèle
        Au cours des dernières années, les cartes graphiques (Graphics Processing Units) ont
beaucoup changé : initialement conçues comme des processeurs à pipeline dédiés exclusivement aux
opérations graphiques, elles ont évolué vers des processeurs plus flexibles et plus puissants
utilisables par des applications pas forcement graphiques, mais ayant besoin d’une grande capacité
de calcul [1]. Cette ouverture a permis d’obtenir des différences souvent remarquables entre les
temps d’exécution d’un même algorithme sur le GPU et sur le CPU. Le ratio d'amélioration est très
variable et dépend de l’algorithme, mais il peut aller de quelques unités jusqu’à plusieurs dizaines
d’unités en faveur de la GPU.
        A titre historique, dans les années ’90 les microprocesseurs (CPU) avaient été améliorés en
leur ajoutant des extensions multimédia (par exemple Intel MMX) qui permettaient d'accélérer
certaines opérations répétitives dans des domaines tels que le traitement du son et de l'image [11].
Les applications multimédia nécessitant de manipuler des images fixes ou animées, ces extensions
offraient des primitives optimisées et rapides pour réaliser des traitements spécifiques (par exemple
décodages d’images, zooms, corrections chromatiques gamma, additions d’images, etc.). De nos
jours, l’industrie des applications multimédia (plus particulièrement l’industrie des jeux vidéo) est
toujours celle qui pousse les producteurs de cartes graphiques à offrir des produits de plus en plus
performants et à des prix abordables [1,7].
        Pour comprendre les différences en termes de performance entre le GPU et le CPU, il faut
regarder plus en détail l’architecture de chacun d’entre eux. Le CPU est un processeur conçu pour
effectuer des opérations séquentielles et généralement variées. Son architecture (qui contient, entre
autres, une unité arithmétique et logique, un séquenceur, des registres, une unité d’entrée-sortie, une
mémoire cache) permet l’exécution de programmes divers, à caractère général.
        De l’autre côté, l’architecture du GPU a été optimisée pour effectuer une tâche bien précise :
exécuter un très grand nombre d’opérations massivement utilisées dans le domaine de la
modélisation et de l’affichage des images 3D [7,8] (multiplications matricielles, filtres de
convolution, transformation des couleurs, etc. [1]).
                                                                        L’ensemble        d'opérations
                                                                        nécessaires pour les calculs
                                                                        graphiques 3D est appelé le
                                                                        pipeline graphique [1,8]
                                                                        (représenté dans le schéma de
                                                                        gauche). Il faut préciser que
                                                                        le vertex processor et le
                                                                        fragment processor sont tous
                                                                        les deux programmables.




Synthèse Bibliographique - La technique GPGPU et ses applications                               Page 4
       Afin de comparer la vitesse des GPU avec celle des CPU, on utilise souvent une mesure
appelée FLOPS (FLoating point Operations Per Second), qu’on peut traduire en français par
opérations à virgule flottante par seconde. Bien que cette mesure ne soit pas suffisante pour
comparer les deux processeurs, elle peut quand-même donner une idée sur la puissance de calcul de
chacun d’entre eux. Il faut aussi préciser que les GPU ne supportent pas encore les opérations en
double précision [1], tandis que les CPU les supportent depuis longtemps. Dans la figure ci-dessous
on peut voir l’évolution en termes de vitesse des GPU de NVIDIA et des CPU de Intel au cours des
dernières années :




              Comparaison GPU-CPU (source : http://www.ixbt.com/video3/images/cuda/gflops.png)

        On observe que les performances graphiques des GPU augmentent plus rapidement que
celles des CPU. Ceci n’est bien évidemment pas dû à la capacité de semi-conducteurs, qui augmente
au même rythme pour les deux plates-formes (et qui est étroitement liée aux progrès de la
technologie de fabrication) [7]. La différence est par contre due aux architectures de ces deux types
de processeurs, qu’on a brièvement décrites plus haut.
        Pour être plus précis en ce qui concerne les processeurs graphiques, les GPU modernes
adoptent un schéma de traitement parallèle de type SIMD/MIMD (Single Instruction, Multiple Data /
Multiple Instruction, Multiple Data) [1]. Par exemple, dans la logique SIMD, le même jeu
d’instructions peut être exécuté simultanément sur un ensemble d’unités de traitement synchronisées,
ce qui confère un haut niveau de parallélisme [8,11]. De ce fait, seuls les algorithmes qui peuvent
être adaptés peuvent bénéficier pleinement des avantages offerts par ce type d’architecture.




Synthèse Bibliographique - La technique GPGPU et ses applications                             Page 5
       2.2.    Intérêt de la technique GPGPU
       Loïc ~2 pages




Synthèse Bibliographique - La technique GPGPU et ses applications   Page 6
       2.3.    Les technologies GPGPU
         Dans ce qui suit, nous présenterons de manière synthétique les deux Framework les plus
utilisés à ce jour : les technologies AMD Stream de ATI et CUDA de NVIDIA.
         Afin de permettre l’exploitation des extraordinaires perspectives de parallélisation, des
Framework ont été mis à la disposition des développeurs, principalement par le biais des grands
constructeurs de cartes graphiques, en particulier le constructeur américain NVIDIA et le
constructeur canadien ATI, filiale de l’américain AMD. Ces Framework ont pour principal objectif
de populariser auprès des développeurs des environnements de développement basés sur les récentes
technologies GPGPU liées aux cartes graphiques de ces constructeurs, permettant d’exécuter du
code de plus en plus générique sur une architecture très parallélisée afin d’améliorer de manière
significative le temps d’exécution.
         Tout d’abord, commençons par CUDA, probablement la technologie la plus populaire à
l’heure actuelle et très souvent citée dans les articles scientifiques traitant de la mise en place
d’algorithmes sur GPU.
                                               CUDA pour Compute Unified Device Architecture est
                                       une architecture matérielle et logicielle permettant d’apporter
                                       une réponse à la problématique d’utilisation du GPU comme
                                       périphérique de calcul avec données parallélisée pour les
                                       calculs sans la nécessité de mettre en place un mappage entre
                                       ceux-ci et l’API des cartes graphiques. CUDA est disponible
                                       pour les cartes graphiques NVIDIA des séries GeForce 8, Tesla
                                       et Quadro (selon modèle).
                                               La pile logicielle CUDA est composée de plusieurs
                                       couches comme illustré sur la figure ci-contre : le pilote
         Pile logicielle CUDA          matériel CUDA, l’Application Programming Interface (API) et
le Runtime associé, les librairies CUDA de haut niveau pour usage
standard : CUFFT et CUBLAS [12].
         Autre particularité de la technologie CUDA, celle-ci donne
accès à la possibilité d’adressage de la DRAM pour plus de flexibilité
dans la programmation comme illustré ci-contre, grâce aux possibilités
de regroupement et d’éparpillement de la mémoire. Cela a notamment
pour effet de permettre comme lors de la programmation sur CPU, de                  Opérations sur la DRAM
lire et d’écrire à quelque endroit que ce soit dans la RAM. De plus,
CUDA met à disposition une zone de mémoire partagée dont l’accès
en écriture ou en lecture est extrêmement rapide, et c’est dans une
perspective d’utilisation de cette mémoire partagée en limitant les
accès DRAM (et donc la dépendance à la bande passante DRAM
moins importante) que les résultats d’optimisation les plus pertinents
sont obtenus. Ainsi, cette zone de mémoire partagée rend les données
plus « proches » des ALU.                                                              Mémoire partagée



Synthèse Bibliographique - La technique GPGPU et ses applications                                  Page 7
       Concernant l’implémentation du code, la technologie CUDA se base sur l’utilisation de
multiprocesseurs [9, 12].
Un programme exécuté sur cette architecture utilise plusieurs éléments :
    Le block : un programme est décomposé en blocks, ceux-ci s’exécutent logiquement en
       parallèle. Construit par un développeur, un block est un groupe de thread mappé à un seul
       multiprocesseur dans lequel ils peuvent accéder à 16 Ko de mémoire partagée [9,12].
    Le warp : un warp est une chaine qui est constituée par une collection de thread qui peut
       s’exécuter de manière concurrente (sans partage de temps) sur tous les multiprocesseurs [9].
    Le kernel : il s’agit en réalité du code à exécuter par chaque Thread. L’exécutable est partagé
       entre tous les threads du système [9,12].




                   Modèle matériel                                           Groupement de thread


    Quelques chiffres clés concernant cette architecture sont disponibles ci-dessous. Ils permettent de
s’informer sur les limitations en vigueur concernant les éléments clé pour la parallélisation [9].

                       Paramètre                              Limitation   Impact
                       Multi-Processeurs par GPU                      16   Faible
                       Processeurs / Multi-Processeur                  8   Faible
                       Threads / Warp                                 32   Faible
                       Blocks / Multiprocesseur                        8   Moyen
                       Threads / Block                              512    Moyen
                       Threads / Multiprocesseur                    768     Elevé
                       Registres 32-bits / Multiprocesseur         8192     Elevé
                       Mémoire partagée / Multiproceseur         16 Ko      Elevé



Synthèse Bibliographique - La technique GPGPU et ses applications                                   Page 8
Passons maintenant au concurrent de CUDA : AMD Stream.
L’environnement proposé par ATI est le suivant :




                                              Pile logicielle
La pile logicielle mise à disposition est relativement différente de celle de CUDA [13]. Les éléments
notoires sont :
    Les compilateurs (comme Brook+)
    Le pilote de périphérique pour les processeurs Stream (AMD Compute Abstraction Layer)
    Les « performance profiling tools » comme GPU Shader Analyzer
    Les « performance Librairies » comme ACML pour des algorithmes optimisés par domaine
Le modèle utilisé pour l’implémentation possède des similarités aves CUDA :




                                    Modèle matériel et logique
        Les différences importantes sont au niveau de l’utilisation des processeurs AMD stream et
des « Thread Processors ». En effet chaque « stream processor » est composé de « thread
processors ». A l’intérieur du stream processor, un ordonnanceur s’occupe du mappage entre un
thread et un thread processeur physique. Le thread processor est composé de cœurs et de registres
ainsi que d’une interface de communication avec la mémoire [13].
        Pour ces deux technologies, les SDK mis à disposition permettent de développer des
applications en C en tentant compte des choix d’architecture pris par les constructeurs.


Synthèse Bibliographique - La technique GPGPU et ses applications                              Page 9
   3. Principaux algorithmes utilisés dans
     les traitements d’image et de vidéo et
     leur adaptation à la GPU
       3.1.    SVM (Support Vector Machines)
       L’algorithme SVM est une méthode bien connue d’apprentissage. Le but de cette méthode
d’apprentissage est de trouver un plan de décision qui maximise la marge intra-classe.
       Des classificateurs SVM ont été introduits par Vapnik et al pour lesquels les surfaces de
décision sont des hyperplans dans un espace K :



       Les paramètres de f sont dérivés d’un arbre d’apprentissage. La solution SVM correspondant
à l’hyperplan ayant la marge maximale entre les exemples d’apprentissage négatifs et positifs [1]. La
fonction de décision f (x) peut être exprimée en utilisant les m exemples d’apprentissage :



        Les coefficients             et b sont trouvés en résolvant un problème d’optimisation
quadratique. En réalité, seulement pour quelques vecteurs xi, les coefficients son non nuls. Ces
vecteurs xi déterminent la position et l’orientation de l’hyperplan et sont appelés vecteurs supports.
En remplaçant le produit interne             par                 crée des surfaces de décision non
linéaires dans l’espace de travail correspondantes aux surfaces de décisions linéaires dans un espace
caractéristique plus grand :




        Les SVM ont été mis en place avec succès pour les tâches de détection et de reconnaissance
de visages [1]. Il faut signaler que les SVM peuvent être mis en place pour les régressions non
linéaires.

   L’implémentation sur GPU d’un tel algorithme peut se faire en suivant deux lignes directrices :
    Traiter l’évaluation de noyau en parallèle : l’algorithme SVM fait une évaluation du noyau
      entre un nouvel échantillon et chacun des vecteurs supports (voir figure ci-dessous) car il n’y
      a pas de dépendance entre les différentes passes, elles peuvent être faites en parallèle



Synthèse Bibliographique - La technique GPGPU et ses applications                             Page 10
       Traiter plusieurs candidats en même temps : plutôt que de se contenter de ne partir que sur
        une région en particulier, autant essayer de partir de plusieurs régions dès le début. Cela se
        justifie notamment par le fait que le système peut traiter plusieurs exemples en parallèles, car
        les données peuvent être partagées entre elles et ne sont pas altérées par un exemple en
        particulier.

        La principale idée est donc de maximiser le bénéfice que l’on peut tirer du parallélisme des
SIMD dans l’architecture GPU. On exploite pleinement ce parallélisme quand les fonctions agissant
sur le noyau sont mappées sur le GPU.
        L’illustration ci-dessous illustre le fonctionnement d’un classificateur SVM lors de
l’implémentation sur GPU et le portage des méthodes agissant sur le noyau, sur GPU.




   Illustration du fonctionnement des SVM sur GPU            Couche de calcul pour les fonctions du noyau



Au final, l’implémentation de l’algorithme SVM sur GPU revient à un problème de rendu en deux passes [1].

       La première calcule la grille NxM de la figure de droite. L’évaluation du noyau entre le vecteur de
        test de l’i-ème instance SVM et le j-ième vecteur support est stockée à la position (i,j) dans la grille.
        Les vecteurs supports xi et leurs coefficients associés   (i=1,..,m) ont été détérminés en amont
        en utilisant l’implémentation SVM light de Thorsten Joachim’s [1] et ont été transférés dans
        la mémoire GPU sous la forme d’une texture. Les régions échantillons sont extraites du flux
        dans lequel on souhaite procéder à la classification.

       La seconde passe réalise une réduction linéaire parallélisée des résultats de la première passe.
        Chaque cellule i du vecteur à une dimension N contient alors le résultat de la classification
        SVM de l’i-ème vecteur échantillon.




Synthèse Bibliographique - La technique GPGPU et ses applications                                           Page 11
       3.2.    KPCA (Kernel Principal Component Analysis)
       Xavier ~1.5 pages


       3.3.    HOG (Histogram of Oriented Gradient)
       Loïc ~2 pages


       3.4.    SIFT (Scale Invariant Feature Transform)
       Loïc ~2 pages


       3.5.    MS (Mean Shift)
       Cosmin ~2 pages




Synthèse Bibliographique - La technique GPGPU et ses applications   Page 12
       3.6.    Graph Cuts
        L’extraction des silhouettes dans les images est une technique de bas niveau très utilisée dans
une large gamme d’applications, comme la reconstruction des modèles 3D à partir des images, le
suivi des objets dans un flux vidéo, ou l’estimation de la position et de l’orientation d’un objet
relatives à un système de coordonnées [2]. Ils existent bien sûr plusieurs algorithmes d’extraction
des silhouettes, mais dans cette section on va présenter uniquement celui connu sous le nom de
Graph Cuts (en français coupes de graphes).
        La coupe de graphes est une technique qui peut être appliquée aux problèmes de
minimisation d'énergie, fréquemment rencontrés dans les systèmes de vision par ordinateur,
notamment au problème de segmentation binaire d'images (c'est-à-dire extraction des silhouettes).
        Cette technique est en effet une solution au problème de flot maximal; ce problème
d'optimisation peut être formalisé par un graphe G=(V,E), où V représente l’ensemble des sommets
et E représente l’ensemble des arcs orientés, chaque arc ayant attribué une capacité. L’ensemble
V={s,t}∪P contient deux sommets terminaux couramment appelés s (la source) et t (le réservoir –
tank en anglais) et un ensemble de sommets non-terminaux désigné par P.
Une coupe du graphe est un partitionnement des sommets en deux sous-
ensembles disjoints notés S et T tels que s soit dans S et t soit dans T (voir
la figure ci-contre). Le capacité d’une coupe C={S,T} est la somme des
pondérations de ses arcs (c'est-à-dire des arcs (p,q) qui sont à la frontière
entre S et T, tels que p S et q T). Le théorème de Ford-Fulkerson affirme
qu’un flot maximal de s à t sature un ensemble d’arcs dans le graphe, ce
qui engendre la séparation des sommets en deux sous-ensembles disjoints
correspondant à une coupe minimale du graphe.
        En fait, les problèmes de flot maximal et de coupe minimale sont équivalents et la valeur du
flot maximal est égale à la capacité de la coupe minimale. Par la suite, on va présenter un algorithme
qui détermine le flot maximal dans un graphe et on va illustrer son adaptation à l’architecture GPU.
        Il s’agit de l’algorithme push-relabel qui est fondé autour de deux opérations principales :
décharge (en anglais push) et réétiquetage (en anglais relabel) [2]. Dans cet algorithme, chaque
sommet est soit débordé, soit inactif et a associé une hauteur et une quantité de flot en excès
variables. De même façon, chacun des arcs a associée une capacité résiduelle, elle aussi variable.
Typiquement, une queue de sommets débordés est entretenue et à chaque itération le premier
sommet de la queue est extrait et il est soit déchargé, soit réétiqueté. L'algorithme finit lorsqu’il n’y a
plus d’opérations de décharge ou de réétiquetage valides.
        La décharge d’un sommet suppose que le flot en excès (ou une partie) soit transféré aux
sommets voisins si les arcs incidents correspondants ne sont pas saturés (ont une capacité résiduelle
non nulle). L’excès du sommet courant est donc diminué de la quantité transférée et la capacité
résiduelle de l’arc le liant avec le sommet de destination est elle aussi revue à la baisse de la même
quantité. Ensuite, le sommet de destination est inséré dans la queue de sommets débordés; il en est
de même pour le sommet source s’il est toujours débordé.




Synthèse Bibliographique - La technique GPGPU et ses applications                                 Page 13
        De plus, un sommet doit être réétiqueté lorsqu’il est débordé mais il n’a plus de voisins
valides. On dit qu’un voisin est valide si sa hauteur est plus petite que celle du sommet courant et si
l’arc qui les relie a une capacité résiduelle non nulle. Pour réétiqueter un sommet, sa hauteur doit
être modifiée de façon à avoir une unité en plus par rapport à celle du voisin le plus bas, pour
permettre des décharges ultérieures.
        Afin de pouvoir implémenter cet algorithme sur le GPU, il faudra l’adapter de manière à ne
plus avoir du code divergent (branchements si-alors) qui n’est pas adéquat au modèle SIMD du
GPU. En plus, il faudra trouver des structures de données appropriées pour la représentation du
graphe en mémoire. On a choisit de représenter le graphe G=(V,E), comme une liste V de sommets
et comme une liste E d’arcs. On a groupé les arcs de façon à ce que ceux provenant d’un même
sommet soient l’un après l’autre dans la liste E . Ainsi, chaque sommet de la liste V contient un
pointeur vers le premier arc de son groupe associé, tandis que chaque arc contient des informations
concernant sa capacité, son flot courant et le sommet de destination.




Synthèse Bibliographique - La technique GPGPU et ses applications                              Page 14
   4.          Applications dans l’analyse d’image
       4.1.    Reconnaissance faciale
       Cosmin ~1 page


       4.2.    Classification des objets
       Xavier ~2 pages




Synthèse Bibliographique - La technique GPGPU et ses applications   Page 15
   5.          Applications dans l’analyse vidéo
       5.1.    Suivi en temps réel des objets dans un flux vidéo
       Loïc ~2 pages


       5.2.    Extraction des silhouettes / Segmentation
       Cosmin ~1 page




Synthèse Bibliographique - La technique GPGPU et ses applications   Page 16
   6.          Conclusion
       Cosmin ~1 page




Synthèse Bibliographique - La technique GPGPU et ses applications   Page 17
   7.          Bibliographie
       A écrire les références bibliographiques correctement !

       1. ImplementationOfKernelMethods [Cosmin]
           SVM, KPCA, Face recognition system
       2. VideoObjectSilhouetteExtraction [Cosmin]
           Graph Cuts, Silhouette extration
       3. MeanShiftParallelTrackingOnGPU [Cosmin]
           MS, Object tracking
       4. SIFTImplementationAndOptimizationForGeneral-PurposeGPU [Loïc]
           SIFT, Feature extraction, Feature-tracking with real time frame rates
       5. Efficient_Scan_Window_Based_Object_Recognition_using_GPGPU [Xavier]
           HOG, SVM, Feature extraction and classification
       6. Parallelization_convolutional_networks_object_recognition_gpu [Xavier]
           BICON, Object recognition, Classification
       7. Algorithmes_vision_temps_reel_video_surveillance_intelligente [Xavier]
           GPGPU (p.108), Face detection (p.90), Classification
       8. PerformanceEvaluationOfImageProcessing [Cosmin]
           GPU, GPGPU, CUDA
       9. BiomedicalImageAnalysisonACooperativeClusterOfGPUs [Loïc]
           GPGPU, Frameworks (CUDA)
       10. Livre : Computer Vision - ECCV 2004, Part 2
           MS
       11. Livre : Les systèmes de vision
           GPU, Architecture parallèle


                  http://fr.wikipedia.org/wiki/GFLOPS
                  http://en.wikipedia.org/wiki/Pose_%28computer_vision%29
                  http://luthuli.cs.uiuc.edu/~daf/courses/Optimization/Combinatorialpapers/Nikos-
                   Yuri-Olga.pdf




Synthèse Bibliographique - La technique GPGPU et ses applications                           Page 18

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:36
posted:10/31/2011
language:French
pages:18