Condividi tramite

Parte 2 dell'esercitazione: Esplorare e visualizzare i dati usando i notebook di Microsoft Fabric

  • Articolo

In questa esercitazione si apprenderà come eseguire l'analisi esplorativa dei dati (EDA) per esaminare e analizzare i dati riepilogando le caratteristiche principali tramite l'uso di tecniche di visualizzazione dei dati.

Si userà seaborn, una libreria di visualizzazione dei dati Python che fornisce un'interfaccia di alto livello per la compilazione di oggetti visivi su dataframe e matrici. Per altre informazioni su seaborn, vedere Seaborn: Visualizzazione dati statistici.

Si userà anche Data Wrangler, uno strumento basato su notebook che offre un'esperienza immersiva per eseguire analisi esplorative dei dati e pulizia.

I passaggi principali di questa esercitazione sono:

  1. Leggere i dati archiviati da una tabella delta nella lakehouse.
  2. Convertire un dataframe Spark in dataframe Pandas, supportato da librerie di visualizzazioni Python.
  3. Usare Data Wrangler per eseguire la pulizia e la trasformazione iniziali dei dati.
  4. Eseguire l'analisi esplorativa dei dati usando seaborn.

Prerequisiti

  • Ottenere una sottoscrizione di Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione gratuita di Microsoft Fabric.

  • Accedere a Microsoft Fabric.

  • Usare il commutatore esperienza sul lato sinistro della home page per passare all'esperienza di data science di Synapse.

    Screenshot del menu switcher dell'esperienza, che mostra dove selezionare Data Science.

Questa è la parte 2 di 5 nella serie di esercitazioni. Per completare questa esercitazione, completare prima di tutto:

Seguire la procedura nel notebook

2-explore-cleanse-data.ipynb è il notebook che accompagna questa esercitazione.

Per aprire il notebook a accompagnamento per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni sull'analisi scientifica dei dati per importare il notebook nell'area di lavoro.

Se si preferisce copiare e incollare il codice da questa pagina, è possibile creare un nuovo notebook.

Assicurarsi di collegare un lakehouse al notebook prima di iniziare a eseguire il codice.

Importante

Collegare la stessa lakehouse usata nella parte 1.

Leggere i dati non elaborati dal lakehouse

Leggere i dati non elaborati dalla sezione File del lakehouse. Questi dati sono stati caricati nel notebook precedente. Assicurarsi di aver collegato la stessa lakehouse usata nella parte 1 a questo notebook prima di eseguire questo codice.

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv("Files/churn/raw/churn.csv")
    .cache()
)

Creare un dataframe pandas dal set di dati

Convertire il dataframe spark in dataframe pandas per semplificare l'elaborazione e la visualizzazione.

df = df.toPandas()

Visualizzare i dati non elaborati

Esplorare i dati non elaborati con display, eseguire alcune statistiche di base e visualizzare le visualizzazioni del grafico. Si noti che è prima necessario importare le librerie necessarie, Numpyad esempio , Pnadas, Seaborne Matplotlib per l'analisi e la visualizzazione dei dati.

import seaborn as sns
sns.set_theme(style="whitegrid", palette="tab10", rc = {'figure.figsize':(9,6)})
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
from matplotlib import rc, rcParams
import numpy as np
import pandas as pd
import itertools

display(df, summary=True)

Usare Data Wrangler per eseguire la pulizia iniziale dei dati

Per esplorare e trasformare i dataframe pandas nel notebook, avviare Data Wrangler direttamente dal notebook.

Nota

I dati Wrangler non possono essere aperti mentre il kernel del notebook è occupato. L'esecuzione della cella deve essere completata prima di avviare Data Wrangler.

  1. Nella scheda Dati della barra multifunzione del notebook selezionare Avvia dati Wrangler. Verrà visualizzato un elenco di dataframe pandas attivati disponibili per la modifica.
  2. Selezionare il dataframe da aprire in Data Wrangler. Poiché questo notebook contiene solo un dataframe, dfselezionare df.

Screenshot che mostra come avviare il data wrangler da un notebook.

I dati Wrangler avviano e generano una panoramica descrittiva dei dati. La tabella al centro mostra ogni colonna di dati. Il pannello Riepilogo accanto alla tabella mostra informazioni sul dataframe. Quando si seleziona una colonna nella tabella, il riepilogo viene aggiornato con informazioni sulla colonna selezionata. In alcuni casi, i dati visualizzati e riepilogati saranno una visualizzazione troncata del dataframe. In questo caso, verrà visualizzata l'immagine di avviso nel riquadro di riepilogo. Passare il puntatore del mouse su questo avviso per visualizzare il testo che spiega la situazione.

Screenshot che mostra la panoramica di data wrangler.

Ogni operazione eseguita può essere applicata in pochi clic, aggiornando la visualizzazione dei dati in tempo reale e generando codice che è possibile salvare nuovamente nel notebook come funzione riutilizzabile.

