Oltre a Numpy e Pandas Sbloccare il potenziale delle librerie Python meno conosciute

Sbloccare il potenziale di altre librerie Python meno conosciute oltre a Numpy e Pandas.

3 librerie Python per il calcolo scientifico che dovresti conoscere come professionista dei dati

Immagine di OrMaVaredo su Pixabay

Python è uno dei linguaggi di programmazione più utilizzati al mondo e fornisce agli sviluppatori una vasta gamma di librerie.

Tuttavia, quando si tratta di manipolazione dei dati e calcolo scientifico, generalmente pensiamo a librerie come Numpy, Pandas o SciPy.

In questo articolo, presentiamo 3 librerie Python che potrebbero interessarti.

1. Dask

Introduzione a Dask

Dask è una libreria flessibile per il calcolo parallelo che consente l’elaborazione distribuita e il parallelismo per l’elaborazione di dati su larga scala.

Quindi, perché dovremmo usare Dask? Come dicono sul loro sito web:

Python è diventato il linguaggio dominante sia nell’analisi dei dati che nella programmazione generale. Questa crescita è stata alimentata da librerie computazionali come NumPy, pandas e scikit-learn. Tuttavia, questi pacchetti non sono stati progettati per scalare oltre una singola macchina. Dask è stato sviluppato per scalare nativamente questi pacchetti e l’ecosistema circostante su macchine multicore e cluster distribuiti quando i set di dati superano la memoria.

Quindi, uno degli usi comuni di Dask, come dicono, è:

Dask DataFrame viene utilizzato in situazioni in cui di solito è necessario Pandas, di solito quando Pandas fallisce a causa della dimensione dei dati o della velocità di calcolo:

– Manipolazione di grandi set di dati, anche quando questi set di dati non rientrano in memoria

– Accelerazione di calcoli lunghi utilizzando molti core

– Calcolo distribuito su grandi set di dati con operazioni standard di Pandas come groupby, join e calcoli di serie temporali

Quindi, Dask è una buona scelta quando dobbiamo gestire enormi data frame di Pandas. Questo perché Dask:

Consente agli utenti di manipolare set di dati di oltre 100 GB su un laptop o set di dati di oltre 1 TB su una workstation

Che è un risultato piuttosto impressionante.

Cosa succede sotto il cofano, è che:

I Dask DataFrame coordinano molti DataFrame/Series di Pandas disposti lungo l’indice. Un Dask DataFrame viene suddiviso per riga, raggruppando le righe per valore di indice per efficienza. Questi oggetti Pandas possono risiedere su disco o su altre macchine.

Quindi, abbiamo qualcosa del genere:

La differenza tra un Dask e un Pandas data frame. Immagine di Author, liberamente ispirata a una presente sul sito web di Dask già citata.

Alcune caratteristiche di Dask in azione

Prima di tutto, dobbiamo installare Dask. Possiamo farlo tramite pip o conda in questo modo:

$ pip install dask[complete]o$ conda install dask

CARATTERISTICA UNO: APERTURA DI UN FILE CSV

La prima caratteristica di Dask che possiamo mostrare è come aprire un file CSV. Possiamo farlo in questo modo:

import dask.dataframe as dd# Carica un grande file CSV utilizzando Daskdf_dask = dd.read_csv('my_very_large_dataset.csv')# Esegui operazioni sul Dask DataFramemean_value_dask = df_dask['nome_colonna'].mean().compute()

Quindi, come possiamo vedere nel codice, il modo in cui usiamo Dask è molto simile a Pandas. In particolare:

  • Utilizziamo il metodo read_csv() esattamente come in Pandas
  • Intercettiamo una colonna esattamente come in Pandas. Infatti, se avessimo un data frame Pandas chiamato df intercetteremmo una colonna in questo modo: df['nome_colonna'].
  • Applichiamo il metodo mean() alla colonna intercettata in modo simile a Pandas, ma qui dobbiamo anche aggiungere il metodo compute().

