Agile Data Science - Guide rapide

La science des données agile est une approche utilisant la science des données avec une méthodologie agile pour le développement d'applications Web. Il se concentre sur la sortie du processus de science des données approprié pour effectuer des changements pour une organisation. La science des données comprend la création d'applications qui décrivent le processus de recherche avec analyse, visualisation interactive et maintenant également l'apprentissage automatique appliqué.

Le principal objectif de la science des données agile est de -

documenter et guider l'analyse des données explicatives pour découvrir et suivre le chemin critique vers un produit convaincant.

La science des données Agile est organisée avec l'ensemble de principes suivant -

Itération continue

Ce processus implique une itération continue avec des tableaux de création, des graphiques, des rapports et des prédictions. La création de modèles prédictifs nécessitera de nombreuses itérations d'ingénierie des fonctionnalités avec extraction et production d'informations.

Sortie intermédiaire

Il s'agit de la liste des pistes des sorties générées. On dit même que les expériences ratées ont également des résultats. Le suivi de la sortie de chaque itération aidera à créer une meilleure sortie lors de la prochaine itération.

Expériences prototypes

Les expériences prototypes impliquent l'attribution de tâches et la génération de résultats conformément aux expériences. Dans une tâche donnée, nous devons itérer pour obtenir un aperçu et ces itérations peuvent être mieux expliquées comme des expériences.

Intégration des données

Le cycle de vie du développement logiciel comprend différentes phases avec des données essentielles pour -

  • customers

  • développeurs, et

  • les affaires

L'intégration des données ouvre la voie à de meilleures perspectives et résultats.

Valeur des données pyramidales

La valeur pyramidale ci-dessus décrit les couches nécessaires au développement de la «science des données Agile». Cela commence par une collection de dossiers basés sur les exigences et les dossiers individuels de plomberie. Les graphiques sont créés après le nettoyage et l'agrégation des données. Les données agrégées peuvent être utilisées pour la visualisation des données. Les rapports sont générés avec une structure, des métadonnées et des balises de données appropriées. La deuxième couche de pyramide à partir du haut comprend une analyse de prédiction. La couche de prédiction est l'endroit où plus de valeur est créée, mais aide à créer de bonnes prédictions axées sur l'ingénierie des entités.

La couche supérieure implique des actions où la valeur des données est pilotée efficacement. La meilleure illustration de cette implémentation est «l'Intelligence Artificielle».

Dans ce chapitre, nous nous concentrerons sur les concepts de cycle de vie du développement logiciel appelé «agile». La méthodologie de développement logiciel Agile aide à créer un logiciel grâce à des sessions d'incrémentation en courtes itérations de 1 à 4 semaines afin que le développement soit aligné sur les besoins changeants de l'entreprise.

Il y a 12 principes qui décrivent la méthodologie Agile en détail -

Satisfaction des clients

La priorité la plus élevée est donnée aux clients qui se concentrent sur les exigences grâce à la livraison précoce et continue de logiciels précieux.

Accueillir les nouveaux changements

Les changements sont acceptables pendant le développement du logiciel. Les processus agiles sont conçus pour fonctionner de manière à correspondre à l'avantage concurrentiel du client.

Livraison

La livraison d'un logiciel fonctionnel est donnée aux clients dans un délai d'une à quatre semaines.

Collaboration

Les analystes d'affaires, les analystes qualité et les développeurs doivent travailler ensemble pendant tout le cycle de vie du projet.

Motivation

Les projets doivent être conçus avec un clan d'individus motivés. Il fournit un environnement pour soutenir les membres individuels de l'équipe.

Conversation personnelle

La conversation en face à face est la méthode la plus efficace et la plus efficace pour envoyer des informations à et au sein d'une équipe de développement.

Mesurer les progrès

Mesurer les progrès est la clé qui aide à définir l'avancement du projet et du développement logiciel.

Maintenir un rythme constant

Le processus Agile se concentre sur le développement durable. L'entreprise, les développeurs et les utilisateurs doivent être en mesure de maintenir un rythme constant avec le projet.

surveillance

Il est obligatoire de maintenir une attention régulière à l'excellence technique et à une bonne conception pour améliorer la fonctionnalité agile.

Simplicité

Le processus Agile garde tout simple et utilise des termes simples pour mesurer le travail qui n'est pas terminé.

Termes auto-organisés

Une équipe agile doit être auto-organisée et indépendante avec la meilleure architecture; les exigences et les conceptions émergent d'équipes auto-organisées.

Revoir le travail

Il est important de revoir le travail à intervalles réguliers afin que l'équipe puisse réfléchir à la façon dont le travail progresse. La révision du module en temps opportun améliorera les performances.

Stand-up quotidien

Le stand-up quotidien fait référence à la réunion de statut quotidienne entre les membres de l'équipe. Il fournit des mises à jour liées au développement du logiciel. Il fait également référence à l'élimination des obstacles au développement de projets.

Le stand-up quotidien est une pratique obligatoire, quelle que soit la façon dont une équipe agile est constituée, quel que soit l'emplacement de son bureau.

La liste des caractéristiques d'un stand-up quotidien est la suivante -

  • La durée de la réunion quotidienne de stand-up devrait être d'environ 15 minutes. Il ne devrait pas durer plus longtemps.

  • Le stand-up devrait inclure des discussions sur la mise à jour du statut.

  • Les participants à cette réunion ont généralement l'intention de se réunir rapidement.

Histoire de l'utilisateur

Une histoire est généralement une exigence, qui est formulée en quelques phrases dans un langage simple et doit être complétée en une itération. Une user story doit inclure les caractéristiques suivantes -

  • Tout le code associé doit avoir des enregistrements associés.

  • Les cas de test unitaires pour l'itération spécifiée.

  • Tous les cas de test d'acceptation doivent être définis.

  • Acceptation du product owner lors de la définition de l'histoire.

Qu'est-ce que Scrum?

Scrum peut être considéré comme un sous-ensemble de la méthodologie agile. C'est un processus léger et comprend les fonctionnalités suivantes -

  • Il s'agit d'un cadre de processus, qui comprend un ensemble de pratiques qui doivent être suivies dans un ordre cohérent. La meilleure illustration de Scrum est de suivre des itérations ou des sprints.

  • Il s'agit d'un processus «léger», ce qui signifie que le processus est maintenu aussi petit que possible, afin de maximiser le rendement productif dans une durée donnée spécifiée.

