Taipy uno strumento per la costruzione di applicazioni di data science pronte per la produzione, facili da usare per gli utenti.

Taipy è uno strumento per costruire applicazioni di data science pronte per la produzione, facili da usare.

Un modo semplice, veloce ed efficiente per creare un’applicazione dati full-stack

Introduzione

Come Data Scientist, potresti voler creare dashboard per la visualizzazione dei dati, visualizzare dati e persino implementare applicazioni aziendali per assistere gli stakeholder nella presa di decisioni operative.

Per svolgere queste attività, possono essere utilizzati vari strumenti e tecnologie, sia open-source che software proprietari. Tuttavia, potrebbero non essere ideali per i seguenti motivi:

• Alcune delle tecnologie open-source richiedono una curva di apprendimento ripida e l’assunzione di persone con la competenza appropriata. Di conseguenza, le organizzazioni possono affrontare un aumento del tempo di integrazione per i nuovi dipendenti, costi di formazione più elevati e possibili difficoltà nel trovare candidati qualificati.
• Altre soluzioni open-source sono ottime per i prototipi ma non scalano per diventare applicazioni pronte per la produzione.
• Allo stesso modo, gli strumenti proprietari presentano anche le loro sfide, tra cui costi di licenza più elevati, personalizzazione limitata e difficoltà per le aziende di passare ad altre soluzioni.

Non sarebbe bello se ci fosse uno strumento che fosse non solo open-source ma anche facile da imparare e in grado di scalare in un’applicazione completa?

Ecco dove entra in gioco Taipy 🎉

• RAPIDS Usa la GPU per accelerare facilmente i modelli di ML
• Imparare le basi per il tuo prossimo progetto LangChain
• Oltre a Numpy e Pandas Sbloccare il potenziale delle librerie Python meno conosciute

In questo articolo verrà spiegato cos’è Taipy, insieme ad alcuni casi aziendali che può risolvere, prima di esplorare le sue funzionalità chiave. Inoltre, saranno illustrate tutte le fasi per creare un’applicazione web completa.

Cos’è Taipy e perché dovresti interessarti?

È una libreria open-source, interamente scritta in Python e richiede solo una conoscenza di base della programmazione Python. Consente ai data scientist, agli ingegneri di machine learning e a qualsiasi altro programmatore Python di trasformare rapidamente i propri dati e modelli di machine learning in un’applicazione web completamente funzionale.

Nell’ambiente in continua evoluzione di oggi, la richiesta di strumenti robusti, flessibili e potenti diventa essenziale, e di seguito sono elencate alcune delle funzionalità che rendono Taipy una piattaforma unica:

• Non è progettato esclusivamente per i prototipi, ma può essere esteso a progetti industrializzati.
• La semplicità di Taipy, combinata con potenti funzionalità, consente agli sviluppatori Python con una conoscenza minima della programmazione di costruire soluzioni robuste in poco tempo.
• Un alto livello di personalizzazione consente agli utenti di modificare e adattare rapidamente le funzionalità di Taipy alle proprie esigenze, offrendo un’esperienza personalizzata che molti strumenti open-source non riescono a offrire.
• Le chiamate sincrone e asincrone fornite da Taipy consentono l’esecuzione di più attività contemporaneamente, migliorandone le prestazioni complessive.
• Un’applicazione Taipy può essere sviluppata utilizzando script Python o Jupyter Notebooks.
• Grazie alla funzionalità di versionamento delle pipeline di Taipy, gli utenti possono gestire efficacemente diverse versioni di progetto.

Può essere installata l’estensione Taipy studio in Visual Studio Code per accelerare significativamente lo sviluppo delle applicazioni Taipy.

Funzionalità chiave di Taipy

Anche se Taipy è ottimo per lo sviluppo Front-End o Back-End, il suo vero potenziale si manifesta nello sviluppo di un’applicazione web completa con componenti front-end e back-end.

Diamo un’occhiata più da vicino alle principali funzionalità di ciascuno di essi:

Funzionalità Front-End di Taipy

