Agile Data Science - Guida rapida

La scienza dei dati agili è un approccio che utilizza la scienza dei dati con una metodologia agile per lo sviluppo di applicazioni web. Si concentra sull'output del processo di data science adatto per effettuare il cambiamento per un'organizzazione. La scienza dei dati include la creazione di applicazioni che descrivono il processo di ricerca con analisi, visualizzazione interattiva e ora anche l'apprendimento automatico applicato.

L'obiettivo principale della data science agile è:

documentare e guidare l'analisi dei dati esplicativa per scoprire e seguire il percorso critico verso un prodotto convincente.

La scienza dei dati Agile è organizzata con la seguente serie di principi:

Iterazione continua

Questo processo prevede l'iterazione continua con la creazione di tabelle, grafici, rapporti e previsioni. La creazione di modelli predittivi richiederà molte iterazioni dell'ingegneria delle funzionalità con estrazione e produzione di informazioni.

Uscita intermedia

Questa è la track list degli output generati. Si dice anche che anche gli esperimenti falliti abbiano dei risultati. Il monitoraggio dell'output di ogni iterazione aiuterà a creare un output migliore nella prossima iterazione.

Esperimenti di prototipi

Gli esperimenti sui prototipi implicano l'assegnazione di compiti e la generazione di output secondo gli esperimenti. In un determinato compito, dobbiamo iterare per ottenere insight e queste iterazioni possono essere spiegate al meglio come esperimenti.

Integrazione dei dati

Il ciclo di vita dello sviluppo del software comprende diverse fasi con dati essenziali per:

• customers

• sviluppatori e

• l'attività

L'integrazione dei dati apre la strada a prospettive e risultati migliori.

Valore dei dati della piramide

Il valore piramidale di cui sopra descriveva i livelli necessari per lo sviluppo della "scienza dei dati Agile". Inizia con una raccolta di record basata sui requisiti e sui singoli record idraulici. I grafici vengono creati dopo la pulizia e l'aggregazione dei dati. I dati aggregati possono essere utilizzati per la visualizzazione dei dati. I report vengono generati con una struttura, metadati e tag di dati adeguati. Il secondo strato di piramide dall'alto include l'analisi di previsione. Il livello di previsione è dove viene creato più valore, ma aiuta a creare buone previsioni incentrate sull'ingegneria delle funzionalità.

Il livello più alto comprende azioni in cui il valore dei dati è guidato in modo efficace. La migliore illustrazione di questa implementazione è "Intelligenza artificiale".

In questo capitolo ci concentreremo sui concetti del ciclo di vita dello sviluppo del software chiamato "agile". La metodologia di sviluppo software Agile aiuta nella creazione di un software attraverso sessioni incrementali in brevi iterazioni da 1 a 4 settimane in modo che lo sviluppo sia allineato ai mutevoli requisiti aziendali.

Ci sono 12 principi che descrivono in dettaglio la metodologia Agile:

Soddisfazione dei clienti

La massima priorità viene data ai clienti che si concentrano sui requisiti attraverso la consegna tempestiva e continua di software di valore.

Accogliere nuovi cambiamenti

Le modifiche sono accettabili durante lo sviluppo del software. I processi agili sono progettati per funzionare al fine di abbinare il vantaggio competitivo del cliente.

Consegna

La consegna di un software funzionante viene data ai clienti in un arco di tempo compreso tra una e quattro settimane.

Collaborazione

Gli analisti aziendali, gli analisti della qualità e gli sviluppatori devono collaborare durante l'intero ciclo di vita del progetto.

Motivazione

I progetti dovrebbero essere progettati con un clan di individui motivati. Fornisce un ambiente per supportare i singoli membri del team.

Conversazione personale

La conversazione faccia a faccia è il metodo più efficiente ed efficace per inviare informazioni ae all'interno di un team di sviluppo.

Misurare i progressi

Misurare il progresso è la chiave che aiuta a definire il progresso del progetto e dello sviluppo del software.

Mantenere un ritmo costante

Il processo Agile si concentra sullo sviluppo sostenibile. L'azienda, gli sviluppatori e gli utenti dovrebbero essere in grado di mantenere un ritmo costante con il progetto.

Monitoraggio

È obbligatorio mantenere un'attenzione regolare all'eccellenza tecnica e al buon design per migliorare la funzionalità agile.

Semplicità

Il processo agile mantiene tutto semplice e utilizza termini semplici per misurare il lavoro che non è stato completato.

Termini auto-organizzati

Un team agile dovrebbe essere auto-organizzato e dovrebbe essere indipendente con la migliore architettura; requisiti e progetti emergono da team auto-organizzati.

Rivedi il lavoro

È importante rivedere il lavoro a intervalli regolari in modo che il team possa riflettere su come procede il lavoro. La revisione tempestiva del modulo migliorerà le prestazioni.

Stand-up quotidiano

Lo stand-up quotidiano si riferisce alla riunione quotidiana sullo stato dei membri del team. Fornisce aggiornamenti relativi allo sviluppo del software. Si riferisce anche all'affrontare gli ostacoli allo sviluppo del progetto.