Le processus Scrum est connu pour son processus distinctif par rapport à d'autres méthodologies d'approche agile traditionnelle. Il est divisé en trois catégories suivantes -

  • Roles

  • Artifacts

  • Boîtes de temps

Les rôles définissent les membres de l'équipe et leurs rôles inclus tout au long du processus. L'équipe Scrum se compose des trois rôles suivants -

  • Scrum Master

  • Propriétaire du produit

  • Team

Les artefacts Scrum fournissent des informations clés dont chaque membre doit être conscient. Les informations comprennent des détails sur le produit, les activités prévues et les activités réalisées. Les artefacts définis dans le framework Scrum sont les suivants -

  • Backlog produit

  • Backlog de sprint

  • Tableau de combustion

  • Increment

Les boîtes de temps sont les user stories qui sont planifiées pour chaque itération. Ces user stories aident à décrire les fonctionnalités du produit qui font partie des artefacts Scrum. Le backlog produit est une liste de user stories. Ces user stories sont classées par ordre de priorité et transmises aux réunions d'utilisateurs pour décider laquelle doit être reprise.

Pourquoi Scrum Master?

Scrum Master interagit avec chaque membre de l'équipe. Voyons maintenant l'interaction du Scrum Master avec d'autres équipes et ressources.

Propriétaire du produit

Le Scrum Master interagit avec le Product Owner des manières suivantes -

  • Trouver des techniques pour réaliser un backlog produit efficace des user stories et les gérer.

  • Aider l'équipe à comprendre les besoins d'éléments clairs et concis du backlog de produit.

  • Planification de produit avec environnement spécifique.

  • S'assurer que le propriétaire du produit sait comment augmenter la valeur du produit.

  • Faciliter les événements Scrum en cas de besoin.

Équipe Scrum

Le Scrum Master interagit avec l'équipe de plusieurs manières -

  • Accompagnement de l'organisation dans son adoption Scrum.

  • Planifier les implémentations Scrum dans l'organisation spécifique.

  • Aider les employés et les parties prenantes à comprendre les exigences et les phases de développement de produits.

  • Travailler avec Scrum Masters d'autres équipes pour augmenter l'efficacité de l'application de Scrum de l'équipe spécifiée.

Organisation

Le Scrum Master interagit avec l'organisation de plusieurs manières. Quelques-uns sont mentionnés ci-dessous -

  • L'équipe de coaching et de mêlée interagit avec l'auto-organisation et comprend une fonctionnalité de fonctionnalité croisée.

  • Coaching de l'organisation et des équipes dans les domaines où Scrum n'est pas encore totalement adopté ou n'est pas accepté.

Avantages de Scrum

Scrum aide les clients, les membres de l'équipe et les parties prenantes à collaborer. Il comprend une approche temporelle et un retour d'information continu du propriétaire du produit garantissant que le produit est en état de fonctionnement. Scrum offre des avantages aux différents rôles du projet.

Client

Les sprints ou itérations sont considérés pour une durée plus courte et les user stories sont conçues selon la priorité et sont reprises lors de la planification du sprint. Il garantit que chaque livraison de sprint, les exigences des clients sont satisfaites. Sinon, les exigences sont notées et sont planifiées et prises pour le sprint.

Organisation

L'organisation avec l'aide de Scrum et Scrum masters peut se concentrer sur les efforts requis pour le développement des user stories, réduisant ainsi la surcharge de travail et évitant les retouches le cas échéant. Cela contribue également à maintenir une efficacité accrue de l'équipe de développement et la satisfaction des clients. Cette approche contribue également à augmenter le potentiel du marché.

Gestionnaires de produits

La responsabilité principale des chefs de produit est de s'assurer que la qualité du produit est maintenue. Avec l'aide de Scrum Masters, il devient facile de faciliter le travail, de recueillir des réponses rapides et d'absorber les changements le cas échéant. Les chefs de produit vérifient également que le produit conçu est aligné selon les exigences du client à chaque sprint.

Équipe de développement

Avec la nature limitée dans le temps et le maintien des sprints pendant une durée plus courte, l'équipe de développement devient enthousiaste de voir que le travail est reflété et livré correctement. Le produit de travail incrémente chaque niveau après chaque itération ou plutôt nous pouvons les appeler «sprint». Les user stories conçues pour chaque sprint deviennent la priorité du client, ajoutant plus de valeur à l'itération.

Conclusion

Scrum est un cadre efficace dans lequel vous pouvez développer des logiciels en équipe. Il est entièrement conçu sur des principes agiles. ScrumMaster est là pour aider et coopérer l'équipe de Scrum de toutes les manières possibles. Il agit comme un entraîneur personnel qui vous aide à vous en tenir au plan conçu et à effectuer toutes les activités selon le plan. L'autorité de ScrumMaster ne devrait jamais s'étendre au-delà du processus. Il / elle doit être potentiellement capable de gérer chaque situation.

Dans ce chapitre, nous comprendrons le processus de science des données et les terminologies nécessaires pour comprendre le processus.

«La science des données est le mélange d'interface de données, de développement d'algorithmes et de technologie afin de résoudre des problèmes analytiques complexes».

La science des données est un domaine interdisciplinaire englobant des méthodes, des processus et des systèmes scientifiques avec des catégories incluses en tant que connaissances d'apprentissage automatique, mathématiques et statistiques avec la recherche traditionnelle. Il comprend également une combinaison de compétences en piratage avec une expertise de fond. La science des données s'inspire des mathématiques, des statistiques, des sciences de l'information et de l'informatique, de l'exploration de données et de l'analyse prédictive.

Les différents rôles qui font partie de l'équipe de science des données sont mentionnés ci-dessous -

Les clients

Les clients sont les personnes qui utilisent le produit. Leur intérêt conditionne le succès du projet et leurs retours sont très précieux en science des données.

Développement des affaires

Cette équipe de science des données signe chez les premiers clients, soit de première main, soit via la création de pages de destination et de promotions. L'équipe de développement commercial délivre la valeur du produit.

Gestionnaires de produits

Les chefs de produit prennent l'importance de créer le meilleur produit, ce qui est précieux sur le marché.

Concepteurs d'interaction

Ils se concentrent sur les interactions de conception autour des modèles de données afin que les utilisateurs trouvent la valeur appropriée.