Inoltre, anche se la metodologia di apertura di un file CSV è la stessa di Pandas, sotto il cofano Dask elabora senza sforzo un grande dataset che supera la capacità di memoria di una singola macchina.

Ciò significa che non possiamo vedere alcuna differenza effettiva, tranne il fatto che un grande data frame non può essere aperto in Pandas, ma in Dask possiamo farlo.

FEATURE DUE: SCALING MACHINE LEARNING WORKFLOWS

Possiamo utilizzare Dask anche per creare un dataset di classificazione con un numero enorme di campioni. Possiamo quindi dividerlo in set di addestramento e di test, adattare il set di addestramento con un modello di apprendimento automatico e calcolare le previsioni per il set di test.

Possiamo farlo in questo modo:

import dask_ml.datasets as dask_datasetsfrom dask_ml.linear_model import LogisticRegressionfrom dask_ml.model_selection import train_test_split# Carica un dataset di classificazione utilizzando DaskX, y = dask_datasets.make_classification(n_samples=100000, chunks=1000)# Dividi i dati in set di addestramento e di testX_train, X_test, y_train, y_test = train_test_split(X, y)# Addestra un modello di regressione logistica in parallelomodel = LogisticRegression()model.fit(X_train, y_train)# Prevedi sul set di testy_pred = model.predict(X_test).compute()

Questo esempio evidenzia la capacità di Dask di gestire enormi dataset anche nel caso di un problema di apprendimento automatico, distribuendo i calcoli su più core.

In particolare, possiamo creare un “dataset Dask” per un caso di classificazione con il metodo dask_datasets.make_classification(), e possiamo specificare il numero di campioni e i chunks (anche molto grandi!).

Allo stesso modo di prima, le previsioni vengono ottenute con il metodo compute().

NOTA: in questo caso, potrebbe essere necessario installare il modulo dask_ml. Puoi farlo in questo modo:$ pip install dask_ml

FEATURE TRE: EFFICIENTE ELABORAZIONE DELLE IMMAGINI

La potenza dell’elaborazione parallela utilizzata da Dask può essere applicata anche alle immagini.

In particolare, potremmo aprire più immagini, ridimensionarle e salvarle ridimensionate. Possiamo farlo in questo modo:

import dask.array as daimport dask_image.imreadfrom PIL import Image# Carica una collezione di immagini utilizzando Daskimages = dask_image.imread.imread('image*.jpg')# Ridimensiona le immagini in paralleloresized_images = da.stack([da.resize(image, (300, 300)) for image in images])# Calcola il risultatoresult = resized_images.compute()# Salva le immagini ridimensionatefor i, image in enumerate(result):    resized_image = Image.fromarray(image)    resized_image.save(f'resized_image_{i}.jpg')

Quindi, ecco il processo:

  1. Apriamo tutte le immagini “.jpg” nella cartella corrente (o in una cartella che puoi specificare) con il metodo dask_image.imread.imread("image*.jpg").
  2. Le ridimensioniamo tutte a 300×300 utilizzando una comprensione di lista nel metodo da.stack().
  3. Calcoliamo il risultato con il metodo compute(), come abbiamo fatto prima.
  4. Salviamo tutte le immagini ridimensionate con il ciclo for.

2. SymPy

Introduzione a SymPy

Se hai bisogno di effettuare calcoli e computazioni matematiche e desideri utilizzare Python, puoi provare SymPy.

In effetti: perché usare altri strumenti e software quando possiamo usare il nostro amato Python?

Come scrivono sul loro sito web, SymPy è:

una libreria Python per la matematica simbolica. Ha l’obiettivo di diventare un sistema di algebra computazionale (CAS) completo, mantenendo il codice il più semplice possibile per essere comprensibile ed estensibile. SymPy è interamente scritto in Python.

Ma perché usare SymPy? Suggeriscono:

SymPy è…

– Gratuito: Con licenza BSD, SymPy è gratuito sia nel senso della libertà di parola che nel senso della birra.