Lo stare in piedi quotidianamente è una pratica obbligatoria, indipendentemente da come viene stabilito un team agile, indipendentemente dalla posizione dell'ufficio.

L'elenco delle caratteristiche di uno stand-up quotidiano è il seguente:

• La durata dell'incontro quotidiano in piedi dovrebbe essere di circa 15 minuti. Non dovrebbe estendersi per una durata maggiore.

• Lo stand-up dovrebbe includere discussioni sull'aggiornamento dello stato.

• I partecipanti a questo incontro di solito stanno con l'intenzione di finire per incontrarsi rapidamente.

Storia dell'utente

Una storia è solitamente un requisito, che è formulato in poche frasi in un linguaggio semplice e dovrebbe essere completato all'interno di un'iterazione. Una user story dovrebbe includere le seguenti caratteristiche:

• Tutto il codice correlato dovrebbe avere i relativi check-in.

• I casi di unit test per l'iterazione specificata.

• Dovrebbero essere definiti tutti i casi di test di accettazione.

• Accettazione da parte del proprietario del prodotto durante la definizione della storia.

Cos'è Scrum?

Scrum può essere considerato come un sottoinsieme della metodologia agile. È un processo leggero e include le seguenti caratteristiche:

• È una struttura di processo, che include una serie di pratiche che devono essere seguite in ordine coerente. La migliore illustrazione di Scrum è seguire iterazioni o sprint.

• È un processo "leggero", il che significa che il processo è mantenuto il più piccolo possibile, per massimizzare la produzione produttiva in una data durata specificata.

Il processo Scrum è noto per il suo processo distintivo rispetto ad altre metodologie dell'approccio agile tradizionale. È suddiviso nelle seguenti tre categorie:

• Roles

• Artifacts

• Time Boxes

I ruoli definiscono i membri del team e i loro ruoli inclusi durante il processo. Lo Scrum Team è composto dai seguenti tre ruoli:

• Maestro di mischia

• Proprietario del prodotto

• Team

Gli artefatti di Scrum forniscono informazioni chiave di cui ogni membro dovrebbe essere a conoscenza. Le informazioni includono i dettagli del prodotto, delle attività pianificate e delle attività completate. Gli artefatti definiti nel framework Scrum sono i seguenti:

• Backlog di prodotto

• Backlog di sprint

• Brucia il grafico

• Increment

Le caselle temporali sono le storie degli utenti pianificate per ogni iterazione. Queste storie utente aiutano a descrivere le caratteristiche del prodotto che fanno parte degli artefatti di Scrum. Il backlog del prodotto è un elenco di storie degli utenti. Queste storie utente vengono assegnate in base alla priorità e inoltrate alle riunioni degli utenti per decidere quale dovrebbe essere ripresa.

Perché Scrum Master?

Scrum Master interagisce con ogni membro del team. Vediamo ora l'interazione dello Scrum Master con altri team e risorse.

Proprietario del prodotto

Lo Scrum Master interagisce con il proprietario del prodotto nei seguenti modi:

• Trovare le tecniche per ottenere un backlog di prodotto efficace delle storie degli utenti e gestirle.

• Aiutare il team a comprendere le esigenze di elementi del backlog di prodotto chiari e concisi.

• Pianificazione del prodotto con ambiente specifico.

• Garantire che il proprietario del prodotto sappia come aumentare il valore del prodotto.

• Facilitare gli eventi Scrum come e quando richiesto.

Scrum Team

Lo Scrum Master interagisce con il team in diversi modi:

• Coaching l'organizzazione nell'adozione di Scrum.

• Pianificare le implementazioni di Scrum per l'organizzazione specifica.

• Aiutare i dipendenti e le parti interessate a comprendere i requisiti e le fasi di sviluppo del prodotto.

• Lavorare con Scrum Master di altri team per aumentare l'efficacia dell'applicazione di Scrum del team specificato.

Organizzazione

Lo Scrum Master interagisce con l'organizzazione in diversi modi. Alcuni sono menzionati di seguito:

• Il coaching e il team di mischia interagiscono con l'auto-organizzazione e includono una funzionalità di funzionalità incrociata.

• Coaching dell'organizzazione e dei team in quelle aree in cui Scrum non è ancora completamente adottato o non è accettato.

Vantaggi di Scrum

Scrum aiuta clienti, membri del team e stakeholder a collaborare. Include un approccio timebox e un feedback continuo da parte del proprietario del prodotto che garantisce che il prodotto sia in condizioni di lavoro. Scrum offre vantaggi ai diversi ruoli del progetto.

Cliente

Gli sprint o le iterazioni sono considerati per una durata più breve e le storie degli utenti sono progettate secondo priorità e vengono prese in considerazione durante la pianificazione dello sprint. Assicura che ogni consegna sprint, i requisiti dei clienti siano soddisfatti. In caso contrario, i requisiti vengono annotati, pianificati e presi per lo sprint.

Organizzazione

L'organizzazione con l'aiuto di Scrum e Scrum master può concentrarsi sugli sforzi necessari per lo sviluppo di user story riducendo così il sovraccarico di lavoro ed evitando eventuali rielaborazioni. Questo aiuta anche a mantenere una maggiore efficienza del team di sviluppo e la soddisfazione del cliente. Questo approccio aiuta anche ad aumentare il potenziale del mercato.