Scientifiques des données

Les data scientists explorent et transforment les données de nouvelles manières pour créer et publier de nouvelles fonctionnalités. Ces scientifiques combinent également des données provenant de diverses sources pour créer une nouvelle valeur. Ils jouent un rôle important dans la création de visualisations avec des chercheurs, des ingénieurs et des développeurs Web.

Des chercheurs

Comme son nom l'indique, les chercheurs participent à des activités de recherche. Ils résolvent des problèmes complexes, ce que les data scientists ne peuvent pas faire. Ces problèmes impliquent une concentration et un temps intenses du module d'apprentissage automatique et de statistiques.

S'adapter au changement

Tous les membres de l'équipe de la science des données sont tenus de s'adapter aux nouvelles évolutions et de travailler en fonction des besoins. Plusieurs changements doivent être apportés pour adopter une méthodologie agile avec la science des données, qui sont mentionnés comme suit -

  • Choisir des généralistes plutôt que des spécialistes.

  • Préférence des petites équipes par rapport aux grandes équipes.

  • Utilisation d'outils et de plates-formes de haut niveau.

  • Partage continu et itératif des travaux intermédiaires.

Note

Dans l'équipe de science des données Agile, une petite équipe de généralistes utilise des outils de haut niveau qui sont évolutifs et affinent les données par itérations dans des états de valeur de plus en plus élevés.

Considérez les exemples suivants liés au travail des membres de l'équipe de science des données -

  • Les concepteurs fournissent du CSS.

  • Les développeurs Web créent des applications entières, comprennent l'expérience utilisateur et la conception de l'interface.

  • Les scientifiques des données devraient travailler à la fois à la recherche et à la création de services Web, y compris des applications Web.

  • Les chercheurs travaillent dans la base de code, qui montre des résultats expliquant les résultats intermédiaires.

  • Les chefs de produit essaient d'identifier et de comprendre les failles dans tous les domaines connexes.

Dans ce chapitre, nous découvrirons les différents outils Agile et leur installation. La pile de développement de la méthodologie agile comprend l'ensemble de composants suivant:

Événements

Un événement est une occurrence qui se produit ou est enregistrée avec ses caractéristiques et horodatages.

Un événement peut prendre de nombreuses formes telles que des serveurs, des capteurs, des transactions financières ou des actions, que nos utilisateurs prennent dans notre application. Dans ce tutoriel complet, nous utiliserons des fichiers JSON qui faciliteront l'échange de données entre différents outils et langages.

Collectionneurs

Les collecteurs sont des agrégateurs d'événements. Ils collectent les événements de manière systématique pour stocker et agréger des données volumineuses en les mettant en file d'attente pour l'action des travailleurs en temps réel.

Document distribué

Ces documents incluent le multinœud (plusieurs nœuds) qui stocke le document dans un format spécifique. Nous allons nous concentrer sur MongoDB dans ce tutoriel.

Serveur d'applications Web

Le serveur d'applications Web active les données au format JSON via le client via la visualisation, avec une surcharge minimale. Cela signifie que le serveur d'applications Web permet de tester et de déployer les projets créés avec une méthodologie agile.

Navigateur moderne

Il permet à un navigateur ou une application moderne de présenter des données comme un outil interactif pour nos utilisateurs.

Configuration de l'environnement local

Pour la gestion des ensembles de données, nous nous concentrerons sur le framework Anaconda de python qui comprend des outils de gestion des fichiers Excel, csv et bien d'autres. Le tableau de bord du framework Anaconda une fois installé est comme indiqué ci-dessous. Il est également appelé «Anaconda Navigator» -

Le navigateur inclut le «framework Jupyter» qui est un système de notebook qui permet de gérer les ensembles de données. Une fois que vous lancez le framework, il sera hébergé dans le navigateur comme mentionné ci-dessous -

Dans ce chapitre, nous nous concentrerons sur la différence entre les données structurées, semi-structurées et non structurées.

Données structurées

Les données structurées concernent les données stockées au format SQL dans un tableau avec des lignes et des colonnes. Il comprend une clé relationnelle, qui est mappée dans des champs prédéfinis. Les données structurées sont utilisées à plus grande échelle.

Les données structurées ne représentent que 5 à 10% de toutes les données informatiques.

Données semi-structurées

Les données semi-structurées incluent les données qui ne résident pas dans la base de données relationnelle. Ils incluent certaines propriétés organisationnelles qui facilitent l'analyse. Il inclut le même processus pour les stocker dans une base de données relationnelle. Les exemples de base de données semi-structurée sont les fichiers CSV, les documents XML et JSON. Les bases de données NoSQL sont considérées comme semi-structurées.

Données non structurées

Les données non structurées représentent 80% des données. Il comprend souvent du texte et du contenu multimédia. Les meilleurs exemples de données non structurées incluent les fichiers audio, les présentations et les pages Web. Les exemples de données non structurées générées par la machine sont des images satellites, des données scientifiques, des photographies et des données vidéo, radar et sonar.

La structure pyramidale ci-dessus se concentre spécifiquement sur la quantité de données et le rapport sur lequel elles sont dispersées.

Les données quasi-structurées apparaissent comme type entre les données non structurées et semi-structurées. Dans ce didacticiel, nous nous concentrerons sur les données semi-structurées, ce qui est bénéfique pour la méthodologie agile et la recherche en science des données.

Les données semi-structurées n'ont pas de modèle de données formel, mais ont un modèle et une structure apparents et auto-descriptifs qui sont développés par leur analyse.

L'objectif complet de ce didacticiel est de suivre une méthodologie agile avec moins d'étapes et avec la mise en œuvre d'outils plus utiles. Pour comprendre cela, il est important de connaître la différence entre les bases de données SQL et NoSQL.

La plupart des utilisateurs connaissent la base de données SQL et ont de bonnes connaissances sur MySQL, Oracle ou d'autres bases de données SQL. Au cours des dernières années, la base de données NoSQL est largement adoptée pour résoudre divers problèmes commerciaux et exigences du projet.

Le tableau suivant montre la différence entre les bases de données SQL et NoSQL -