– Basato su Python: SymPy è interamente scritto in Python e utilizza Python come linguaggio.

– Leggero: SymPy dipende solo da mpmath, una libreria puramente Python per l’aritmetica in virgola mobile arbitraria, rendendolo facile da usare.

– Una libreria: Oltre all’uso come strumento interattivo, SymPy può essere incorporato in altre applicazioni ed esteso con funzioni personalizzate.

Quindi, fondamentalmente ha tutte le caratteristiche che possono essere amate dagli appassionati di Python!

Ora, vediamo alcune delle sue funzionalità.

Alcune caratteristiche di SymPy in azione

Prima di tutto, dobbiamo installarlo:

$ pip install sympy

FAI ATTENZIONE: se scrivi $ pip install simpy installerai un'altra libreria (completamente diversa!). Quindi, la seconda lettera è una "y", non una "i".

CARATTERISTICA UNO: RISOLUZIONE DI UN’EQAZIONE ALGEBRICA

Se abbiamo bisogno di risolvere un’equazione algebrica, possiamo usare SymPy in questo modo:

from sympy import symbols, Eq, solve# Definiamo i simbolix, y = symbols('x y')# Definiamo l'equazioneequation = Eq(x**2 + y**2, 25)# Risolviamo le equazionisolutions = solve(equation, (x, y))# Stampiamo la soluzioneprint(solutions)>>>[(-sqrt(25 - y**2), y), (sqrt(25 - y**2), y)]

Quindi, ecco il processo:

  1. Definiamo i simboli dell’equazione con il metodo symbols().
  2. Scriviamo l’equazione algebrica con il metodo Eq.
  3. Risolviamo l’equazione con il metodo solve().

Quando ero all’Università, ho usato diversi strumenti per risolvere questi tipi di problemi, e devo dire che SymPy, come possiamo vedere, è molto leggibile e user-friendly.

Ma, in effetti: è una libreria Python, quindi come potrebbe essere diverso?

CARATTERISTICA DUE: CALCOLO DELLE DERIVATE

Calcolare le derivate è un’altra attività che potremmo avere bisogno di fare matematicamente, per molte ragioni nell’analisi dei dati. Spesso, potremmo avere bisogno di calcoli per qualsiasi motivo, e SymPy semplifica davvero questo processo. Infatti, possiamo farlo in questo modo:

from sympy import symbols, diff# Definiamo il simbolox = symbols('x')# Definiamo la funzionef = x**3 + 2*x**2 + 3*x + 4# Calcoliamo la derivataderivative = diff(f, x)# Stampiamo la derivataprint(derivative)>>>3*x**2 + 4*x + 3

Quindi, come possiamo vedere, il processo è molto semplice e autoesplicativo:

  1. Definiamo il simbolo della funzione da cui stiamo derivando con symbols().
  2. Definiamo la funzione.
  3. Calcoliamo la derivata con diff() specificando la funzione e il simbolo da cui stiamo calcolando la derivata (questa è una derivata assoluta, ma potremmo eseguire anche derivate parziali nel caso di funzioni che hanno variabili x e y).

E se lo testiamo, vedremo che il risultato arriva in una questione di 2 o 3 secondi. Quindi, è anche piuttosto veloce.

CARATTERISTICA TRE: CALCOLO DELLE INTEGRAZIONI

Ovviamente, se SymPy può calcolare le derivate, può anche calcolare le integrazioni. Facciamolo:

from sympy import symbols, integrate, sin# Definiamo il simbolox = symbols('x')# Eseguiamo l'integrazione simbolicaintegral = integrate(sin(x), x)# Stampiamo l'integraleprint(integral)>>>-cos(x)

Quindi, qui usiamo il metodo integrate(), specificando la funzione da integrare e la variabile di integrazione.

Non potrebbe essere più semplice?!

3. Xarray

Introduzione a Xarray

Xarray è una libreria Python che estende le funzionalità di NumPy, dandoci la possibilità di lavorare con array e dataset etichettati.