Responsabili del prodotto

La responsabilità principale dei responsabili del prodotto è garantire il mantenimento della qualità del prodotto. Con l'aiuto di Scrum Masters, diventa facile facilitare il lavoro, raccogliere risposte rapide e assorbire eventuali cambiamenti. I responsabili di prodotto verificano anche che il prodotto progettato sia allineato secondo i requisiti del cliente in ogni sprint.

Team di sviluppo

Con la natura time-boxed e mantenendo gli sprint per un periodo di tempo inferiore, il team di sviluppo diventa entusiasta nel vedere che il lavoro viene riflesso e consegnato correttamente. Il prodotto funzionante incrementa ogni livello dopo ogni iterazione o meglio possiamo chiamarli “sprint”. Le storie degli utenti progettate per ogni sprint diventano la priorità del cliente aggiungendo più valore all'iterazione.

Conclusione

Scrum è un framework efficiente all'interno del quale è possibile sviluppare software in team. È completamente progettato su principi agili. ScrumMaster è lì per aiutare e cooperare al team di Scrum in ogni modo possibile. Si comporta come un personal trainer che ti aiuta a rispettare il piano progettato e ad eseguire tutte le attività come da piano. L'autorità di ScrumMaster non dovrebbe mai estendersi oltre il processo. Dovrebbe essere potenzialmente in grado di gestire ogni situazione.

In questo capitolo, comprenderemo il processo di data science e le terminologie necessarie per comprendere il processo.

"La scienza dei dati è la miscela di interfaccia dati, sviluppo di algoritmi e tecnologia per risolvere problemi analitici complessi".

La scienza dei dati è un campo interdisciplinare che comprende metodi, processi e sistemi scientifici con categorie incluse in esso come apprendimento automatico, matematica e conoscenza statistica con la ricerca tradizionale. Include anche una combinazione di capacità di hacking con competenze sostanziali. La scienza dei dati trae principi da matematica, statistica, scienza dell'informazione e informatica, data mining e analisi predittiva.

I diversi ruoli che fanno parte del team di data science sono menzionati di seguito:

Clienti

I clienti sono le persone che utilizzano il prodotto. Il loro interesse determina il successo del progetto e il loro feedback è molto prezioso nella scienza dei dati.

Sviluppo aziendale

Questo team di data science firma i primi clienti, in prima persona o attraverso la creazione di pagine di destinazione e promozioni. Il team di sviluppo aziendale offre il valore del prodotto.

Responsabili del prodotto

I responsabili di prodotto prendono l'importanza di creare il miglior prodotto, che è prezioso nel mercato.

Designer di interazione

Si concentrano sulle interazioni di progettazione attorno ai modelli di dati in modo che gli utenti trovino il valore appropriato.

Scienziati di dati

I data scientist esplorano e trasformano i dati in nuovi modi per creare e pubblicare nuove funzionalità. Questi scienziati combinano anche dati provenienti da diverse fonti per creare un nuovo valore. Svolgono un ruolo importante nella creazione di visualizzazioni con ricercatori, ingegneri e sviluppatori web.

Ricercatori

Come indica il nome, i ricercatori sono coinvolti in attività di ricerca. Risolvono problemi complicati, cosa che i data scientist non possono fare. Questi problemi comportano un'intensa concentrazione e tempo di apprendimento automatico e modulo statistico.

Adattarsi al cambiamento

Tutti i membri del team di data science devono adattarsi ai nuovi cambiamenti e lavorare sulla base dei requisiti. Diversi cambiamenti dovrebbero essere fatti per l'adozione di una metodologia agile con la scienza dei dati, che sono menzionati come segue:

• Scegliere i generalisti rispetto agli specialisti.

• Preferenza di piccoli team rispetto a grandi team.

• Utilizzo di strumenti e piattaforme di alto livello.

• Condivisione continua e iterativa del lavoro intermedio.

Note

Nel team di data science Agile, un piccolo team di generalisti utilizza strumenti di alto livello scalabili e perfeziona i dati attraverso iterazioni in stati di valore sempre più elevati.

Considera i seguenti esempi relativi al lavoro dei membri del team di data science:

• I designer forniscono CSS.

• Gli sviluppatori Web creano intere applicazioni, comprendono l'esperienza dell'utente e il design dell'interfaccia.

• I data scientist dovrebbero lavorare sia sulla ricerca che sulla creazione di servizi web, comprese le applicazioni web.

• I ricercatori lavorano in base al codice, che mostra i risultati che spiegano i risultati intermedi.

• I responsabili di prodotto cercano di identificare e comprendere i difetti in tutte le aree correlate.

In questo capitolo, impareremo a conoscere i diversi strumenti Agile e la loro installazione. Lo stack di sviluppo della metodologia agile include il seguente set di componenti:

Eventi

Un evento è un evento che si verifica o viene registrato insieme alle sue caratteristiche e timestamp.

Un evento può presentarsi in molte forme come server, sensori, transazioni finanziarie o azioni, che i nostri utenti intraprendono nella nostra applicazione. In questo tutorial completo, utilizzeremo file JSON che faciliteranno lo scambio di dati tra diversi strumenti e linguaggi.