SQL NoSQL
Les bases de données SQL sont principalement appelées système de gestion de base de données relationnelle (SGBDR). La base de données NoSQL est également appelée base de données orientée document. Il est non relationnel et distribué.
Les bases de données basées sur SQL comprennent une structure de table avec des lignes et des colonnes. Collection de tables et autres structures de schéma appelées base de données. La base de données NoSQL comprend des documents comme structure principale et l'inclusion de documents est appelée collection.
Les bases de données SQL incluent un schéma prédéfini. Les bases de données NoSQL ont des données dynamiques et incluent des données non structurées.
Les bases de données SQL sont évolutives verticalement. Les bases de données NoSQL sont évolutives horizontalement.
Les bases de données SQL conviennent parfaitement aux environnements de requêtes complexes. NoSQL n'a pas d'interfaces standard pour le développement de requêtes complexes.
Les bases de données SQL ne sont pas réalisables pour le stockage de données hiérarchiques. Les bases de données NoSQL conviennent mieux au stockage hiérarchique des données.
Les bases de données SQL conviennent le mieux aux transactions lourdes dans les applications spécifiées. Les bases de données NoSQL ne sont toujours pas considérées comme comparables en charge élevée pour les applications transactionnelles complexes.
Les bases de données SQL fournissent un excellent support pour leurs fournisseurs. La base de données NoSQL repose toujours sur le support de la communauté. Seuls quelques experts sont disponibles pour la configuration et le déploiement pour les déploiements NoSQL à grande échelle.
Les bases de données SQL se concentrent sur les propriétés ACID - atomique, cohérence, isolation et durabilité. La base de données NoSQL se concentre sur les propriétés CAP - cohérence, disponibilité et tolérance de partition.
Les bases de données SQL peuvent être classées comme open source ou open source en fonction des fournisseurs qui les ont choisies. Les bases de données NoSQL sont classées en fonction du type de stockage. Les bases de données NoSQL sont open source par défaut.

Pourquoi NoSQL pour Agile?

La comparaison mentionnée ci-dessus montre que la base de données de documents NoSQL prend complètement en charge le développement agile. Il est sans schéma et ne se concentre pas complètement sur la modélisation des données. Au lieu de cela, NoSQL diffère les applications et les services et les développeurs ont ainsi une meilleure idée de la manière dont les données peuvent être modélisées. NoSQL définit le modèle de données comme le modèle d'application.

Installation de MongoDB

Tout au long de ce tutoriel, nous nous concentrerons davantage sur les exemples de MongoDB car il est considéré comme le meilleur «schéma NoSQL».

Il y a des moments où les données ne sont pas disponibles au format relationnel et nous devons les garder transactionnelles à l'aide de bases de données NoSQL.

Dans ce chapitre, nous nous concentrerons sur le flux de données de NoSQL. Nous apprendrons également comment il est opérationnel avec une combinaison d'agilité et de science des données.

L'une des principales raisons d'utiliser NoSQL avec agile est d'augmenter la vitesse face à la concurrence du marché. Les raisons suivantes montrent comment NoSQL convient le mieux à la méthodologie des logiciels agiles -

Moins d'obstacles

Changer le modèle, qui passe actuellement à mi-chemin, a des coûts réels même en cas de développement agile. Avec NoSQL, les utilisateurs travaillent avec des données agrégées au lieu de perdre du temps à normaliser les données. Le point principal est de faire quelque chose et de travailler dans le but de créer des données parfaites pour le modèle.

Évolutivité accrue

Chaque fois qu'une organisation crée un produit, elle met davantage l'accent sur son évolutivité. NoSQL est toujours connu pour son évolutivité, mais il fonctionne mieux lorsqu'il est conçu avec une évolutivité horizontale.

Capacité à exploiter les données

NoSQL est un modèle de données sans schéma qui permet à l'utilisateur d'utiliser facilement des volumes de données, qui comprend plusieurs paramètres de variabilité et de vitesse. Lorsque vous envisagez un choix de technologie, vous devez toujours considérer celle qui exploite les données à une plus grande échelle.

Flux de données de NoSQL

Prenons l'exemple suivant dans lequel, nous avons montré comment un modèle de données se concentre sur la création du schéma SGBDR.

Voici les différentes exigences du schéma -

  • L'identification de l'utilisateur doit être répertoriée.

  • Chaque utilisateur doit avoir au moins une compétence obligatoire.

  • Les détails de l'expérience de chaque utilisateur doivent être conservés correctement.

La table utilisateur est normalisée avec 3 tables séparées -

  • Users

  • Compétences des utilisateurs

  • Expérience utilisateur

La complexité augmente lors de l'interrogation de la base de données et la consommation de temps est notée avec une normalisation accrue, ce qui n'est pas bon pour la méthodologie Agile. Le même schéma peut être conçu avec la base de données NoSQL comme mentionné ci-dessous -

NoSQL maintient la structure au format JSON, dont la structure est légère. Avec JSON, les applications peuvent stocker des objets avec des données imbriquées en tant que documents uniques.

Dans ce chapitre, nous nous concentrerons sur la structure JSON, qui fait partie de la «méthodologie Agile». MongoDB est une structure de données NoSQL largement utilisée et fonctionne facilement pour collecter et afficher des enregistrements.

Étape 1

Cette étape implique l'établissement d'une connexion avec MongoDB pour créer une collection et un modèle de données spécifié. Tout ce que vous devez exécuter est la commande «mongod» pour démarrer la connexion et la commande mongo pour vous connecter au terminal spécifié.

Étape 2

Créez une nouvelle base de données pour créer des enregistrements au format JSON. Pour l'instant, nous créons une base de données factice nommée «mydb».

>use mydb
switched to db mydb
>db
mydb
>show dbs
local 0.78125GB
test 0.23012GB
>db.user.insert({"name":"Agile Data Science"})
>show dbs
local 0.78125GB
mydb 0.23012GB
test 0.23012GB

Étape 3

La création de la collection est obligatoire pour obtenir la liste des enregistrements. Cette fonctionnalité est utile pour la recherche et les résultats en science des données.

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>show collections
mycollection
system.indexes
>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
 6142800, max : 10000 } )
{ "ok" : 1 }
>db.agiledatascience.insert({"name" : "demoname"})
>show collections
mycol
mycollection
system.indexes
demoname

La visualisation des données joue un rôle très important dans la science des données. Nous pouvons considérer la visualisation de données comme un module de science des données. La science des données comprend plus que la création de modèles prédictifs. Il comprend l'explication des modèles et leur utilisation pour comprendre les données et prendre des décisions. La visualisation des données fait partie intégrante de la présentation des données de la manière la plus convaincante.

