:orphan:

|rss_image|  **références - 1/1** :ref:`Blog <ap-main-0>` :ref:`references (4) <ap-cat-references-0>`

.. |rss_image| image:: feed-icon-16x16.png
    :target: ../_downloads/rss.xml
    :alt: RSS

----


.. index:: références


.. _ap-cat-references-0:

références - 1/1
++++++++++++++++

.. blogpostagg::
    :title: GraphFrames
    :date: 2018-12-29
    :keywords: spark
    :categories: références
    :rawfile: 2018/2018-12-29_graph.rst

    Les graphes sont toujours compliqués en MapReduce,
    `GraphFrames <https://graphframes.github.io/index.html>`_.
    Ca n'a pas l'air trop mal
    `A Gentle Intro To Graph Analytics With GraphFrames <https://www.jowanza.com/blog/a-gentle-intro-to-graph-analytics-with-graphframes>`_
    mais il est difficile de comprendre en quoi la solution
    se distingue d'un `neo4j <https://neo4j.com/>`_.
    En fait, je ne suis pas sûr que ce type de solution permettent
    de résoudre tous les problèmes. Le coût réseau
    `Groute performance vs. Gunrock <https://gunrock.github.io/docs/groute.html>`_
    est très important pour les graphes car il faut pouvoir accéder
    à n'importe quelle partie. Je crois plutôt à des grosses machines
    avec pas mal de coeurs et des librairies écrites en C++.
    Je m'interroge sur des trucs de ce style
    `Charm++ <http://charm.cs.illinois.edu/research/charm>`_ ou
    `Presto: Distributed Machine Learning and Graph Processing with Sparse Matrices <http://shivaram.org/publications/presto-eurosys13.pdf>`_.
    Un autre article
    `High-Level Programming Abstractions for Distributed Graph Processing <https://arxiv.org/pdf/1607.02646.pdf>`_
    à lire sans doute (ça aussi `MapReduce formulation of PageRank <http://maartenfokkinga.github.io/utwente/mmf2010e.pdf>`_)
    `Lemon <https://lemon.cs.elte.hu/trac/lemon>`_.
    J'ai trouvé ça aussi
    `teexgraph <https://github.com/franktakes/teexgraph>`_ mais
    le code n'a pas l'air terrible (double, pas float et autres défauts).
    Bref, pour les très gros graphes, la ruse
    a encore quelques beaux jours.




.. blogpostagg::
    :title: Références sur scala
    :date: 2018-04-16
    :keywords: scala
    :categories: références
    :rawfile: 2018/2018-04-16_scala.rst

    Anglais
    
    * `Scala Documentation <https://docs.scala-lang.org/tutorials/tour/pattern-matching.html.html>`_
    
    Français
    
    * `Apprenez la programmation avec Scala <https://openclassrooms.com/courses/apprenez-la-programmation-avec-scala/classes-et-variables>`_
    * `Travaux pratiques - Introduction à Spark et Scala <http://cedric.cnam.fr/vertigo/Cours/RCP216/tpSparkScala.html>`_




.. blogpostagg::
    :title: Streaming et pipelines
    :date: 2018-04-10
    :keywords: streaming,pipelines
    :categories: références
    :rawfile: 2018/2018-04-10_awesome.rst

    Deux pages qui recensent de nombreuses libraires
    qui permettent de créer des pipelines et plus
    généralement de traiter les données en parallèles :
    

    ...




.. blogpostagg::
    :title: Sujets abordés en introduction à Spark
    :date: 2018-04-09
    :keywords: spark,programmation fonctionnelle
    :categories: références
    :rawfile: 2018/2018-04-09_session1.rst

    *Partie 1 : programmation fonctionnelle*
    
    * notion de
      :func:`map <sparkouille.fctmr.simplefctmr.mapper>`,
      :func:`filter <sparkouille.fctmr.simplefctmr.ffilter>`,
      :func:`reduce <sparkouille.fctmr.simplefctmr.mapper>` (group by),
      :func:`combine <sparkouille.fctmr.simplefctmr.combiner>` (ou join)
    * exemple détailler avec un mapper, suivi d'un reducer, suivi d'un mapper
    * pourquoi trier localement pour un reducer
    * coûts associés (calcul + mémoire) pour les quatre
      primitives pour une exécution locale dans deux cas :
      parcourir la liste complète, obtenir le premier élément
    * pourquoi la programmation fonctionnelle est adaptée
      à la distribution des calculs
    * stratégie de distribution
    * coûts associés (calcul + mémoire) pour les quatre
      primitives pour une exécution locale dans deux cas :
      parcourir la liste complète, obtenir le premier élément
    * notion de reducer récursif : cas de la somme et de la moyenne
    * introduction des termes : lazy evaluation, index
    * notebook :ref:`recursivereducersrst`
    
    *Partie 2 : exemples et Spark*
    
    * Enlever les doublons dans une base de données
      (code postal, nom, téléphone), sont considérés comme doublons
      deux entités qui ont au moins deux champs en commun (sur trois)
    * lien vers installation en local : :ref:`l-install-spark`
    * exécution de :ref:`sparkfirststepsrst`
    
    Enfin, quelques lignes sur :
    

    ...





----

|rss_image|  **références - 1/1** :ref:`2018-04 (4) <ap-month-2018-04-0>` :ref:`2018-12 (1) <ap-month-2018-12-0>`