• La creazione di un’interfaccia utente viene eseguita con una conoscenza di base della programmazione Python.
• Taipy è progettato per essere intuitivo per l’utente, semplificando la creazione dell’interfaccia utente in modo semplice e intuitivo.
• Non è richiesta alcuna conoscenza di progettazione web ed elimina tutti i prerequisiti per CSS e HTML.
• Sfrutta la sintassi Markdown potenziata per aiutare gli utenti nella creazione delle pagine web desiderate.

Funzionalità Back-End di Taipy

• Taipy supporta la creazione di una pipeline robusta per gestire diverse situazioni.
• Rende la modellazione dei grafi aciclici diretti (Directed Acyclic Graphs – DAG) semplice.
• La funzione di caching dei dati migliora le prestazioni complessive delle applicazioni Taipy.
• Registro delle esecuzioni delle pipeline.
• Versionamento delle pipeline.
• Gli utenti possono monitorare e valutare le prestazioni delle loro applicazioni con lo strumento di monitoraggio KPI di Taipy.
• Visualizzazione integrata delle pipeline e dei dati associati.

Iniziare con Taipy

Ora che hai una migliore comprensione di Taipy, immergiamoci in un’implementazione completa.

La documentazione principale di Taipy e i contributi della comunità contengono informazioni rilevanti, e questo articolo non intende sostituirli ma può essere utilizzato come un luogo alternativo per iniziare a imparare Taipy in un contesto reale.

Per illustrare meglio il nostro caso, utilizzeremo i dati sulle violazioni relative alla salute mantenuti dall’Ufficio per i diritti civili del Dipartimento della salute e dei servizi umani degli Stati Uniti. Fornisce informazioni sulle violazioni segnalate delle informazioni sanitarie protette non sicure per oltre 500 individui.

Questa sezione sarà divisa in due parti:

• Costruire un’interfaccia grafica utilizzando Taipy per aiutare gli utenti finali a avere una panoramica globale dei diversi tipi di violazioni per prendere decisioni operative.
• Sviluppare un framework di backend di Taipy per interagire con un modello di apprendimento automatico di classificazione al fine di predire il tipo di violazione per una determinata informazione.

Installazione rapida

Per utilizzare Taipy è necessario Python 3.8 o versioni successive. La distribuzione di Anaconda Python (conda) e l’IDE Visual Studio Code vengono utilizzati per installare Taipy come segue:

Crea l’ambiente virtuale con il nome taipy-env e installa Python 3.8

conda create –-name taipy-env python=3.8

Attiva l’ambiente creato in precedenza

conda activate taipy-env

Il comando seguente installa la libreria taipy all’interno dell’ambiente virtuale

pip install taipy

Esecuzione di un’app Taipy

• Crea un file di script Python <taipy_app.py>
• Inserisci il seguente codice, quindi salva il file:

from taipy import Guianalytics_choice = ["Distribuzione dei tipi di violazione",                 "Violazione per Stato",                 "Top 10 Stati a rischio",                 "Tipo di entità coperta",                 ""]choice = ""my_app_page = """# Pannello di analisi delle violazioni della sicurezza## Analisi delle violazioniScegli dall'elenco sottostante per avviare la tua analisi<|{choice}|selector|lov={analytics_choice}|dropdown|>Scelta: <|{choice}|text|>"""if __name__ == '__main__': Gui(page=my_app_page).run(host="0.0.0.0", port=9696)

Nella console di conda, digita il comando seguente nel file taipy_app.py:

python taipy_app.py

L’esecuzione corretta del codice sopra genera questo URL e apre automaticamente una finestra del browser:

È fantastico!

Adesso, cerchiamo di capire il codice precedente.

• Importa il modulo Gui utilizzato per creare i dashboard.
• Il analytics_choice è l’elenco delle scelte possibili.
• Quindi la variabile choice conterrà un valore tratto dall’elenco analytics_choice e l’interpolazione di queste variabili viene fatta utilizzando la sintassi <|…|>.
• my_page contiene le informazioni sottostanti nel formato markdown:
• Pannello di analisi delle violazioni della sicurezza ha il livello H1 rappresentato con un singolo simbolo “#”.
• Analisi delle violazioni ha il livello H2 rappresentato con due simboli “#” seguiti da un testo semplice “Scegli dall’elenco … analisi”
• Creiamo una lista a discesa utilizzando le variabili originali analytics_choice e choice.
• Visualizza la scelta effettuata dall’utente.