Du point de vue de la science des données, la visualisation des données est une fonction de mise en évidence qui montre les changements et les tendances.

Tenez compte des consignes suivantes pour une visualisation efficace des données -

  • Positionnez les données sur une échelle commune.

  • L'utilisation de barres est plus efficace par rapport aux cercles et aux carrés.

  • Une couleur appropriée doit être utilisée pour les nuages ​​de points.

  • Utilisez un graphique à secteurs pour afficher les proportions.

  • La visualisation Sunburst est plus efficace pour les tracés hiérarchiques.

Agile a besoin d'un langage de script simple pour la visualisation des données et avec la science des données en collaboration «Python» est le langage suggéré pour la visualisation des données.

Exemple 1

L'exemple suivant illustre la visualisation des données du PIB calculé pour des années spécifiques. «Matplotlib» est la meilleure bibliothèque pour la visualisation de données en Python. L'installation de cette bibliothèque est illustrée ci-dessous -

Considérez le code suivant pour comprendre cela -

import matplotlib.pyplot as plt
years = [1950, 1960, 1970, 1980, 1990, 2000, 2010]
gdp = [300.2, 543.3, 1075.9, 2862.5, 5979.6, 10289.7, 14958.3]

# create a line chart, years on x-axis, gdp on y-axis
plt.plot(years, gdp, color='green', marker='o', linestyle='solid')

# add a title plt.title("Nominal GDP")
# add a label to the y-axis
plt.ylabel("Billions of $")
plt.show()

Production

Le code ci-dessus génère la sortie suivante -

Il existe de nombreuses façons de personnaliser les graphiques avec des étiquettes d'axe, des styles de ligne et des marqueurs de points. Concentrons-nous sur l'exemple suivant qui démontre la meilleure visualisation des données. Ces résultats peuvent être utilisés pour une meilleure sortie.

Exemple 2

import datetime
import random
import matplotlib.pyplot as plt

# make up some data
x = [datetime.datetime.now() + datetime.timedelta(hours=i) for i in range(12)]
y = [i+random.gauss(0,1) for i,_ in enumerate(x)]

# plot
plt.plot(x,y)

# beautify the x-labels
plt.gcf().autofmt_xdate()
plt.show()

Production

Le code ci-dessus génère la sortie suivante -

L'enrichissement des données fait référence à une gamme de processus utilisés pour améliorer, affiner et améliorer les données brutes. Il fait référence à la transformation de données utiles (données brutes en informations utiles). Le processus d'enrichissement des données vise à faire des données un actif de données précieux pour les entreprises ou les entreprises modernes.

Le processus d'enrichissement des données le plus courant comprend la correction des fautes d'orthographe ou des erreurs typographiques dans la base de données grâce à l'utilisation d'algorithmes de décision spécifiques. Les outils d'enrichissement des données ajoutent des informations utiles aux tableaux de données simples.

Considérez le code suivant pour la correction orthographique des mots -

import re
from collections import Counter
def words(text): return re.findall(r'\w+', text.lower())
WORDS = Counter(words(open('big.txt').read()))

def P(word, N=sum(WORDS.values())):
   "Probabilities of words"
   return WORDS[word] / N
	
def correction(word):
   "Spelling correction of word"
   return max(candidates(word), key=P)
	
def candidates(word):
   "Generate possible spelling corrections for word."
   return (known([word]) or known(edits1(word)) or known(edits2(word)) or [word])
	
def known(words):
   "The subset of `words` that appear in the dictionary of WORDS."
   return set(w for w in words if w in WORDS)
	
def edits1(word):
   "All edits that are one edit away from `word`."
   letters = 'abcdefghijklmnopqrstuvwxyz'
   splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]
   deletes = [L + R[1:] for L, R in splits if R]
   transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R)>1]
   replaces = [L + c + R[1:] for L, R in splits if R for c in letters]
   inserts = [L + c + R for L, R in splits for c in letters]
   return set(deletes + transposes + replaces + inserts)
	
def edits2(word):
   "All edits that are two edits away from `word`."
   return (e2 for e1 in edits1(word) for e2 in edits1(e1))
   print(correction('speling'))
   print(correction('korrectud'))

Dans ce programme, nous allons faire correspondre avec «big.txt» qui comprend les mots corrigés. Les mots correspondent aux mots inclus dans le fichier texte et impriment les résultats appropriés en conséquence.

Production

Le code ci-dessus générera la sortie suivante -

Dans ce chapitre, nous en apprendrons davantage sur la création de rapports, qui est un module important de la méthodologie agile. Pages de graphique de sprints agiles créées par visualisation dans des rapports complets. Avec les rapports, les graphiques deviennent interactifs, les pages statiques deviennent des données dynamiques et liées au réseau. Les caractéristiques de l'étape des rapports de la pyramide des valeurs des données sont présentées ci-dessous -

Nous mettrons davantage l'accent sur la création d'un fichier csv, qui peut être utilisé comme rapport pour l'analyse de la science des données et pour tirer des conclusions. Bien que l'agilité se concentre sur moins de documentation, la génération de rapports pour mentionner la progression du développement du produit est toujours prise en compte.

import csv
#----------------------------------------------------------------------
def csv_writer(data, path):
   """
      Write data to a CSV file path
   """
   with open(path, "wb") as csv_file:
   writer = csv.writer(csv_file, delimiter=',')
   for line in data:
   writer.writerow(line)
#----------------------------------------------------------------------
if __name__ == "__main__":
   data = ["first_name,last_name,city".split(","),
      "Tyrese,Hirthe,Strackeport".split(","),
      "Jules,Dicki,Lake Nickolasville".split(","),
      "Dedric,Medhurst,Stiedemannberg".split(",")
   ]
	
   path = "output.csv"
   csv_writer(data, path)

Le code ci-dessus vous aidera à générer le "fichier csv" comme indiqué ci-dessous -

Considérons les avantages suivants des rapports csv (valeurs séparées par des virgules) -

  • Il est convivial et facile à modifier manuellement.
  • Il est simple à implémenter et à analyser.
  • Le CSV peut être traité dans toutes les applications.
  • Il est plus petit et plus rapide à manipuler.
  • CSV suit un format standard.
  • Il fournit un schéma simple pour les scientifiques des données.