Come dicono sul loro sito web, infatti:

Xarray rende semplice, efficiente e divertente lavorare con array multidimensionali etichettati in Python!

E anche:

Xarray introduce etichette sotto forma di dimensioni, coordinate e attributi su array multidimensionali simili a NumPy grezzi, il che consente un’esperienza di sviluppo più intuitiva, più concisa e meno soggetta a errori.

In altre parole, estende la funzionalità degli array NumPy aggiungendo etichette o coordinate alle dimensioni dell’array. Queste etichette forniscono metadati e consentono un’analisi e una manipolazione più avanzate dei dati multidimensionali.

Ad esempio, in NumPy, gli array sono accessibili utilizzando un indice basato su numeri interi.

In Xarray, invece, ogni dimensione può avere un’etichetta associata ad essa, rendendo più facile capire e manipolare i dati basati su nomi significativi.

Ad esempio, invece di accedere ai dati con arr[0, 1, 2], possiamo utilizzare arr.sel(x=0, y=1, z=2) in Xarray, dove x, y e z sono etichette di dimensione.

Questo rende il codice molto più leggibile!

Quindi, vediamo alcune caratteristiche di Xarray.

Alcune caratteristiche di Xarray in azione

Come al solito, per installarlo:

$ pip install xarray

CARATTERISTICA UNO: LAVORARE CON COORDINATE ETICHETTATE

Supponiamo che vogliamo creare alcuni dati relativi alla temperatura e vogliamo etichettarli con coordinate come la latitudine e la longitudine. Possiamo farlo in questo modo:

import xarray as xr
import numpy as np

# Creare dati di temperatura
temperature = np.random.rand(100, 100) * 20 + 10

# Creare array di coordinate per latitudine e longitudine
latitudes = np.linspace(-90, 90, 100)
longitudes = np.linspace(-180, 180, 100)

# Creare un array di dati Xarray con coordinate etichettate
da = xr.DataArray(
    temperature,
    dims=['latitude', 'longitude'],
    coords={'latitude': latitudes, 'longitude': longitudes}
)

# Accedere ai dati utilizzando coordinate etichettate
subset = da.sel(latitude=slice(-45, 45), longitude=slice(-90, 0))

E se li stampiamo otteniamo:

# Stampare i dati
print(subset)
<<<

array([[13.45064786, 29.15218061, 14.77363206, ..., 12.00262833,        16.42712411, 15.61353963],
       [23.47498117, 20.25554247, 14.44056286, ..., 19.04096482,        15.60398491, 24.69535367],
       [25.48971105, 20.64944534, 21.2263141 , ..., 25.80933737,        16.72629302, 29.48307134],
       ...,
       [10.19615833, 17.106716  , 10.79594252, ..., 29.6897709 ,        20.68549602, 29.4015482 ],
       [26.54253304, 14.21939699, 11.085207  , ..., 15.56702191,        19.64285595, 18.03809074],
       [26.50676351, 15.21217526, 23.63645069, ..., 17.22512125,        13.96942377, 13.93766583]])
Coordinates:
  * latitude   (latitude) float64 -44.55 -42.73 -40.91 ... 40.91 42.73 44.55
  * longitude  (longitude) float64 -89.09 -85.45 -81.82 ... -9.091 -5.455 -1.818

Quindi, vediamo il processo passo dopo passo:

  1. Abbiamo creato i valori della temperatura come un array NumPy.
  2. Abbiamo definito i valori di latitudine e longitudine come array NumPy.
  3. Abbiamo memorizzato tutti i dati in un array Xarray con il metodo DataArray().
  4. Abbiamo selezionato un sottoinsieme di latitudini e longitudini con il metodo sel() che seleziona i valori che desideriamo per il nostro sottoinsieme.

Anche il risultato è facilmente leggibile, quindi l’etichettatura è davvero utile in molti casi.

CARATTERISTICA DUE: GESTIONE DEI DATI MANCANTI