Collezionisti

I collezionisti sono aggregatori di eventi. Raccolgono eventi in modo sistematico per archiviare e aggregare dati ingombranti mettendoli in coda per l'azione da parte dei lavoratori in tempo reale.

Documento distribuito

Questi documenti includono multinode (più nodi) che memorizza il documento in un formato specifico. Ci concentreremo su MongoDB in questo tutorial.

Server di applicazioni Web

Il server di applicazioni Web abilita i dati come JSON tramite il client tramite la visualizzazione, con un sovraccarico minimo. Significa che il server di applicazioni Web aiuta a testare e distribuire i progetti creati con una metodologia agile.

Browser moderno

Consente al browser o all'applicazione moderni di presentare i dati come strumento interattivo per i nostri utenti.

Configurazione ambientale locale

Per la gestione dei set di dati, ci concentreremo sul framework Anaconda di python che include strumenti per la gestione di excel, csv e molti altri file. La dashboard di Anaconda framework una volta installato è come mostrato di seguito. È anche chiamato "Anaconda Navigator" -

Il navigatore include il “framework Jupyter” che è un sistema notebook che aiuta a gestire i dataset. Una volta avviato il framework, verrà ospitato nel browser come indicato di seguito:

In questo capitolo ci concentreremo sulla differenza tra dati strutturati, semi-strutturati e non strutturati.

Dati strutturati

I dati strutturati riguardano i dati archiviati in formato SQL in tabelle con righe e colonne. Include una chiave relazionale, mappata in campi predefiniti. I dati strutturati vengono utilizzati su scala più ampia.

I dati strutturati rappresentano solo il 5-10 percento di tutti i dati informatici.

Dati semistrutturati

I dati semistrutturati includono dati che non risiedono nel database relazionale. Includono alcune proprietà organizzative che ne semplificano l'analisi. Include lo stesso processo per memorizzarli nel database relazionale. Gli esempi di database semi-strutturato sono file CSV, documenti XML e JSON. I database NoSQL sono considerati semistrutturati.

Dati non strutturati

I dati non strutturati rappresentano l'80% dei dati. Spesso include testo e contenuti multimediali. I migliori esempi di dati non strutturati includono file audio, presentazioni e pagine web. Gli esempi di dati non strutturati generati dalla macchina sono immagini satellitari, dati scientifici, fotografie e dati video, radar e sonar.

La struttura piramidale di cui sopra si concentra specificamente sulla quantità di dati e sul rapporto su cui sono sparsi.

I dati quasi strutturati vengono visualizzati come tipo tra dati non strutturati e semi-strutturati. In questo tutorial, ci concentreremo sui dati semi-strutturati, utili per la metodologia agile e la ricerca scientifica dei dati.

I dati semistrutturati non hanno un modello di dati formale, ma hanno un modello e una struttura apparenti e auto-descrittivi sviluppati dalla loro analisi.

L'obiettivo completo di questo tutorial è seguire la metodologia agile con un numero inferiore di passaggi e con l'implementazione di strumenti più utili. Per capirlo, è importante conoscere la differenza tra database SQL e NoSQL.

La maggior parte degli utenti conosce il database SQL e ha una buona conoscenza di MySQL, Oracle o altri database SQL. Negli ultimi anni, il database NoSQL è stato ampiamente adottato per risolvere vari problemi aziendali e requisiti di progetto.

La tabella seguente mostra la differenza tra database SQL e NoSQL:

SQL	NoSQL
I database SQL sono principalmente chiamati Relational Database Management System (RDBMS).	Il database NoSQL è anche chiamato database orientato ai documenti. Non è relazionale e distribuito.
I database basati su SQL includono la struttura della tabella con righe e colonne. Raccolta di tabelle e altre strutture di schemi denominate database.	Il database NoSQL include documenti come struttura principale e l'inclusione di documenti è chiamata raccolta.
I database SQL includono uno schema predefinito.	I database NoSQL hanno dati dinamici e includono dati non strutturati.
I database SQL sono scalabili in verticale.	I database NoSQL sono scalabili orizzontalmente.
I database SQL sono adatti per ambienti di query complessi.	NoSQL non dispone di interfacce standard per lo sviluppo di query complesse.
I database SQL non sono fattibili per l'archiviazione gerarchica dei dati.	I database NoSQL si adattano meglio per l'archiviazione gerarchica dei dati.
I database SQL si adattano meglio a transazioni pesanti nelle applicazioni specificate.	I database NoSQL non sono ancora considerati comparabili in condizioni di carico elevato per applicazioni transazionali complesse.
I database SQL forniscono un eccellente supporto per i loro fornitori.	Il database NoSQL si basa ancora sul supporto della comunità. Solo pochi esperti sono disponibili per la configurazione e la distribuzione per distribuzioni NoSQL su larga scala.
I database SQL si concentrano sulle proprietà ACID: atomica, coerenza, isolamento e durata.	Il database NoSQL si concentra sulle proprietà della CAP: coerenza, disponibilità e tolleranza delle partizioni.
I database SQL possono essere classificati come open source o closed source in base ai fornitori che li hanno scelti.	I database NoSQL sono classificati in base al tipo di archiviazione. I database NoSQL sono open source per impostazione predefinita.