La parte restante di questa sezione illustra i passaggi per eseguire la pulizia dei dati con Data Wrangler.

Eliminare righe duplicate

Nel pannello sinistro è riportato un elenco di operazioni, ad esempio Trova e sostituisci, Format, Formule, Numeric, che è possibile eseguire nel set di dati.

  1. Espandere Trova e sostituisci e selezionare Elimina righe duplicate.

    Screenshot che mostra l'eliminazione di righe duplicate in Trova e sostituisci.

  2. Viene visualizzato un pannello che consente di selezionare l'elenco di colonne da confrontare per definire una riga duplicata. Selezionare RowNumber e CustomerId.

    Nel pannello centrale è disponibile un'anteprima dei risultati di questa operazione. Nell'anteprima è il codice per eseguire l'operazione. In questo caso, i dati sembrano essere invariati. Tuttavia, poiché si sta esaminando una visualizzazione troncata, è consigliabile applicare ancora l'operazione.

    Screenshot che mostra l'eliminazione di righe duplicate in Data Wrangler.

  3. Selezionare Applica (sul lato o nella parte inferiore) per passare al passaggio successivo.

Eliminare righe con dati mancanti

Usare Data Wrangler per eliminare righe con dati mancanti in tutte le colonne.

  1. Selezionare Elimina valori mancanti in Trova e sostituisci.

  2. Scegliere Seleziona tutto dalle colonne di destinazione.

    Screenshot che mostra l'eliminazione di righe mancanti in Data Wrangler.

  3. Selezionare Applica per passare al passaggio successivo.

Elimina colonne

Usare Data Wrangler per eliminare colonne non necessarie.

  1. Espandere Schema e selezionare Rilascia colonne.

  2. Selezionare RowNumber, CustomerId, Surname. Queste colonne vengono visualizzate in rosso nell'anteprima, per mostrare che sono state modificate dal codice (in questo caso, rimosse).

    Screenshot che mostra l'eliminazione di colonne in Data Wrangler.

  3. Selezionare Applica per passare al passaggio successivo.

Aggiungere codice al notebook

Ogni volta che si seleziona Applica, viene creato un nuovo passaggio nel pannello Passaggi di pulizia in basso a sinistra. Nella parte inferiore del pannello selezionare Codice di anteprima per tutti i passaggi per visualizzare una combinazione di tutti i passaggi separati.

Selezionare Aggiungi codice al notebook in alto a sinistra per chiudere Data Wrangler e aggiungere automaticamente il codice. Il notebook Add code to notebook esegue il wrapping del codice in una funzione, quindi chiama la funzione .

Screenshot che mostra il codice di anteprima e dove accedere al notebook.

Suggerimento

Il codice generato da Data Wrangler non verrà applicato fino a quando non si esegue manualmente la nuova cella.

Se non si usa Data Wrangler, è invece possibile usare questa cella di codice successiva.

Questo codice è simile al codice prodotto da Data Wrangler, ma aggiunge nell'argomento inplace=True a ognuno dei passaggi generati. Impostando inplace=True, pandas sovrascriverà il dataframe originale anziché produrre un nuovo dataframe come output.

# Modified version of code generated by Data Wrangler 
# Modification is to add in-place=True to each step

# Define a new function that include all above Data Wrangler operations
def clean_data(df):
    # Drop rows with missing data across all columns
    df.dropna(inplace=True)
    # Drop duplicate rows in columns: 'RowNumber', 'CustomerId'
    df.drop_duplicates(subset=['RowNumber', 'CustomerId'], inplace=True)
    # Drop columns: 'RowNumber', 'CustomerId', 'Surname'
    df.drop(columns=['RowNumber', 'CustomerId', 'Surname'], inplace=True)
    return df

df_clean = clean_data(df.copy())
df_clean.head()

Esplorare i dati

Visualizzare alcuni riepiloghi e visualizzazioni dei dati puliti.

Determinare gli attributi categorici, numerici e di destinazione

Usare questo codice per determinare gli attributi categorici, numerici e di destinazione.

# Determine the dependent (target) attribute
dependent_variable_name = "Exited"
print(dependent_variable_name)
# Determine the categorical attributes
categorical_variables = [col for col in df_clean.columns if col in "O"
                        or df_clean[col].nunique() <=5
                        and col not in "Exited"]
print(categorical_variables)
# Determine the numerical attributes
numeric_variables = [col for col in df_clean.columns if df_clean[col].dtype != "object"
                        and df_clean[col].nunique() >5]
print(numeric_variables)

Riepilogo dei cinque numeri

Mostra il riepilogo a cinque numeri (punteggio minimo, primo quartile, mediano, terzo quartile, punteggio massimo) per gli attributi numerici, usando i tracciati box.