Infine, esegui l’applicazione fornendo il my_app_page e specificando la porta e l’host. Se non viene specificata la porta del server, verrà aperta su una porta predefinita (5000). Per questo esempio specifico, l’app si apre su 9696 all’indirizzo http://localhost:9696

È il momento di creare un Dashboard Taipy da zero

Portiamo le nostre conoscenze di Taipy al livello successivo implementando una dashboard completa. Le sezioni principali della dashboard sfrutteranno gli elementi visivi seguenti di Taipy:

• Fare una scelta da un elenco di opzioni usando Selectors.
• Scatenare un’azione facendo clic sul pulsante usando Buttons.
• Mostrare i dati grezzi in Tables.

Mostrare i risultati grafici con Charts.

Tutti questi elementi di visualizzazione sopra menzionati sono creati introducendo la seguente sintassi markdown:

<|{variable}|nome_elemento_visuale|param1=param1|param2=param2|…|>

La dashboard finale apparirà come segue e il codice sorgente finale è disponibile alla fine dell’articolo.

Per eseguire un’illustrazione passo passo, verrà fornito un esempio di ciascun componente in un file separato e ogni file viene eseguito con il seguente comando:

python nome_file.py

Selectors

Questi danno agli utenti l’opportunità di scegliere da un elenco a discesa e corrispondono a ciò che abbiamo implementato nella sezione “Esecuzione di un’app Taipy”.

Buttons e Tables

I pulsanti nell’interfaccia utente avviano una funzione specifica quando vengono cliccati o premuti. La funzione on_action viene attivata alla pressione del pulsante.

Le tabelle, d’altra parte, vengono utilizzate per organizzare i dati offrendo tre modalità di visualizzazione: paginata, allow_all_rows, unpaginated e auto_loading. La documentazione ufficiale fornisce ulteriori informazioni su ognuna di queste modalità. Creare un nuovo file button.py con il seguente codice:

from taipy import Guiimport pandas as pdbreach_data = pd.read_csv("data/breach_report_data.csv")def toggle_table_dialog(state): state.show_table_dialog = not state.show_table_dialogshow_table_dialog = Falsemy_app_page = """<center> Security Breach Analytics Dashboard</center>------------------------------<br/><center> Fare clic sul pulsante di seguito per visualizzare i dati </center><br/><center><|Display Raw Data|button|on_action=toggle_table_dialog|></center><|{show_table_dialog}|dialog|on_action=toggle_table_dialog|width=90vw|labels=Cancel|<center><|{breach_data}|table|width=fit-content|height=65vh|></center>|>"""

Iniziamo caricando i dati di violazione in un dataframe Pandas. Quindi, selezionando “Visualizza dati grezzi” vengono visualizzati tutti i dati in formato tabella come mostrato di seguito:

Charts

Con una migliore comprensione dei componenti sopra, possiamo combinarli per creare grafici, basati sulla completa libreria di grafici poltly.js. In caso contrario, la documentazione di Taipy fornisce ottimi esempi da utilizzare come punto di partenza. Allo stesso modo alla sezione precedente, crea un charts.py con il seguente codice:

Viene creato un grafico di tipo bar con State sull’asse x e la Proportione sull’asse y.

# import libraries heremy_app_page = """<center> Security Breach Analytics Dashboard</center>------------------------------<center> Grafico 3: Le 10 stati più colpite</center><br/><|{breach_df}|chart|type=bar|x=State|y=Individuals_Affected|>"""# Metti la sezione '__main__' qui

Il risultato finale è questo grafico dinamico del numero di individui colpiti per stato e sembra che la California sia quella più colpita.

Mostrare un’immagine

Mostrare un’immagine in Taipy GUI è semplice e può essere realizzato con l’attributo image. Il seguente codice mostra la word cloud generata con generate_word_cloud. L’immagine ha una larghezza di 2400 pixel e un’altezza di 1000 pixel. Quando il cursore dell’utente è sull’immagine, viene mostrato il valore dell’attributo hover_text: “Word Cloud della posizione della violazione” in questo scenario specifico.