Dans ce chapitre, nous aborderons le rôle des prédictions dans la science des données agile. Les rapports interactifs exposent différents aspects des données. Les prédictions forment la quatrième couche du sprint agile.

Lorsque nous faisons des prédictions, nous nous référons toujours aux données passées et les utilisons comme inférences pour les itérations futures. Dans ce processus complet, nous transférons les données du traitement par lots des données historiques aux données en temps réel sur l'avenir.

Le rôle des prédictions comprend ce qui suit -

  • Les prédictions aident à la prévision. Certaines prévisions sont basées sur des inférences statistiques. Certaines des prédictions sont basées sur les opinions d'experts.

  • L'inférence statistique est impliquée dans les prédictions de toutes sortes.

  • Parfois, les prévisions sont exactes, tandis que parfois les prévisions sont inexactes.

Analyses prédictives

L'analyse prédictive comprend une variété de techniques statistiques de la modélisation prédictive, de l'apprentissage automatique et de l'exploration de données qui analysent les faits actuels et historiques pour faire des prédictions sur les événements futurs et inconnus.

L'analyse prédictive nécessite des données d'entraînement. Les données entraînées incluent des fonctionnalités indépendantes et dépendantes. Les fonctionnalités dépendantes sont les valeurs qu'un utilisateur tente de prédire. Les fonctionnalités indépendantes sont des fonctionnalités décrivant les choses que nous voulons prédire en fonction des fonctionnalités dépendantes.

L'étude des fonctionnalités s'appelle l'ingénierie des fonctionnalités; c'est essentiel pour faire des prédictions. La visualisation des données et l'analyse exploratoire des données font partie de l'ingénierie des fonctionnalités; ceux-ci forment le noyau deAgile data science.

Faire des prédictions

Il existe deux façons de faire des prédictions dans la science des données agile -

  • Regression

  • Classification

La construction d'une régression ou d'une classification dépend entièrement des besoins de l'entreprise et de son analyse. La prédiction de la variable continue conduit au modèle de régression et la prédiction des variables catégorielles conduit au modèle de classification.

Régression

La régression prend en compte des exemples qui comprennent des fonctionnalités et, par conséquent, produit une sortie numérique.

Classification

La classification prend l'entrée et produit une classification catégorielle.

Note - Le jeu de données d'exemple qui définit l'entrée de la prédiction statistique et qui permet à la machine d'apprendre est appelé «données d'apprentissage».

Dans ce chapitre, nous allons découvrir l'application des fonctionnalités d'extraction avec PySpark dans Agile Data Science.

Présentation de Spark

Apache Spark peut être défini comme une infrastructure de traitement en temps réel rapide. Il effectue des calculs pour analyser les données en temps réel. Apache Spark est présenté comme un système de traitement de flux en temps réel et peut également prendre en charge le traitement par lots. Apache Spark prend en charge les requêtes interactives et les algorithmes itératifs.

Spark est écrit en «langage de programmation Scala».

PySpark peut être considéré comme une combinaison de Python avec Spark. PySpark propose le shell PySpark, qui relie l'API Python au cœur Spark et initialise le contexte Spark. La plupart des spécialistes des données utilisent PySpark pour suivre les fonctionnalités, comme indiqué dans le chapitre précédent.

Dans cet exemple, nous nous concentrerons sur les transformations pour créer un ensemble de données appelé count et l'enregistrer dans un fichier particulier.

text_file = sc.textFile("hdfs://...")
counts = text_file.flatMap(lambda line: line.split(" ")) \
   .map(lambda word: (word, 1)) \
   .reduceByKey(lambda a, b: a + b)
counts.saveAsTextFile("hdfs://...")

En utilisant PySpark, un utilisateur peut travailler avec des RDD en langage de programmation python. La bibliothèque intégrée, qui couvre les bases des documents et des composants basés sur les données, y contribue.

La régression logistique fait référence à l'algorithme d'apprentissage automatique utilisé pour prédire la probabilité d'une variable dépendante catégorielle. Dans la régression logistique, la variable dépendante est une variable binaire, qui se compose de données codées 1 (valeurs booléennes de vrai et faux).

Dans ce chapitre, nous nous concentrerons sur le développement d'un modèle de régression en Python utilisant une variable continue. L'exemple de modèle de régression linéaire se concentrera sur l'exploration de données à partir d'un fichier CSV.

Le but de la classification est de prédire si le client souscrira (1/0) à un dépôt à terme.

import pandas as pd
import numpy as np
from sklearn import preprocessing
import matplotlib.pyplot as plt

plt.rc("font", size=14)
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split

import seaborn as sns
sns.set(style="white")
sns.set(style="whitegrid", color_codes=True)
data = pd.read_csv('bank.csv', header=0)
data = data.dropna()
print(data.shape)
print(list(data.columns))

Suivez ces étapes pour implémenter le code ci-dessus dans Anaconda Navigator avec «Jupyter Notebook» -

Step 1 - Lancez le notebook Jupyter avec Anaconda Navigator.

Step 2 - Téléchargez le fichier csv pour obtenir la sortie du modèle de régression de manière systématique.

Step 3 - Créez un nouveau fichier et exécutez la ligne de code mentionnée ci-dessus pour obtenir la sortie souhaitée.

Dans cet exemple, nous allons apprendre à créer et déployer un modèle prédictif qui aide à la prédiction des prix des logements à l'aide d'un script python. Le cadre important utilisé pour le déploiement du système prédictif comprend Anaconda et «Jupyter Notebook».

Suivez ces étapes pour déployer un système prédictif -

Step 1 - Implémentez le code suivant pour convertir les valeurs des fichiers csv en valeurs associées.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import mpl_toolkits

%matplotlib inline
data = pd.read_csv("kc_house_data.csv")
data.head()

Le code ci-dessus génère la sortie suivante -

Step 2 - Exécutez la fonction describe pour obtenir les types de données inclus dans les fichiers csv attribués.

data.describe()

Step 3 - Nous pouvons supprimer les valeurs associées en fonction du déploiement du modèle prédictif que nous avons créé.

train1 = data.drop(['id', 'price'],axis=1)
train1.head()

Step 4- Vous pouvez visualiser les données selon les enregistrements. Les données peuvent être utilisées pour l'analyse de la science des données et la production de livres blancs.

data.floors.value_counts().plot(kind='bar')

