Ce support sur le framework Apache Spark vous permet d’apprendre à développer des applications en Python en vous appuyant sur l’analyse et le traitement de données volumineuses ainsi que sur la notion d’apprentissage automatique.

Après quelques définitions de termes liés au domaine de la data, vous découvrez les fondements de Spark. Vous appréhendez l’architecture logicielle du framework, ses composants et les différents langages avec lesquels il est possible de développer.

Vous entrez ensuite concrètement dans la transformation de données. Fonctions numériques, alphanumériques, ajouts d’information, suppressions, agrégations de premier ordre et plus complexes sont à l’honneur. Des fonctionnalités plus avancées telles que les fonctions de fenêtrage et celles définies par les utilisateurs sont étudiées et les nombreuses API de Spark parcourues, tout en étant illustrées par des exemples.

Dans la suite du support, l’auteur dévoile l’apprentissage machine. Apprentissage supervisé, non supervisé, profond et moteurs de recommandation sont autant de concepts détaillés. Vous découvrez les différents algorithmes présents dans Spark, les manières de préparer des données à l’entraînement ainsi que les possibilités d’évaluation d’un système prédictif au travers de plusieurs mises en pratique. Les notions d’arbres de décision, de forêts aléatoires, de réseaux de neurones, de régressions linéaires et de factorisation de matrices vous sont expliquées ainsi que le traitement des informations numériques et la vectorisation de textes.

Pour finir, un chapitre met en avant l’industrialisation de Spark. Déployer, déboguer et tester son application ainsi que les subtilités de l’outil pour assurer une performance optimale sont autant d’éléments cruciaux détaillés.

Si les exemples de code du support sont en Python, langage aujourd’hui le plus utilisé avec Spark, certains sont en Scala, API la plus aboutie, pour vous apporter une vision complète du framework.

Téléchargements

• Des fichiers complémentaires (228 Ko)

Le framework Spark et ses rouages

1. 1. Concepts et composants
   1. 1.1 Définition
   2. 1.2 Histoire de Spark
   3. 1.3 Le big data (mégadonnées)
   4. 1.4 L’analyse de données
   5. 1.5 L'apprentissage automatique
   6. 1.6 Le temps réel
   7. 1.7 Langages
   8. 1.8 Composants
2. 2. Démarrer avec Spark
   1. 2.1 Installation sur une machine versus installation sur un cluster
   2. 2.2 Solutions on-premise (sur site)
   3. 2.3 Solutions cloud (nuage informatique)
   4. 2.4 Paramétrer l'interface Databricks pour tester Spark
   5. 2.5 Étendre Spark avec des paquets
   6. 2.6 Un premier code Spark
3. 3. Un framework distribué
   1. 3.1 Le concept de distribution
   2. 3.2 Les raisons de la distribution
      1. 3.2.1 Élasticité horizontale
      2. 3.2.2 Répartition géographique des données
      3. 3.2.3 Tolérance aux pannes
   3. 3.3 Distribution des données
   4. 3.4 Distribution des calculs
   5. 3.5 Distribution dans Spark
4. 4. Les types d’exécution de Spark
   1. 4.1 Exécuter Spark
   2. 4.2 Exécuter Spark en mode local
   3. 4.3 Exécuter Spark en mode client
   4. 4.4 Exécuter Spark en mode cluster
5. 5. Le mode de fonctionnement interne
   1. 5.1 Les stages et les shuffles
   2. 5.2 Les actions et les transformations
6. 6. Lire et écrire des données
   1. 6.1 Principes de lecture, d'écriture et de transformation de données
   2. 6.2 Lire des données
   3. 6.3 Écrire des données
   4. 6.4 Un exemple de lecture et d’écriture
   5. 6.5 Lire et écrire des données CSV
   6. 6.6 Lire et écrire des données JSON
   7. 6.7 Lire et écrire des données Parquet
   8. 6.8 Lire et écrire des données DeltaLake
   9. 6.9 Lire et écrire des données avec Kafka
   10. 6.10 Lire et écrire des données avec une base de données SQL