Perché NoSQL per Agile?

Il suddetto confronto mostra che il database dei documenti NoSQL supporta completamente lo sviluppo agile. È senza schema e non si concentra completamente sulla modellazione dei dati. Invece, NoSQL differisce applicazioni e servizi e quindi gli sviluppatori hanno un'idea migliore di come i dati possono essere modellati. NoSQL definisce il modello di dati come modello di applicazione.

Installazione di MongoDB

In questo tutorial, ci concentreremo maggiormente sugli esempi di MongoDB poiché è considerato il miglior "schema NoSQL".

Ci sono momenti in cui i dati non sono disponibili in formato relazionale e dobbiamo mantenerli transazionali con l'aiuto dei database NoSQL.

In questo capitolo, ci concentreremo sul flusso di dati di NoSQL. Impareremo anche come funziona con una combinazione di agile e data science.

Uno dei motivi principali per utilizzare NoSQL con Agile è aumentare la velocità con la concorrenza del mercato. I seguenti motivi mostrano come NoSQL sia la soluzione migliore per la metodologia software agile:

Meno barriere

Cambiare il modello, che attualmente sta attraversando il mid-stream, ha dei costi reali anche in caso di sviluppo agile. Con NoSQL, gli utenti lavorano con dati aggregati invece di perdere tempo nella normalizzazione dei dati. Il punto principale è fare qualcosa e lavorare con l'obiettivo di rendere i dati perfetti del modello.

Scalabilità aumentata

Ogni volta che un'organizzazione crea un prodotto, pone maggiormente l'accento sulla sua scalabilità. NoSQL è sempre noto per la sua scalabilità ma funziona meglio quando è progettato con scalabilità orizzontale.

Capacità di sfruttare i dati

NoSQL è un modello di dati senza schema che consente all'utente di utilizzare prontamente volumi di dati, che include diversi parametri di variabilità e velocità. Quando si considera una scelta di tecnologia, si dovrebbe sempre considerare quella che sfrutta i dati su una scala maggiore.

Flusso di dati di NoSQL

Consideriamo il seguente esempio in cui abbiamo mostrato come un modello di dati è focalizzato sulla creazione dello schema RDBMS.

Di seguito sono riportati i diversi requisiti dello schema:

• Dovrebbe essere elencata l'identificazione dell'utente.

• Ogni utente dovrebbe avere almeno un'abilità obbligatoria.

• I dettagli dell'esperienza di ogni utente dovrebbero essere mantenuti correttamente.

La tabella utente è normalizzata con 3 tabelle separate -

• Users

• Abilità dell'utente

• L'esperienza utente

La complessità aumenta durante l'interrogazione del database e il consumo di tempo viene notato con una maggiore normalizzazione che non è buona per la metodologia Agile. Lo stesso schema può essere progettato con il database NoSQL come indicato di seguito -

NoSQL mantiene la struttura in formato JSON, che è leggero nella struttura. Con JSON, le applicazioni possono archiviare oggetti con dati nidificati come documenti singoli.

In questo capitolo ci concentreremo sulla struttura JSON, che fa parte della "metodologia Agile". MongoDB è una struttura dati NoSQL ampiamente utilizzata e funziona facilmente per la raccolta e la visualizzazione dei record.

Passo 1

Questo passaggio prevede la creazione di una connessione con MongoDB per la creazione della raccolta e del modello di dati specificato. Tutto ciò che devi eseguire è il comando "mongod" per avviare la connessione e il comando mongo per connettersi al terminale specificato.

Passo 2

Crea un nuovo database per la creazione di record in formato JSON. Per ora, stiamo creando un database fittizio denominato "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

Passaggio 3

La creazione della raccolta è obbligatoria per ottenere l'elenco dei record. Questa funzione è utile per la ricerca e i risultati della scienza dei dati.

>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 visualizzazione dei dati gioca un ruolo molto importante nella scienza dei dati. Possiamo considerare la visualizzazione dei dati come un modulo di scienza dei dati. La scienza dei dati include più della semplice creazione di modelli predittivi. Include la spiegazione dei modelli e il loro utilizzo per comprendere i dati e prendere decisioni. La visualizzazione dei dati è parte integrante della presentazione dei dati nel modo più convincente.

Dal punto di vista della scienza dei dati, la visualizzazione dei dati è una caratteristica di evidenziazione che mostra i cambiamenti e le tendenze.

Considera le seguenti linee guida per una visualizzazione dei dati efficace:

• Posiziona i dati su una scala comune.

• L'uso delle barre è più efficace rispetto a cerchi e quadrati.

• Per i grafici a dispersione è necessario utilizzare il colore corretto.

• Usa il grafico a torta per mostrare le proporzioni.

• La visualizzazione Sunburst è più efficace per i grafici gerarchici.

Agile necessita di un semplice linguaggio di scripting per la visualizzazione dei dati e con la scienza dei dati in collaborazione "Python" è il linguaggio suggerito per la visualizzazione dei dati.

Esempio 1