La bibliothèque d'apprentissage automatique, également appelée «SparkML» ou «MLLib», comprend des algorithmes d'apprentissage communs, notamment la classification, la régression, le clustering et le filtrage collaboratif.

Pourquoi apprendre SparkML pour Agile?

Spark est en train de devenir la plate-forme de facto pour la création d'algorithmes et d'applications d'apprentissage automatique. Les développeurs travaillent sur Spark pour implémenter des algorithmes de machine de manière évolutive et concise dans le framework Spark. Nous apprendrons les concepts du Machine Learning, ses utilitaires et ses algorithmes avec ce framework. Agile opte toujours pour un framework, qui fournit des résultats courts et rapides.

Algorithmes ML

Les algorithmes d'apprentissage automatique incluent des algorithmes d'apprentissage courants tels que la classification, la régression, le clustering et le filtrage collaboratif.

traits

Il comprend l'extraction, la transformation, la réduction des dimensions et la sélection des caractéristiques.

Pipelines

Les pipelines fournissent des outils pour la construction, l'évaluation et le réglage des pipelines d'apprentissage automatique.

Algorithmes populaires

Voici quelques algorithmes populaires -

  • Statistiques de base

  • Regression

  • Classification

  • Système de recommandation

  • Clustering

  • Réduction de dimensionnalité

  • Extraction de caractéristiques

  • Optimization

Système de recommandation

Un système de recommandation est une sous-classe de système de filtrage d'informations qui cherche à prédire la «note» et la «préférence» qu'un utilisateur suggère à un élément donné.

Le système de recommandation comprend divers systèmes de filtrage, qui sont utilisés comme suit -

Filtrage collaboratif

Cela comprend la construction d'un modèle basé sur le comportement passé ainsi que sur des décisions similaires prises par d'autres utilisateurs. Ce modèle de filtrage spécifique est utilisé pour prédire les éléments qu'un utilisateur souhaite intégrer.

Filtrage basé sur le contenu

Il inclut le filtrage des caractéristiques discrètes d'un article afin de recommander et d'ajouter de nouveaux articles avec des propriétés similaires.

Dans nos chapitres suivants, nous nous concentrerons sur l'utilisation du système de recommandation pour résoudre un problème spécifique et améliorer les performances de prédiction du point de vue de la méthodologie agile.

Dans ce chapitre, nous nous concentrerons sur la résolution d'un problème de prédiction à l'aide d'un scénario spécifique.

Considérez qu'une entreprise souhaite automatiser les détails d'éligibilité au prêt selon les détails du client fournis via le formulaire de demande en ligne. Les détails incluent le nom du client, le sexe, l'état matrimonial, le montant du prêt et d'autres détails obligatoires.

Les détails sont enregistrés dans le fichier CSV comme indiqué ci-dessous -

Exécutez le code suivant pour évaluer le problème de prédiction -

import pandas as pd
from sklearn import ensemble
import numpy as np

from scipy.stats import mode
from sklearn import preprocessing,model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import LabelEncoder

#loading the dataset
data=pd.read_csv('train.csv',index_col='Loan_ID')
def num_missing(x):
   return sum(x.isnull())
 
#imputing the the missing values from the data
data['Gender'].fillna(mode(list(data['Gender'])).mode[0], inplace=True)
data['Married'].fillna(mode(list(data['Married'])).mode[0], inplace=True)
data['Self_Employed'].fillna(mode(list(data['Self_Employed'])).mode[0], inplace=True)

# print (data.apply(num_missing, axis=0))
# #imputing mean for the missing value
data['LoanAmount'].fillna(data['LoanAmount'].mean(), inplace=True)
mapping={'0':0,'1':1,'2':2,'3+':3}
data = data.replace({'Dependents':mapping})
data['Dependents'].fillna(data['Dependents'].mean(), inplace=True)
data['Loan_Amount_Term'].fillna(method='ffill',inplace=True)
data['Credit_History'].fillna(method='ffill',inplace=True)
print (data.apply(num_missing,axis=0))

#converting the cateogorical data to numbers using the label encoder
var_mod = ['Gender','Married','Education','Self_Employed','Property_Area','Loan_Status']
le = LabelEncoder()
for i in var_mod:
   le.fit(list(data[i].values))
   data[i] = le.transform(list(data[i]))
 
#Train test split
x=['Gender','Married','Education','Self_Employed','Property_Area','LoanAmount', 'Loan_Amount_Term','Credit_History','Dependents']
y=['Loan_Status']
print(data[x])
X_train,X_test,y_train,y_test=model_selection.train_test_split(data[x],data[y], test_size=0.2)

#
# #Random forest classifier
# clf=ensemble.RandomForestClassifier(n_estimators=100,
criterion='gini',max_depth=3,max_features='auto',n_jobs=-1)
clf=ensemble.RandomForestClassifier(n_estimators=200,max_features=3,min_samples
   _split=5,oob_score=True,n_jobs=-1,criterion='entropy')
	
clf.fit(X_train,y_train)
accuracy=clf.score(X_test,y_test)
print(accuracy)

Production

Le code ci-dessus génère la sortie suivante.

Dans ce chapitre, nous nous concentrerons sur la construction d'un modèle qui aide à la prédiction des performances de l'élève avec un certain nombre d'attributs inclus. L'objectif est d'afficher le résultat de l'échec des étudiants lors d'un examen.

Processus

La valeur cible de l'évaluation est G3. Ces valeurs peuvent être regroupées et classées en outre comme échec et succès. Si la valeur G3 est supérieure ou égale à 10, alors l'étudiant réussit l'examen.

Exemple

Prenons l'exemple suivant dans lequel un code est exécuté pour prédire la performance si les élèves -

import pandas as pd
""" Read data file as DataFrame """
df = pd.read_csv("student-mat.csv", sep=";")
""" Import ML helpers """
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.svm import LinearSVC # Support Vector Machine Classifier model
""" Split Data into Training and Testing Sets """
def split_data(X, Y):
 return train_test_split(X, Y, test_size=0.2, random_state=17)
""" Confusion Matrix """
def confuse(y_true, y_pred):
 cm = confusion_matrix(y_true=y_true, y_pred=y_pred)
 # print("\nConfusion Matrix: \n", cm)
  fpr(cm)
 ffr(cm)