7. 7. Types de données et schéma
   1. 7.1 Concepts de type et de schéma
   2. 7.2 Des lignes et des colonnes
   3. 7.3 Types simples
      1. 7.3.1 Les types simples de Spark et de Python
      2. 7.3.2 Les fonctions pour les types numériques
      3. 7.3.3 Les fonctions pour les types alphanumériques
      4. 7.3.4 Les fonctions pour les types temporels
   4. 7.4 Types complexes
      1. 7.4.1 Les fonctions pour le type tableau
      2. 7.4.2 Les fonctions pour le type dictionnaire
      3. 7.4.3 Les fonctions pour le type StructType
   5. 7.5 Schémas implicites ou explicites
   6. 7.6 Un exemple de transformations de type

Spark pour l’enrichissement de données

1. 1. L’API DataFrame
   1. 1.1 Introduction
   2. 1.2 Manipulations
      1. 1.2.1 Ajouter des colonnes
      2. 1.2.2 Renommer des colonnes
      3. 1.2.3 Supprimer des colonnes
      4. 1.2.4 Sélection de données
      5. 1.2.5 Filtrage de données
      6. 1.2.6 Diverses autres méthodes à partir de l’objet DataFrame
   3. 1.3 Agrégations de données
2. 2. L’API SQL
   1. 2.1 Principes de l’API SQL
      1. 2.1.1 Intérêts de l’API SQL
      2. 2.1.2 DataFrame et SQL
      3. 2.1.3 Plusieurs API, des performances identiques
      4. 2.1.4 La logique SQL dans DataFrame
   2. 2.2 Manipulation de l’API SQL
      1. 2.2.1 Premières manipulations
      2. 2.2.2 Des agrégations plus avancées avec les fonctions de fenêtrage
      3. 2.2.3 Des agrégations plus avancées avec les groupes d’agrégations
      4. 2.2.4 Créer ses propres fonctions
3. 3. L’API Dataset
   1. 3.1 Principes et intérêts
   2. 3.2 Création
      1. 3.2.1 À partir d’une séquence
      2. 3.2.2 À partir d’un objet DataFrame
   3. 3.3 Manipulations
      1. 3.3.1 Transformations de données
      2. 3.3.2 Filtrage
   4. 3.4 L’attention portée à Python
4. 4. Les jointures de données
   1. 4.1 Introduction
   2. 4.2 Différentes API
      1. 4.2.1 L’API SQL
      2. 4.2.2 L’API Dataset
   3. 4.3 Différents types de jointures
      1. 4.3.1 Jointures externes
      2. 4.3.2 Jointures internes
      3. 4.3.3 Jointures entières
      4. 4.3.4 Semi-jointure
      5. 4.3.5 Jointure anti
      6. 4.3.6 D’autres types de jointures
   4. 4.4 Gérer les doublons
      1. 4.4.1 Ne pas utiliser d’expression si possible
      2. 4.4.2 Renommer les colonnes avant
      3. 4.4.3 Avoir recours à l’API SQL
5. 5. RDD, l’API bas niveau
   1. 5.1 Présentation générale
      1. 5.1.1 L’histoire
      2. 5.1.2 Caractérisation des RDD
      3. 5.1.3 La programmation fonctionnelle inhérente à Spark
      4. 5.1.4 Les cas d’utilisation
      5. 5.1.5 Relations avec les API haut niveau
   2. 5.2 Premières manipulations
      1. 5.2.1 Créer un objet RDD depuis un autre objet Spark
      2. 5.2.2 Créer un objet RDD depuis une liste
      3. 5.2.3 Créer un objet RDD depuis des sources de données
      4. 5.2.4 Enregistrer un objet RDD
      5. 5.2.5 Filtrer des données
      6. 5.2.6 Modifier ligne à ligne des données
      7. 5.2.7 Renvoyer plusieurs lignes à partir d’une ligne
      8. 5.2.8 Afficher le contenu d’un RDD
      9. 5.2.9 Enregistrer le contenu d’un RDD
      10. 5.2.10 Calculer des valeurs à partir d’un RDD
   3. 5.3 Les agrégations et jointures
      1. 5.3.1 Les agrégations
      2. 5.3.2 Les jointures
6. 6. L’API Spark streaming
   1. 6.1 Introduction
      1. 6.1.1 Streaming versus batch
      2. 6.1.2 Un système robuste
      3. 6.1.3 Une API proche des autres API de Spark
      4. 6.1.4 Plusieurs manières de faire du streaming
      5. 6.1.5 Les sources et sorties
   2. 6.2 Manipulations
      1. 6.2.1 Structure d’une requête streaming
      2. 6.2.2 Déboguer
      3. 6.2.3 Transformations
      4. 6.2.4 Agrégations
      5. 6.2.5 Jointures
      6. 6.2.6 Opérations de fenêtrage (window operations)
      7. 6.2.7 Les déclencheurs
   3. 6.3 Les limites