Supponiamo di raccogliere dati relativi alle temperature durante l’anno. Vogliamo sapere se abbiamo alcuni valori nulli nel nostro array. Ecco come possiamo farlo:

import xarray as xrimport numpy as npimport pandas as pd# Creiamo dati di temperatura con valori mancanti temperatura = np.random.rand(365, 50, 50) * 20 + 10 temperatura[0:10, :, :] = np.nan  # Imposta i primi 10 giorni come valori mancanti# Creiamo array di coordinate temporali, latitudine e longitudinetimes = pd.date_range('2023-01-01', periods=365, freq='D')latitudes = np.linspace(-90, 90, 50)longitudes = np.linspace(-180, 180, 50)# Creiamo un array di dati Xarray con valori mancanti da = xr.DataArray( temperature, dims=['time', 'latitude', 'longitude'], coords={'time': times, 'latitude': latitudes, 'longitude': longitudes})# Conta il numero di valori mancanti lungo la dimensione temporale missing_count = da.isnull().sum(dim='time')# Stampa i valori mancanti print(missing_count)>>><xarray.DataArray (latitude: 50, longitude: 50)>array([[10, 10, 10, ..., 10, 10, 10], [10, 10, 10, ..., 10, 10, 10], [10, 10, 10, ..., 10, 10, 10], ..., [10, 10, 10, ..., 10, 10, 10], [10, 10, 10, ..., 10, 10, 10], [10, 10, 10, ..., 10, 10, 10]])Coordinates: * latitude (latitude) float64 -90.0 -86.33 -82.65 ... 82.65 86.33 90.0 * longitude (longitude) float64 -180.0 -172.7 -165.3 ... 165.3 172.7 180.0

E così otteniamo che abbiamo 10 valori nulli.

Inoltre, se osserviamo attentamente il codice, possiamo vedere che possiamo applicare i metodi di Pandas a un Xarray come isnull.sum(), come in questo caso, che conta il numero totale di valori mancanti.

CARATTERISTICA UNO: GESTIONE ED ANALISI DI DATI MULTI-DIMENSIONALI

La tentazione di gestire ed analizzare dati multi-dimensionali è alta quando abbiamo la possibilità di etichettare i nostri array. Quindi, perché non provarlo?

Ad esempio, supponiamo che stiamo ancora raccogliendo dati relativi alle temperature ad alcune latitudini e longitudini.

Possiamo calcolare la media, il massimo e la mediana delle temperature. Possiamo farlo così:

import xarray as xrimport numpy as npimport pandas as pd# Creiamo dati di temperatura sintetica temperatura = np.random.rand(365, 50, 50) * 20 + 10# Creiamo array di coordinate temporali, latitudine e longitudines times = pd.date_range('2023-01-01', periods=365, freq='D')latitudes = np.linspace(-90, 90, 50)longitudes = np.linspace(-180, 180, 50)# Creiamo un dataset Xarray ds = xr.Dataset( { 'temperature': (['time', 'latitude', 'longitude'], temperature), }, coords={ 'time': times, 'latitude': latitudes, 'longitude': longitudes, })# Esegui analisi statistica sui dati di temperatura mean_temperature = ds['temperature'].mean(dim='time')max_temperature = ds['temperature'].max(dim='time')min_temperature = ds['temperature'].min(dim='time')# Stampa i valori print(f"media temperatura:\n {mean_temperature}\n")print(f"temperatura massima:\n {max_temperature}\n")print(f"temperatura minima:\n {min_temperature}\n")>>>media temperatura: <xarray.DataArray 'temperature' (latitude: 50, longitude: 50)>array([[19.99931701, 20.36395016, 20.04110699, ..., 19.98811842, 20.08895803, 19.86064693], [19.84016491, 19.87077812, 20.27445405, ..., 19.8071972 , 19.62665953, 19.58231185], [19.63911165, 19.62051976, 19.61247548, ..., 19.85043831, 20.13086891, 19.80267099], ..., [20.18590514, 20.05931149, 20.17133483, ..., 20.52858247, 19.83882433, 20.66808513], [19.56455575, 19.90091128, 20.32566232, ..., 19.88689221, 19.78811145, 19.91205212], [19.82268297, 20.14242279, 19.60842148, ..., 19.68290006, 20.00327294, 19.68955107]])Coordinates: * latitude (latitude) float64 -90.0 -86.33 -82.65 ... 82.65 86.33 90.0 * longitude (longitude) float64 -180.0 -172.7 -165.3 ... 165.3 172.7 180.0temperatura massima: <xarray.DataArray 'temperature' (latitude: 50, longitude: 50)>array([[29.98465531, 29.97609171, 29.96821276, ..., 29.86639343, 29.95069558, 29.98807808], [29.91802049, 29.92870312, 29.87625447, ..., 29.92519055, 29.9964299 , 29.99792388], [29.96647016, 29.7934891 , 29.89731136, ..., 29.99174546, 29.97267052, 29.96058079], ..., [29.91699117, 29.98920555, 29.83798369, ..., 29.90271746, 29.93747041, 29.97244906], [29.99171911, 29.99051943, 29.92706773, ..., 29.90578739, 29.99433847, 29.94506567], [29.99438621, 29.98798699, 29.97664488, ..., 29.98669576, 29.91296382, 29.93100249]])Coordinates: * latitude (latitude) float64 -90.0 -86.33 -82.65 ... 82.65 86.33 90.0 * longitude (longitude) float64 -180.0 -172.7 -165.3 ... 165.3 172.7 180.0temperatura minima: <xarray.DataArray 'temperature' (latitude: 50, longitude: 50)>array([[10.0326431 , 10.07666029, 10.02795524, ..., 10.17215336, 10.00264909, 10.05387097], [10.00355858, 10.00610942, 10.02567816, ..., 10.29100316, 10.00861792, 10.16955806], [10.01636216, 10.02856619, 10.00389027, ..., 10.0929342 , 10.01504103, 10.06219179], ..., [10.00477003, 10.0303088 , 10.04494723, ..., 10.05720692, 10.122994 , 10.04947012], [10.00422182, 10.0211205 , 10.00183528, ..., 10.03818058, 10.02632697, 10.06722953], [10.10994581, 10.12445222, 10.03002468, ..., 10.06937041, 10.04924046, 10.00645499]])Coordinates: * latitude (latitude) float64 -90.0 -86.33 -82.65 ... 82.65 86.33 90.0 * longitude (longitude) float64 -180.0 -172.7 -165.3 ... 165.3

E abbiamo ottenuto ciò che volevamo, anche in modo chiaramente leggibile.

E ancora una volta, come prima, per calcolare i valori massimi, minimi e medi delle temperature abbiamo utilizzato le funzioni di Pandas applicate a un array.

Conclusioni

In questo articolo abbiamo mostrato tre librerie per il calcolo e l'elaborazione scientifica.

Mentre SymPy può essere il sostituto di altri strumenti e software, dando la possibilità di utilizzare il codice Python per calcoli matematici, Dask e Xarray estendono le funzionalità di altre librerie, aiutandoci in situazioni in cui potremmo avere difficoltà con altre librerie Python più conosciute per l'analisi e la manipolazione dei dati.

EBOOK PYTHON GRATUITO:

Hai iniziato a imparare la Data Science in Python ma stai avendo difficoltà? Iscriviti alla mia newsletter e ricevi il mio ebook gratuito: questo ti darà il giusto percorso di apprendimento da seguire per imparare Python per la Data Science con esperienza pratica.

Ti è piaciuta la storia? Diventa membro di VoAGI per 5$/mese tramite il mio link di referenza: guadagnerò una piccola commissione senza alcun costo aggiuntivo per te:

Come membro di VoAGI, una parte della tua quota di iscrizione va agli autori che leggi e avrai accesso completo a ogni storia...

federicotrotta.medium.com