""" False Pass Rate """
def fpr(confusion_matrix):
 fp = confusion_matrix[0][1]
 tf = confusion_matrix[0][0]
 rate = float(fp) / (fp + tf)
 print("False Pass Rate: ", rate)
""" False Fail Rate """
def ffr(confusion_matrix):
 ff = confusion_matrix[1][0]
 tp = confusion_matrix[1][1]
 rate = float(ff) / (ff + tp)
 print("False Fail Rate: ", rate)
 return rate
""" Train Model and Print Score """
def train_and_score(X, y):
 X_train, X_test, y_train, y_test = split_data(X, y)
 clf = Pipeline([
 ('reduce_dim', SelectKBest(chi2, k=2)),
 ('train', LinearSVC(C=100))
 ])
 scores = cross_val_score(clf, X_train, y_train, cv=5, n_jobs=2)
 print("Mean Model Accuracy:", np.array(scores).mean())
 clf.fit(X_train, y_train)
 confuse(y_test, clf.predict(X_test))
 print()
""" Main Program """
def main():
 print("\nStudent Performance Prediction")
 # For each feature, encode to categorical values
 class_le = LabelEncoder()
 for column in df[["school", "sex", "address", "famsize", "Pstatus", "Mjob",
"Fjob", "reason", "guardian", "schoolsup", "famsup", "paid", "activities",
"nursery", "higher", "internet", "romantic"]].columns:
 df[column] = class_le.fit_transform(df[column].values)
 # Encode G1, G2, G3 as pass or fail binary values
 for i, row in df.iterrows():
 if row["G1"] >= 10:
 df["G1"][i] = 1
 else:
 df["G1"][i] = 0
 if row["G2"] >= 10:
 df["G2"][i] = 1
 else:
 df["G2"][i] = 0
 if row["G3"] >= 10:
 df["G3"][i] = 1
 else:
 df["G3"][i] = 0
 # Target values are G3
 y = df.pop("G3")
 # Feature set is remaining features
 X = df
 print("\n\nModel Accuracy Knowing G1 & G2 Scores")
 print("=====================================")
 train_and_score(X, y)
 # Remove grade report 2
 X.drop(["G2"], axis = 1, inplace=True)
 print("\n\nModel Accuracy Knowing Only G1 Score")
 print("=====================================")
 train_and_score(X, y)
 # Remove grade report 1
 X.drop(["G1"], axis=1, inplace=True)
 print("\n\nModel Accuracy Without Knowing Scores")
 print("=====================================")
 train_and_score(X, y)
main()

Production

Le code ci-dessus génère la sortie comme indiqué ci-dessous

La prédiction est traitée en référence à une seule variable. En référence à une variable, la prédiction du rendement des élèves est indiquée ci-dessous -

La méthodologie Agile aide les organisations à s'adapter au changement, à être compétitives sur le marché et à créer des produits de haute qualité. On observe que les organisations mûrissent avec une méthodologie agile, avec un changement croissant des exigences des clients. La compilation et la synchronisation des données avec des équipes organisationnelles agiles sont importantes pour regrouper les données selon le portefeuille requis.

Construisez un meilleur plan

La performance agile standardisée dépend uniquement du plan. Le schéma de données ordonné renforce la productivité, la qualité et la réactivité des progrès de l'organisation. Le niveau de cohérence des données est maintenu avec des scénarios historiques et en temps réel.

Considérez le diagramme suivant pour comprendre le cycle d'expérimentation en science des données -

La science des données implique l'analyse des exigences suivie de la création d'algorithmes basés sur ceux-ci. Une fois que les algorithmes sont conçus avec la configuration environnementale, un utilisateur peut créer des expériences et collecter des données pour une meilleure analyse.

Cette idéologie calcule le dernier sprint d'agile, qui est appelé «actions».

Actionsimplique toutes les tâches obligatoires pour le dernier sprint ou niveau de méthodologie agile. La trace des phases de la science des données (par rapport au cycle de vie) peut être maintenue avec des cartes d'histoire comme éléments d'action.

Analyse prédictive et Big data

L'avenir de la planification réside entièrement dans la personnalisation des rapports de données avec les données collectées à partir de l'analyse. Cela inclura également la manipulation avec l'analyse de Big Data. À l'aide du Big Data, des informations discrètes peuvent être analysées, de manière efficace en découpant et en découpant les métriques de l'organisation. L'analyse est toujours considérée comme une meilleure solution.

Il existe différentes méthodologies utilisées dans le processus de développement agile. Ces méthodologies peuvent également être utilisées pour le processus de recherche en science des données.

L'organigramme ci-dessous montre les différentes méthodologies -

Scrum

En termes de développement logiciel, scrum signifie gérer le travail avec une petite équipe et la gestion d'un projet spécifique pour révéler les forces et les faiblesses du projet.

Méthodologies du cristal

Les méthodologies Crystal incluent des techniques innovantes de gestion et d'exécution des produits. Avec cette méthode, les équipes peuvent effectuer des tâches similaires de différentes manières. La famille Crystal est l'une des méthodes les plus simples à appliquer.

Méthode de développement logiciel dynamique

Ce cadre de prestation est principalement utilisé pour mettre en œuvre le système de connaissances actuel en méthodologie logicielle.

Développement axé sur l'avenir

L'objectif de ce cycle de vie de développement est les fonctionnalités impliquées dans le projet. Cela fonctionne mieux pour la modélisation d'objets de domaine, le développement de code et de fonctionnalités pour la propriété.

Développement de logiciels Lean

Programmation extrême

La programmation extrême est une méthodologie de développement logiciel unique, qui se concentre sur l'amélioration de la qualité du logiciel. Cela est efficace lorsque le client n'est pas sûr de la fonctionnalité d'un projet.

Les méthodologies agiles prennent racine dans le flux de la science des données et elles sont considérées comme la méthodologie logicielle importante. Grâce à l'auto-organisation agile, les équipes interfonctionnelles peuvent travailler ensemble de manière efficace. Comme mentionné, il existe six catégories principales de développement agile et chacune d'entre elles peut être diffusée avec la science des données selon les exigences. La science des données implique un processus itératif pour obtenir des informations statistiques. Agile aide à décomposer les modules de science des données et aide à traiter les itérations et les sprints de manière efficace.

Le processus d'Agile Data Science est un moyen incroyable de comprendre comment et pourquoi le module de science des données est mis en œuvre. Il résout les problèmes de manière créative.