Spark pour l’apprentissage automatique

1. 1. Introduction à l’apprentissage automatique
   1. 1.1 L’approche de la boîte noire magique
   2. 1.2 L’approche par les mathématiques et statistiques
   3. 1.3 L’approche par l’intuition
   4. 1.4 Définition
      1. 1.4.1 La machine autonome : une idée ancienne
      2. 1.4.2 L’idée de machine autonome renouvelée avec l’informatique
      3. 1.4.3 Une tentative de définition
   5. 1.5 Spark et l’apprentissage automatique
2. 2. Différentes étapes d’un projet d'apprentissage automatique
   1. 2.1 Prétraiter les données
   2. 2.2 Extraire des caractéristiques
      1. 2.2.1 Extraire des caractéristiques de données textuelles
      2. 2.2.2 TF-IDF
      3. 2.2.3 Word2Vec
   3. 2.3 Transformer des caractéristiques
      1. 2.3.1 Introduction
      2. 2.3.2 Transformations des données alphanumériques
      3. 2.3.3 Les fonctions de remise à l’échelle
      4. 2.3.4 Transformation des données numériques
3. 3. Classification
   1. 3.1 Définition
   2. 3.2 Structure d’un algorithme d’apprentissage dans Spark
      1. 3.2.1 Quelques mots-clés
      2. 3.2.2 L’évaluation
      3. 3.2.3 Estimer et transformer
   3. 3.3 Différents algorithmes
      1. 3.3.1 L’arbre de décision
      2. 3.3.2 La forêt aléatoire
4. 4. Régression
   1. 4.1 Définition
   2. 4.2 Différents algorithmes
      1. 4.2.1 L’arbre de décision
      2. 4.2.2 La régression linéaire
5. 5. Apprentissage non supervisé
   1. 5.1 Définition
   2. 5.2 Exemple
6. 6. Recommandation
   1. 6.1 Définition
   2. 6.2 Exemple
      1. 6.2.1 Extraire des caractéristiques invisibles à l’œil
      2. 6.2.2 Évaluer un algorithme de recommandation
      3. 6.2.3 Démarrage à froid et valeurs implicites
      4. 6.2.4 Implémentation d’une matrice de factorisation
7. 7. Apprentissage profond
   1. 7.1 Définition
   2. 7.2 Exemple
8. 8. Opérations statistiques
   1. 8.1 Mesurer la corrélation de plusieurs variables
   2. 8.2 Tests d’hypothèse

Industrialiser Spark

1. 1. Améliorer les performances de temps
   1. 1.1 Dimensionner adéquatement le cluster
   2. 1.2 Choisir la bonne API
   3. 1.3 Éviter les UDF
   4. 1.4 User précautionneusement des actions
   5. 1.5 Éviter le shuffle
      1. 1.5.1 Rappel du concept de shuffle
      2. 1.5.2 Penser mégadonnées
      3. 1.5.3 Différentes stratégies de jointure
      4. 1.5.4 Les fonctions coalesce et repartition
2. 2. Tester avec Spark
   1. 2.1 Tester sans Spark
   2. 2.2 Tester avec Spark
   3. 2.3 Créer ou importer les données
   4. 2.4 Des tests performants
      1. 2.4.1 Limiter les actions
      2. 2.4.2 Un même processus pour différents tests
      3. 2.4.3 Limiter les logs
      4. 2.4.4 Limiter le shuffle
3. 3. Améliorer les performances algorithmiques
   1. 3.1 Les performances dans l’apprentissage automatique
   2. 3.2 Exemple avec validation croisée à k blocs
   3. 3.3 Séparation test/entraînement
4. 4. Déboguer avec Spark
   1. 4.1 Vision du plan physique
      1. 4.1.1 Vision par l’intermédiaire du schéma
      2. 4.1.2 Vision par l’intermédiaire du plan écrit
   2. 4.2 Les autres onglets de Spark UI
   3. 4.3 Déboguer avec Spark UI
5. 5. Se repérer dans la documentation
   1. 5.1 La documentation générale
   2. 5.2 La documentation Python
6. 6. Déployer l’apprentissage automatique
   1. 6.1 Enregistrer un modèle
   2. 6.2 Récupérer un modèle sauvegardé
9. Conclusion
10. Index