df_num_cols = df_clean[numeric_variables]
sns.set(font_scale = 0.7) 
fig, axes = plt.subplots(nrows = 2, ncols = 3, gridspec_kw =  dict(hspace=0.3), figsize = (17,8))
fig.tight_layout()
for ax,col in zip(axes.flatten(), df_num_cols.columns):
    sns.boxplot(x = df_num_cols[col], color='green', ax = ax)
fig.delaxes(axes[1,2])

Il grafico mostra i riepiloghi a cinque numeri.

Distribuzione dei clienti chiusi e non conxited

Mostra la distribuzione dei clienti chiusi rispetto ai clienti nonxited tra gli attributi categorici.

attr_list = ['Geography', 'Gender', 'HasCrCard', 'IsActiveMember', 'NumOfProducts', 'Tenure']
fig, axarr = plt.subplots(2, 3, figsize=(15, 4))
for ind, item in enumerate (attr_list):
    sns.countplot(x = item, hue = 'Exited', data = df_clean, ax = axarr[ind%2][ind//2])
fig.subplots_adjust(hspace=0.7)

Il grafico mostra i grafici a barre per i clienti chiusi e non conxited.

Distribuzione di attributi numerici

Visualizzare la distribuzione della frequenza degli attributi numerici usando l'istogramma.

columns = df_num_cols.columns[: len(df_num_cols.columns)]
fig = plt.figure()
fig.set_size_inches(18, 8)
length = len(columns)
for i,j in itertools.zip_longest(columns, range(length)):
    plt.subplot((length // 2), 3, j+1)
    plt.subplots_adjust(wspace = 0.2, hspace = 0.5)
    df_num_cols[i].hist(bins = 20, edgecolor = 'black')
    plt.title(i)
plt.show()

Grafico mostra la distribuzione degli attributi numerici.

Eseguire l'ingegneria delle funzionalità

Eseguire la progettazione delle funzionalità per generare nuovi attributi in base agli attributi correnti:

df_clean["NewTenure"] = df_clean["Tenure"]/df_clean["Age"]
df_clean["NewCreditsScore"] = pd.qcut(df_clean['CreditScore'], 6, labels = [1, 2, 3, 4, 5, 6])
df_clean["NewAgeScore"] = pd.qcut(df_clean['Age'], 8, labels = [1, 2, 3, 4, 5, 6, 7, 8])
df_clean["NewBalanceScore"] = pd.qcut(df_clean['Balance'].rank(method="first"), 5, labels = [1, 2, 3, 4, 5])
df_clean["NewEstSalaryScore"] = pd.qcut(df_clean['EstimatedSalary'], 10, labels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Usare Data Wrangler per eseguire la codifica one-hot

I dati Wrangler possono essere usati anche per eseguire la codifica one-hot. A tale scopo, riaprire Data Wrangler. Questa volta, selezionare i df_clean dati.

  1. Espandere Formule e selezionare Codifica one-hot.
  2. Viene visualizzato un pannello in cui selezionare l'elenco di colonne su cui si vuole eseguire la codifica one-hot. Selezionare Geografia e Sesso.

È possibile copiare il codice generato, chiudere Data Wrangler per tornare al notebook e quindi incollarlo in una nuova cella. In alternativa, selezionare Aggiungi codice al notebook in alto a sinistra per chiudere Data Wrangler e aggiungere automaticamente il codice.

Se non si usa Data Wrangler, è invece possibile usare questa cella di codice successiva:

# This is the same code that Data Wrangler will generate
 
import pandas as pd
 
def clean_data(df_clean):
    # One-hot encode columns: 'Geography', 'Gender'
    df_clean = pd.get_dummies(df_clean, columns=['Geography', 'Gender'])
    return df_clean
 
df_clean_1 = clean_data(df_clean.copy())
df_clean_1.head()

Riepilogo delle osservazioni dell'analisi esplorativa dei dati

  • La maggior parte dei clienti proviene dalla Francia rispetto alla Spagna e alla Germania, mentre la Spagna ha il tasso di varianza più basso rispetto alla Francia e alla Germania.
  • La maggior parte dei clienti ha carte di credito.
  • Ci sono clienti la cui età e punteggio di credito sono superiori a 60 e al di sotto di 400, rispettivamente, ma non possono essere considerati come outlier.
  • Pochissimi clienti hanno più di due dei prodotti della banca.
  • I clienti che non sono attivi hanno una varianza più elevata.
  • Gli anni di sesso e di tenure non sembrano avere un impatto sulla decisione del cliente di chiudere il conto bancario.

Creare una tabella differenziale per i dati puliti

Questi dati verranno usati nel notebook successivo di questa serie.

table_name = "df_clean"
# Create Spark DataFrame from pandas
sparkDF=spark.createDataFrame(df_clean_1) 
sparkDF.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark dataframe saved to delta table: {table_name}")

Passaggio successivo

Eseguire il training e registrare modelli di Machine Learning con questi dati:

Parte 3: Eseguire il training e registrare modelli di Machine Learning.