L'esempio seguente mostra la visualizzazione dei dati del PIL calcolato in anni specifici. "Matplotlib" è la migliore libreria per la visualizzazione dei dati in Python. L'installazione di questa libreria è mostrata di seguito:

Considera il codice seguente per capirlo:

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()

Produzione

Il codice precedente genera il seguente output:

Esistono molti modi per personalizzare i grafici con etichette degli assi, stili di linea e indicatori di punto. Concentriamoci sul prossimo esempio che dimostra la migliore visualizzazione dei dati. Questi risultati possono essere utilizzati per un output migliore.

Esempio 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()

Produzione

Il codice precedente genera il seguente output:

L'arricchimento dei dati si riferisce a una serie di processi utilizzati per migliorare, perfezionare e migliorare i dati grezzi. Si riferisce alla trasformazione dei dati utili (dati grezzi a informazioni utili). Il processo di arricchimento dei dati si concentra sul rendere i dati una risorsa di dati preziosa per le aziende moderne.

Il processo di arricchimento dei dati più comune include la correzione di errori di ortografia o errori tipografici nel database attraverso l'uso di algoritmi decisionali specifici. Gli strumenti di arricchimento dei dati aggiungono informazioni utili a semplici tabelle di dati.

Considera il seguente codice per la correzione ortografica delle parole:

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'))

In questo programma, faremo corrispondere con "big.txt" che include le parole corrette. Le parole corrispondono alle parole incluse nel file di testo e stampano i risultati appropriati di conseguenza.

Produzione

Il codice sopra genererà il seguente output:

In questo capitolo, impareremo la creazione di report, che è un modulo importante della metodologia agile. Pagine dei grafici degli sprint agili create dalla visualizzazione in report completi. Con i report, i grafici diventano interattivi, le pagine statiche diventano dinamiche e dati relativi alla rete. Di seguito sono riportate le caratteristiche della fase di report della piramide del valore dei dati:

Metteremo più l'accento sulla creazione di file csv, che può essere utilizzato come report per l'analisi della scienza dei dati e per trarre conclusioni. Sebbene Agile si concentri su una minore documentazione, viene sempre presa in considerazione la generazione di report per menzionare l'avanzamento dello sviluppo del prodotto.

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)

Il codice sopra ti aiuterà a generare il "file csv" come mostrato di seguito -

Consideriamo i seguenti vantaggi dei rapporti csv (valori separati da virgola):

• È amichevole e facile da modificare manualmente.
• È semplice da implementare e analizzare.
• CSV può essere elaborato in tutte le applicazioni.
• È più piccolo e più veloce da gestire.
• CSV segue un formato standard.
• Fornisce uno schema semplice per i data scientist.

In questo capitolo, guadagneremo sul ruolo delle previsioni nella scienza dei dati agile. I report interattivi espongono diversi aspetti dei dati. Le previsioni costituiscono il quarto livello dello sprint agile.

Quando si effettuano previsioni, ci riferiamo sempre ai dati passati e li usiamo come inferenze per iterazioni future. In questo processo completo, trasferiamo i dati dall'elaborazione batch dei dati storici ai dati in tempo reale sul futuro.

Il ruolo delle previsioni include quanto segue:

• Le previsioni aiutano nella previsione. Alcune previsioni si basano su inferenze statistiche. Alcune delle previsioni si basano su opinioni di esperti.

• L'inferenza statistica è coinvolta con previsioni di tutti i tipi.

• A volte le previsioni sono accurate, mentre a volte le previsioni sono imprecise.

Analisi predittiva

L'analisi predittiva include una varietà di tecniche statistiche dalla modellazione predittiva, all'apprendimento automatico e al data mining che analizzano fatti attuali e storici per fare previsioni su eventi futuri e sconosciuti.

L'analisi predittiva richiede dati di addestramento. I dati addestrati includono funzionalità indipendenti e dipendenti. Le caratteristiche dipendenti sono i valori che un utente sta cercando di prevedere. Le caratteristiche indipendenti sono caratteristiche che descrivono le cose che vogliamo prevedere in base alle caratteristiche dipendenti.

Lo studio delle caratteristiche è chiamato ingegneria delle caratteristiche; questo è fondamentale per fare previsioni. La visualizzazione dei dati e l'analisi esplorativa dei dati sono parti dell'ingegneria delle funzionalità; questi costituiscono il nucleo diAgile data science.

Fare previsioni

Esistono due modi per fare previsioni nella scienza dei dati agile:

• Regression

• Classification

La creazione di una regressione o di una classificazione dipende completamente dai requisiti aziendali e dalla sua analisi. La previsione della variabile continua porta al modello di regressione e la previsione delle variabili categoriali porta al modello di classificazione.

Regressione

La regressione considera gli esempi che comprendono le caratteristiche e, quindi, produce un output numerico.

Classificazione

La classificazione prende l'input e produce una classificazione categoriale.

Note - Il set di dati di esempio che definisce l'input per la previsione statistica e che consente alla macchina di apprendere è chiamato "dati di addestramento".

In questo capitolo, apprenderemo l'applicazione delle funzionalità di estrazione con PySpark in Agile Data Science.