<|{breach_location_image}|image|width="2400px"|height="1000px"|hover_text="Word cloud della posizione della violazione"|>

Inoltre, la funzione di supporto generate_word_cloud è definita come segue:

from wordcloud import WordCloudfrom PIL import Imagefrom io import BytesIOdef generate_word_cloud(data, column_name):  # Unire tutte le informazioni sulla posizione in una stringa lunga text = ' '.join(data[str(column_name)]) wordcloud = WordCloud(     background_color="#1E3043" ) # Generare la word cloud my_wordcloud = wordcloud.generate(text) image = my_wordcloud.to_image() my_buffer = BytesIO() image.save(my_buffer, format = 'PNG') return my_buffer.getvalue()

Funzione di callback

Obiettivo è avere una GUI dinamica che viene aggiornata in base alla selezione dell’utente. Ciò viene realizzato utilizzando la funzione di callback di Taipy che attiva automaticamente qualsiasi funzione con il nome on_change nello spazio dei nomi locale come funzione di callback globale. L’implementazione è la seguente:

def update_Type_of_Breach(state, var_name, var_value): if var_name == "Tipo_di_violazione":         state.df = breach_df[breach_df.Tipo_di_violazione == var_value]

Layout

Più grafici possono fornire informazioni aziendali preziose, ma mostrarli verticalmente uno dopo l’altro potrebbe non essere l’approccio più efficace

Invece, possiamo creare un layout per organizzare i componenti in una griglia regolare tra i blocchi layout.start e layout.end. Ogni componente viene creato all’interno del blocco part.start e part.end.

La seguente sintassi di base crea una griglia a 2 colonne con una dimensione del carattere radice di 1,8:

<|layout.start|columns= 1 2|gap=1.8rem| <optional_id|part|>  <|{primo contenuto}|>|optional_id>… <  <|{secondo contenuto}|>>>

Con questa comprensione del layout, possiamo creare la dashboard finale con cinque grafici principali:

• Il Grafico 1 mostra la word cloud relativa alla posizione delle informazioni sulla violazione.
• Il Grafico 2 mostra il numero di individui colpiti per Stato.
• Il Grafico 3 determina il numero totale di individui colpiti per Tipo di violazione.
• Il Grafico 4 mostra per ogni anno il numero totale di individui colpiti.
• Il Grafico 5 mostra il numero di individui colpiti per Entità coperta.

# Preelaborazione della colonna DateTimebreach_df['Breach_Submission_Date'] = pd.to_datetime(breach_df['Breach_Submission_Date'])breach_df["Anno"] = breach_df["Breach_Submission_Date"].dt.yearmarkdown = """<|toggle|theme|># <center>Dashboard di analisi delle violazioni di sicurezza 🚨</center><center>**Grafico 1:** Andamento generale della posizione delle informazioni violata </center><center><|{breach_location_image}|image|width=2400px|height=1000px|hover_text=Word cloud della posizione della violazione|></center>------------------------------<|layout|columns=2 5 5|gap=1.5rem|<column_1|### Tipo di violazione:<|{breach_type}|selector|lov={breach_types}|dropdown|width=100%|>------------------------------<|Visualizza dati grezzi|button|on_action=toggle_table_dialog|><|{show_table_dialog}|dialog|on_action=toggle_table_dialog|width=90vw|labels=Annulla|<center><|{breach_df}|table|width=fit-content|height=65vh|></center>|>|column_1><column_2|**Grafico 2:** Individui colpiti per Stato<|{df}|chart|type=bar|x=State|y=Individuals_Affected|>**Grafico 4:** Individui colpiti per Anno<|{df}|chart|type=bar|x=Anno|y=Individuals_Affected|>|column_2><column_3|**Grafico 3:** Individui colpiti per Tipo di violazione<|{df}|chart|type=bar|x=Tipo_di_violazione|y=Individuals_Affected|>**Grafico 5:** Individui colpiti per Tipo di Entità coperta<|{df}|chart|type=bar|x=Covered_Entity_Type|y=Individuals_Affected|>|column_3>|>"""if __name__ == "__main__": gui = Gui(page=markdown) gui.run(dark_mode=False, host="0.0.0.0", port=9696)