Panoramica di Spark

Apache Spark può essere definito come un framework di elaborazione veloce in tempo reale. Esegue calcoli per analizzare i dati in tempo reale. Apache Spark viene introdotto come sistema di elaborazione del flusso in tempo reale e può anche occuparsi dell'elaborazione in batch. Apache Spark supporta query interattive e algoritmi iterativi.

Spark è scritto in “linguaggio di programmazione Scala”.

PySpark può essere considerato come una combinazione di Python con Spark. PySpark offre la shell PySpark, che collega l'API Python al core Spark e inizializza il contesto Spark. La maggior parte dei data scientist utilizza PySpark per il monitoraggio delle funzionalità, come discusso nel capitolo precedente.

In questo esempio, ci concentreremo sulle trasformazioni per creare un set di dati chiamato counts e salvarlo in un particolare file.

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://...")

Utilizzando PySpark, un utente può lavorare con RDD nel linguaggio di programmazione Python. La libreria integrata, che copre le basi dei documenti e dei componenti Data Driven, aiuta in questo.

La regressione logistica si riferisce all'algoritmo di apprendimento automatico utilizzato per prevedere la probabilità della variabile dipendente categoriale. Nella regressione logistica, la variabile dipendente è una variabile binaria, che consiste di dati codificati come 1 (valori booleani di vero e falso).

In questo capitolo, ci concentreremo sullo sviluppo di un modello di regressione in Python utilizzando la variabile continua. L'esempio del modello di regressione lineare si concentrerà sull'esplorazione dei dati dal file CSV.

L'obiettivo della classificazione è prevedere se il cliente sottoscriverà (1/0) un deposito a termine.

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))

Segui questi passaggi per implementare il codice sopra in Anaconda Navigator con "Jupyter Notebook" -

Step 1 - Avvia il Jupyter Notebook con Anaconda Navigator.

Step 2 - Carica il file csv per ottenere l'output del modello di regressione in modo sistematico.

Step 3 - Creare un nuovo file ed eseguire la suddetta riga di codice per ottenere l'output desiderato.

In questo esempio, impareremo come creare e distribuire un modello predittivo che aiuta nella previsione dei prezzi delle case utilizzando lo script Python. L'importante framework utilizzato per l'implementazione del sistema predittivo include Anaconda e "Jupyter Notebook".

Segui questi passaggi per distribuire un sistema predittivo:

Step 1 - Implementa il codice seguente per convertire i valori dai file CSV ai valori associati.

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()

Il codice precedente genera il seguente output:

Step 2 - Esegui la funzione di descrizione per ottenere i tipi di dati inclusi negli attributi dei file csv.

data.describe()

Step 3 - Possiamo eliminare i valori associati in base alla distribuzione del modello predittivo che abbiamo creato.

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

Step 4- Puoi visualizzare i dati come da record. I dati possono essere utilizzati per l'analisi della scienza dei dati e l'output di white paper.

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

La libreria di machine learning chiamata anche "SparkML" o "MLLib" è costituita da algoritmi di apprendimento comuni, tra cui classificazione, regressione, clustering e filtraggio collaborativo.

Perché imparare SparkML per Agile?

Spark sta diventando la piattaforma di fatto per la creazione di algoritmi e applicazioni di machine learning. Gli sviluppatori lavorano su Spark per implementare algoritmi della macchina in modo scalabile e conciso nel framework Spark. Impareremo i concetti di Machine learning, le sue utilità e algoritmi con questo framework. Agile sceglie sempre un framework, che fornisce risultati brevi e rapidi.

Algoritmi ML

Gli algoritmi ML includono algoritmi di apprendimento comuni come classificazione, regressione, clustering e filtraggio collaborativo.

Caratteristiche

Include l'estrazione, la trasformazione, la riduzione delle dimensioni e la selezione delle caratteristiche.

Condutture

Le pipeline forniscono strumenti per la costruzione, la valutazione e l'ottimizzazione delle pipeline di machine learning.

Algoritmi popolari

Di seguito sono riportati alcuni algoritmi popolari:

• Statistiche di base

• Regression

• Classification

• Sistema di raccomandazione

• Clustering

• Riduzione della dimensionalità

• Estrazione delle caratteristiche

• Optimization

Sistema di raccomandazione

Un sistema di raccomandazione è una sottoclasse del sistema di filtraggio delle informazioni che cerca la previsione di "valutazione" e "preferenza" che un utente suggerisce a un dato elemento.

Il sistema di raccomandazione include vari sistemi di filtraggio, che vengono utilizzati come segue:

Filtraggio collaborativo

Comprende la creazione di un modello basato sul comportamento passato e su decisioni simili prese da altri utenti. Questo modello di filtro specifico viene utilizzato per prevedere gli elementi che un utente è interessato a prendere.

Filtro basato sui contenuti

Include il filtraggio delle caratteristiche discrete di un articolo per consigliare e aggiungere nuovi articoli con proprietà simili.

Nei capitoli successivi, ci concentreremo sull'uso del sistema di raccomandazione per risolvere un problema specifico e migliorare le prestazioni di previsione dal punto di vista della metodologia agile.

In questo capitolo, ci concentreremo sulla risoluzione di un problema di previsione con l'aiuto di uno scenario specifico.

Considera che un'azienda desidera automatizzare i dettagli di ammissibilità del prestito secondo i dettagli del cliente forniti tramite il modulo di domanda online. I dettagli includono nome del cliente, sesso, stato civile, importo del prestito e altri dettagli obbligatori.

I dettagli vengono registrati nel file CSV come mostrato di seguito -

Esegui il codice seguente per valutare il problema di previsione:

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)

Produzione

Il codice precedente genera il seguente output.

In questo capitolo, ci concentreremo sulla costruzione di un modello che aiuti nella previsione delle prestazioni dello studente con una serie di attributi inclusi in esso. L'obiettivo è visualizzare il risultato del fallimento degli studenti in un esame.

Processi

Il valore target della valutazione è G3. Questi valori possono essere raggruppati e ulteriormente classificati come insuccesso e successo. Se il valore G3 è maggiore o uguale a 10, lo studente supera l'esame.

Esempio

Considera il seguente esempio in cui viene eseguito un codice per prevedere le prestazioni se gli studenti:

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()

Produzione

Il codice precedente genera l'output come mostrato di seguito

La previsione viene trattata con riferimento a una sola variabile. Con riferimento a una variabile, la previsione del rendimento degli studenti è come mostrato di seguito:

La metodologia Agile aiuta le organizzazioni ad adattare il cambiamento, competere sul mercato e costruire prodotti di alta qualità. Si osserva che le organizzazioni maturano con una metodologia agile, con un cambiamento crescente nei requisiti dei clienti. La compilazione e la sincronizzazione dei dati con i team agili dell'organizzazione è importante per il raggruppamento dei dati secondo il portfolio richiesto.

Crea un piano migliore

Le prestazioni agili standardizzate dipendono esclusivamente dal piano. Lo schema di dati ordinato potenzia la produttività, la qualità e la reattività del progresso dell'organizzazione. Il livello di coerenza dei dati viene mantenuto con scenari storici e in tempo reale.

Considera il diagramma seguente per comprendere il ciclo di esperimenti di scienza dei dati:

La data science prevede l'analisi dei requisiti seguita dalla creazione di algoritmi basati sugli stessi. Una volta che gli algoritmi sono stati progettati insieme alla configurazione ambientale, un utente può creare esperimenti e raccogliere dati per una migliore analisi.

Questa ideologia calcola l'ultimo sprint di agile, che si chiama "azioni".

Actionscoinvolge tutti i compiti obbligatori per l'ultimo sprint o livello di metodologia agile. La traccia delle fasi di data science (rispetto al ciclo di vita) può essere mantenuta con le story card come elementi di azione.

Analisi predittiva e Big Data

Il futuro della pianificazione risiede completamente nella personalizzazione dei report di dati con i dati raccolti dall'analisi. Comprenderà anche la manipolazione con l'analisi dei big data. Con l'aiuto dei big data, possono essere analizzate informazioni discrete, in modo efficace affettando e sminuzzando le metriche dell'organizzazione. L'analisi è sempre considerata una soluzione migliore.

Esistono varie metodologie utilizzate nel processo di sviluppo agile. Queste metodologie possono essere utilizzate anche per il processo di ricerca scientifica dei dati.

Il diagramma di flusso fornito di seguito mostra le diverse metodologie:

Mischia

In termini di sviluppo software, scrum significa gestire il lavoro con un piccolo team e la gestione di un progetto specifico per rivelare i punti di forza e di debolezza del progetto.

Metodologie di cristallo

Le metodologie Crystal includono tecniche innovative per la gestione e l'esecuzione del prodotto. Con questo metodo, i team possono svolgere attività simili in modi diversi. La famiglia Crystal è una delle metodologie più facili da applicare.

Metodo di sviluppo software dinamico

Questo framework di consegna viene utilizzato principalmente per implementare l'attuale sistema di conoscenza nella metodologia del software.

Sviluppo guidato dal futuro

Il fulcro di questo ciclo di vita dello sviluppo sono le caratteristiche coinvolte nel progetto. Funziona meglio per la modellazione di oggetti di dominio, lo sviluppo di codice e funzionalità per la proprietà.

Sviluppo di software snello

Programmazione estrema

La programmazione estrema è una metodologia di sviluppo software unica, che si concentra sul miglioramento della qualità del software. Ciò è efficace quando il cliente non è sicuro della funzionalità di qualsiasi progetto.

Le metodologie agili stanno prendendo piede nel flusso della scienza dei dati ed è considerata l'importante metodologia del software. Con un'agile auto-organizzazione, i team interfunzionali possono lavorare insieme in modo efficace. Come accennato, esistono sei categorie principali di sviluppo agile e ognuna di esse può essere trasmessa in streaming con la scienza dei dati secondo i requisiti. La scienza dei dati implica un processo iterativo per approfondimenti statistici. Agile aiuta a scomporre i moduli di data science e aiuta a elaborare iterazioni e sprint in modo efficace.

Il processo di Agile Data Science è un modo straordinario per capire come e perché viene implementato il modulo di data science. Risolve i problemi in modo creativo.