Prima di configurare la dashboard, viene creato un nuovo campo Anno dalla colonna Breach_Submission, che viene poi utilizzato come asse x nel Grafico 4.

Eseguendo tutto il codice verrà generata la prima dashboard illustrata sopra.

Taipy Back-end in Azione

Nella sezione successiva, utilizzerai le capacità back-end di Taipy per creare, gestire ed eseguire facilmente ed efficientemente le tue pipeline dati per addestrare un classificatore Random Forest e determinare il tipo di violazione di una determinata informazione di violazione.

In questa sezione ci sono due parti principali. Prima costruirai la rappresentazione grafica completa del workflow utilizzando Taipy Studio. Poi scriverai il corrispondente codice Python.

Taipy Studio

Taipy Studio è un’estensione per Visual Studio Code e può essere installato come segue:

Riavvia VSCode dopo che l’installazione è completata, quindi una interfaccia di Taipy Studio verrà visualizzata dopo aver cliccato sul logo di Taipy in basso a sinistra. Questo mostrerà quattro schede principali come Config Files, Data Notes, Tasks, Pipelines e Scenarios.

Tutte queste schede possono essere utilizzate per raggiungere il nostro obiettivo di implementare una pipeline end-to-end, e il primo passo è creare un file di configurazione ( taipy_config.toml ) che conterrà tutte queste schede rappresentate da 4 loghi in alto a destra dopo aver selezionato l’icona “Taipy: Mostra Vista”.

Di seguito sono riportate le principali funzioni che verranno implementate, insieme a una breve spiegazione di ciascuna delle schede precedenti.

• La funzione filter_columns è responsabile della selezione delle colonne rilevanti dai dati e della generazione di un dataframe Pandas.
• La funzione preprocess_columns viene utilizzata per l’ingegneria delle feature.
• La funzione encode_features è responsabile della codifica delle feature rilevanti nel formato corretto.
• La funzione split_data è la funzione per dividere i dati nei dataset di addestramento e di test.
• La funzione train_model viene utilizzata per addestrare il modello.
• La funzione show_performance è la fase finale per visualizzare le prestazioni del modello.

Scenari e Pipelines

Questo è il primo passo da compiere durante la configurazione di una pipeline. Uno scenario è composto da una o più pipeline. Funziona come un registro delle esecuzioni. Creiamo uno scenario con il nome DATA_BREACH_SCENARIO seguito dalla pipeline DATA_BREACH_PIPELINE come segue:

Tasks

Un task si riferisce a una funzione Python che può essere eseguita, e ci sono in totale sei task che verranno implementati, da filter_columns a show_performance.

L’output della pipeline è collegato all’input di ogni task come segue:

Il passo successivo è configurare questi task in Taipy Studio collegando ogni funzione Python al corrispondente task. Ma prima di ciò, abbiamo bisogno di creare le signature di quelle funzioni nel file data_breach_tasks.py come segue:

import pandas as pdfrom sklearn.preprocessing import LabelEncoderfrom sklearn.model_selection import train_test_splitfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.metrics import ( confusion_matrix, accuracy_score, precision_score, recall_score, f1_score)def filter_columns(df, list_columns_to_skip):     filtered_df = df.drop(list_columns_to_skip, axis=1) return filtered_dfdef preprocess_columns(df): df['Breach_Submission_Date'] = pd.to_datetime(data['Breach_Submission_Date']) df['Breach_Submission_Month'] = df['Breach_Submission_Date'].dt.month df['Breach_Submission_Year'] = df['Breach_Submission_Date'].dt.year df.drop("Breach_Submission_Date", axis=1, inplace=True) return dfdef encode_features(df): list_columns_to_encode = ['State','Location_of_Breached_Information',                                'Business_Associate_Present',                                 'Covered_Entity_Type'] le = LabelEncoder() for col in list_columns_to_encode:     df[col] = le.fit_transform(df[col]) X = df.drop('Type_of_Breach', axis=1) y = le.fit_transform(df['Type_of_Breach']) return {"X": X, "y": y}def split_data(features_target_dict): X_train, X_test, y_train, y_test =                           train_test_split(features_target_dict["X"],                                                           features_target_dict["y"],                                        test_size=0.3,                                         random_state=42) return {     "X_train": X_train, "X_test": X_test,     "y_train": y_train, "y_test": y_test }def train_model(train_test_dictionary): classifier = RandomForestClassifier() classifier.fit(train_test_dictionary["X_train"],                train_test_dictionary["y_train"])     predictions = classifier.predict(train_test_dictionary["X_test"],                                  train_test_dictionary["y_test"]) return predictionsdef show_performance(train_test_dictionary, predictions): y_test = train_test_dictionary["y_test"] accuracy = accuracy_score(y_test, predictions) precision = precision_score(y_test, predictions) recall = recall_score(y_test, predictions) f1score = f1_score(y_test, predictions) return pd.DataFrame({     "Metriche": ['accuratezza', 'precisione', 'recupero', 'f1_score'],     "Valori": [accuratezza, precisione, recupero, f1score] })

Successivamente, collegare ogni task al corrispondente Python seguendo i 3 passaggi seguenti. L’illustrazione viene fornita per il task filter_columns ma deve essere eseguita per ogni task.

Nodi dei dati

I nodi dei dati non contengono i dati effettivi ma contengono tutte le informazioni necessarie per leggere e scrivere quei dati. Possono essere il riferimento a qualsiasi tipo di dato come testo, CSV, JSON e altro.

Ad esempio, la funzione filter_columns ha:

• Un nodo di input (filtering_node) che è un file .CSV, e
• Un nodo di output (filtered_df): che viene anche salvato come file .CSV. Questo viene quindi utilizzato come input della funzione preprocess_columns.

Il nodo per l’interazione è definito come segue mostrando la modifica del tipo di archiviazione da pickle a .csv:

Il prossimo passo è definire il percorso per l’input originale del dataset. Questo viene fatto con l’aiuto dell’attributo “Nuova proprietà” nel nodo di dati. Quindi, digita Invio e fornisci il percorso al file .CSV.

Ripeti lo stesso processo per tutti gli input in cui è richiesto un file .CSV e il diagramma finale avrà un aspetto simile a questo dopo aver specificato tutti i nodi di dati e le loro relazioni.

Dopo la configurazione del pipeline, viene generato un formato di script .toml dell’intero diagramma nel file taipy_config.toml e ha un aspetto simile a quello mostrato nell’animazione sottostante.

Quindi, questo file .toml può essere caricato in qualsiasi script Python per eseguire il pipeline. Creiamo un file del genere con il nome run_pipeline.py.

from taipy import Core, create_scenariofrom taipy.core.config import Configconfig_file_name = "./taipy_config.toml"scenario_name = "DATA_BREACH_SCENARIO"Config.load(config_file_name)scenario_config = Config.scenarios[scenario_name]if __name__ == "__main__":     Core().run() pipeline_scenario = create_scenario(scenario_config) pipeline_scenario.submit() # Questo esegue il modello di scenario model_metrics = pipeline_scenario.performance_data.read() print(model_metrics)

Iniziamo importando i moduli pertinenti, seguiti dalla definizione del file di configurazione e del nome dello scenario da attivare.

Quindi, il pipeline viene eseguito utilizzando la funzione submit().

Infine, recuperiamo le prestazioni del modello e stampiamo i risultati, come mostrato di seguito:

Questo dataframe può essere ulteriormente integrato nel cruscotto iniziale per visualizzare in modo grafico i valori numerici.

Conclusione

Questo articolo fornisce una panoramica completa di Taipy e di come portare il front-end e il back-end a qualsiasi data e modelli di machine learning per creare applicazioni web completamente funzionali.

Inoltre, con la nuova versione, Taipy fornisce elementi visivi di Core che consentono l’integrazione senza soluzione di continuità tra il front-end e il back-end, consentendo agli utenti di creare oggetti aziendali potenti senza sforzo, e queste integrazioni sono disponibili sul sito ufficiale.

Se sei ancora incerto sull’uso di Taipy, è il momento di provarlo per risparmiare tempo, energia e, soprattutto, denaro. Infine, questi fantastici tutorial di Taipy possono aiutarti a migliorare ulteriormente la tua apprendimento e rafforzare le tue competenze.