Una guida dettagliata alla distribuzione di modelli ML utilizzando Streamlit

introduzione

La maggior parte degli appassionati di Machine Learning si iscrive ad alcuni corsi e programmi per iniziare con AI e ML. Questi corsi coprono molte cose fondamentali e guidano accuratamente gli studenti a costruire e addestrare i modelli ML all'avanguardia.

Ma una cosa con cui la maggior parte dei principianti lotta è la parte di distribuzione. Un progetto di machine learning non può essere lasciato così com'è senza alcuna app interattiva attorno ad esso. Per consentire agli utenti di interagire facilmente con il modello o anche per mostrare i nostri progetti, dobbiamo avvolgerli in app Web, app Android o qualche tipo di struttura API utilizzando servizi cloud.

Esistono vari modi per creare questi wrapper per i nostri modelli, ma in questo articolo mi concentrerò su come utilizzare Streamlit come soluzione per questo problema e perché lo considero uno strumento così potente.

Questo articolo conterrà una guida passo passo per la creazione di un progetto ML e la creazione di una piattaforma per app Web utilizzando Streamlit. Il progetto che costruiremo è un modello California House Price Prediction. Il sito sarà dinamico e gli iperparametri come il tasso di apprendimento, il numero di neuroni, ecc. possono essere modificati e sperimentati direttamente tramite l'app web.

Se vai avanti con la creazione di un'app Web del genere utilizzando alcuni framework come Flask o Django, sono quasi certo che ci vorrà molto tempo per creare prima quell'interfaccia utente, e poi c'è un altro problema di ospitarla su un server in modo che può essere accessibile a tutti.

E qui sorge la domanda principale: "Perché gli appassionati di Machine Learning dovrebbero perdere tempo ad apprendere alcuni framework dell'interfaccia utente quando possono invece utilizzare quel tempo prezioso per imparare a costruire modelli migliori?"

Ci saranno molti argomenti trattati qui su come usare Streamlit per i tuoi progetti. Sentiti libero di saltare alle parti di cui vuoi saperne di più.

• Perché Streamlit?
• Costruire un modello ML di base
• Aggiunta dello Streamlit che utilizza la magia
• Distribuzione dell'app Web Streamlit
• Conclusione

Perché Streamlit?

Streamlit ci rende molto facile e veloce la creazione di un'app Web di Machine Learning. Altri modi disponibili per lo sviluppo di tali wrapper per i modelli ML non sono molto comodi.

Flask è un framework Python che consente agli utenti di sviluppare app Web e distribuirle utilizzando il linguaggio Python. Richiede una buona conoscenza di Python e dobbiamo anche investire tempo per impararlo. Anche dopo, non è molto facile sviluppare un'app web rispetto a Streamlit.

Django è un altro framework basato su Python per lo sviluppo web. Si può dire che è una versione migliore e complessa di Flask. Richiede molto tempo dedicato all'apprendimento di questo framework e alla fine la creazione di un'app Web che lo utilizza non è così veloce come vorremmo.

Tensorflow.js è un ottimo modo per salvare modelli compatibili con piattaforme Web e quindi questi modelli possono essere utilizzati per creare app Web. Molte delle complesse implementazioni di modelli ML e architetture di alto livello non sono ancora supportate da Tensorflow.js. Esistono molti modelli che funzioneranno in Python e potrebbero non funzionare su Javascript nella libreria Tensorflow.js.

Come ho detto prima, non dovremmo perdere tempo ad apprendere questi framework e invece imparare a costruire buoni modelli ML. Ed è qui che entra in gioco Streamlit. È il modo più semplice e veloce per sviluppare applicazioni web. Le app Web create utilizzando Streamlit hanno ottimi elementi dell'interfaccia utente e sono molto facili da usare.

Per supportare la mia affermazione secondo cui Streamlit è il modo più semplice e veloce per creare app Web ML, consentitemi di condividere con voi come mi sono imbattuto in questo framework. Stavo imparando come costruire GAN e usarlo per generare volti artificiali, convertire schizzi in bianco e nero in schizzi colorati e implementazioni simili.

I modelli funzionavano bene nel notebook Jupyter ma volevo condividerlo con altri. Ho iniziato a cercare framework per creare un'app e ospitare il modello, ma non volevo perdere tempo ad apprendere un altro framework poiché volevo esplorare altre implementazioni GAN.

Ho controllato tutte le risorse alternative di cui ho parlato in questo articolo in precedenza. Il modello del generatore utilizzato nel progetto di generazione Sketch-To-Color è un po' complesso. È un modello di architettura U-Net e richiede di saltare le connessioni.

A causa della sua elevata complessità, non sono stato in grado di convertire il modello finale per Javascript utilizzando Tensorflow.js. Imparare Flask o Django da zero non era un'opzione per me, quindi ho iniziato a cercare altri framework o librerie.

Questo è quando mi sono imbattuto in Streamlit. In un articolo di Adrien Treuille, mostra come ha creato una straordinaria app Web per un TL-GAN in meno di 13 righe di codice. Tutto questo è stato possibile solo grazie a Streamlit.

Anche la documentazione sul loro sito ufficiale è molto precisa e utile. Ho provato a creare un'app Web Streamlit per il mio modello GAN Sketch to Color ed è stato fantastico. Ho dovuto solo aggiungere 12 righe di codice al mio codice Python esistente. Questo è il motivo per cui alla fine sono andato avanti con l'esplorazione di Streamlit e la creazione di altri progetti utilizzandolo.

Costruire un modello ML di base

Come affermato in precedenza, esamineremo il problema della previsione del prezzo delle abitazioni in California per questo esempio. Prima di tutto, vediamo come costruiamo normalmente un modello per questo. È un problema di regressione.

Per prima cosa importeremo le librerie richieste per il nostro semplice modello ML. Qui useremo TensorFlow, Pandas e NumPy.

importa flusso tensoriale come tf

importa numpy come np

importa panda come pd

Ora utilizzeremo i set di dati di Scikit-Learn per scaricare il set di dati sulle abitazioni della California.

da sklearn.datasets import fetch_california_housing

alloggiamento = fetch_california_housing()

Successivamente, è necessario suddividere i dati caricati in set di treni, convalida e test. Ci sono molti metodi disponibili per farlo. Useremo la funzione train_test_split disponibile nella libreria Scikit-Learn. Usarlo due volte dividerà il set di dati in 3 set di treno, convalida e test.

da sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

dati.abitativi, obiettivo.abitativo

)

X_treno, X_valido, y_treno, y_valid = treno_test_split(

X_treno_completo, y_treno_completo

)

I dati a nostra disposizione hanno i valori di longitudine e latitudine di ciascuna voce. Per visualizzarlo meglio, possiamo creare un grafico a dispersione su una mappa. Per utilizzare le mappe, importeremo la libreria Altair .

Importa altair come alt

map_data = pd.DataFrame(

X_treno,

colonne=[

'MedInc',

'House Age',

'AveRooms',

'AveBedrms',

'Popolazione',

'AveOccup',

'latitudine',

'longitudine'

])

punto medio = (np.average(map_data[“latitudine”]), np.average(map_data[“longitude”])))

st.write(pdk.Deck(

map_style="mapbox://styles/mapbox/light-v9″,

initial_view_state={

“latitudine”: punto medio[0],

“longitudine”: punto medio[1],

“zoom”: 6,

“campo”: 75,

},

strati=[

pdk.Layer(

"Strato esagonale",

dati=mappa_dati,

get_position=[“longitudine”, “latitudine”],

raggio=1000,

elevazione_scala=4,

elevazione_intervallo=[0, 10000],

selezionabile=Vero,

estruso=Vero,

),

],

))

I dati che abbiamo con noi ora non vengono elaborati bene per il modello. Dobbiamo eseguire la preelaborazione per ottenere risultati migliori. Prima di tutto, dovremo normalizzare i valori poiché la maggior parte dei modelli di Machine Learning funziona meglio quando i dati si trovano in un piccolo intervallo di valori. Per questo, useremo la classe StandardScaler dalla libreria sklearn.

da sklearn.preprocessing import StandardScaler

scaler = scaler standard()

X_treno = scaler.fit_transform(X_treno)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

Dopo aver preparato i dati, creeremo ora un modello. Questo modello sarà una rete neurale con un numero specificato di neuroni nel primo livello di input e un singolo neurone nell'ultimo livello in quanto è un problema di regressione. Ciò può essere ottenuto utilizzando la libreria TensorFlow.

importa flusso tensoriale come tf

modello = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

In TensorFlow, dobbiamo compilare il modello dopo averlo creato. Qui dobbiamo menzionare la funzione di perdita che utilizzeremo e anche l'ottimizzatore che vogliamo. Useremo la funzione di perdita dell'errore quadratico medio e l'ottimizzatore SGD con un tasso di apprendimento specifico.

modello.compila(

perdita = 'mean_squared_error',

ottimizzatore=tf.keras.optimizers.SGD(l_rate)

)

Tutto è a posto ora. Tutto quello che dobbiamo fare è addestrare il modello. In TensorFlow, questo può essere fatto semplicemente chiamando il metodo fit(). Possiamo salvare tutti i log in una variabile, history .

cronologia = modello.fit(

X_treno,

y_train,

epoche=n_epoche,

validation_data=(X_valido, y_valido)

)

Dopo l'addestramento, possiamo anche valutare l'accuratezza e la perdita del nostro modello utilizzando il metodo Evaluation().

valutazione = modello.valuta(X_test, y_test)

Ora, se vogliamo prevedere i prezzi delle case usando questo modello, possiamo semplicemente farlo chiamando il metodo predict() .

X_nuovo = X_test[:3]

previsioni = model.predict(X_new)

Ecco come puoi costruire un semplice modello di previsione dei prezzi delle case usando TensorFlow, scikit-learn e panda. Ma il problema come puoi vedere è che non c'è modo di mostrare questo modello ad altri utenti dove possono interagire con esso e questo è solo un modello all'interno di un notebook Jupyter. Quindi ora aggiungiamo un po' di magia con Streamlit!

Leggi anche: Idee per progetti di apprendimento automatico

Aggiungere la magia usando Streamlit

Per creare un'app Web di Machine Learning, devi solo aggiungere alcune righe di codice per le chiamate di funzione Streamlit e il gioco è fatto. Non hai bisogno di HTML, CSS o Javascript. Solo puro pitone!

Sì, avete letto bene. Non devi preoccuparti di nient'altro. Installa Streamlit sul tuo sistema e sarai pronto per partire. Usa il seguente comando nei tuoi terminali:

pip install streamlit

Puoi usare il comando seguente per esplorare la loro app Hello World. È un buon esempio di come appaiono le app Web utilizzando Streamlit.:

snello ciao

Dopo aver installato Streamlit in locale e aver aggiunto la linea magica al codice è sufficiente eseguire il seguente comando per eseguire l'app in locale:

corsa semplificata nome_file.py

Quindi la domanda ora è: "Quali sono quelle linee di codice magiche?" Sono abbastanza semplici. Spiegherò prima le funzioni di base utilizzate in Streamlit e poi mostrerò il codice in modo che tu possa collegarlo direttamente con l'esempio.

Prima di ogni altra cosa, importeremo la libreria semplificata utilizzando la seguente riga di codice:

importare snello come st

La prima caratteristica importante è che puoi semplicemente digitare qualsiasi cosa tra le 3 virgolette, mostra semplicemente il testo così com'è sull'app web. Supporta la sintassi del linguaggio markdown. Quindi puoi fare molte cose come intestazioni, elenchi puntati, tabelle e molto altro. Puoi anche usare la funzione st.write() invece di questa notazione. Ha la stessa funzionalità.

La prossima è la funzione with st.echo() :. Questo fondamentalmente esegue il codice Python scritto al suo interno e quindi lo mostra anche sull'app Web. In questo modo possiamo creare un'app Web che mostra come è stata creata.

st.empty() è un'area riservata ad alcuni contenuti dinamici in seguito.

st.spinner() mostra un elemento di caricamento quando c'è un certo ritardo nell'esecuzione di un pezzo di codice.

st.success() mostra un messaggio in verde. Questo ha un grande aspetto progettuale dei dialoghi di successo.

st.sidebar() mostra il contenuto in una barra laterale a sinistra per impostazione predefinita.

st.sidebar.slider() fornisce un dispositivo di scorrimento nella barra laterale per scegliere i valori da un intervallo di numeri dati. st.sidebar.selectbox() consente di selezionare un valore dall'elenco fornito e Streamlit ha molte altre meravigliose funzioni e caratteristiche racchiuse in esso. Alcune delle caratteristiche sono le seguenti:

• Modifiche in tempo reale quando si salva il file
• Riesegui l'app semplicemente premendo R sulla tastiera
• Una cache vuota semplicemente premendo C sulla tastiera
• Registra l'app Web e salva un file video in locale da condividere con tutti

…E altro ancora

Da leggere: Carriera nell'apprendimento automatico

Il codice

importare snello come st

importa altair come alt

importa pydeck come pdk

area_treno = st.vuoto()

“””

# Prezzi delle abitazioni in California

Questo è il set di dati sui prezzi delle abitazioni in California che contiene i dati tratti dal censimento degli Stati Uniti del 1990. La tabella seguente fornisce descrizioni, intervalli di dati e tipi di dati per ciascuna funzionalità nel set di dati.

## Diamo prima un'occhiata alle importazioni

“””

con st.echo():

importa flusso tensoriale come tf

importa numpy come np

importa panda come pd

“””

## Caricamento del set di dati

Useremo il modulo del set di dati di scikit-learn per portare i dati che sono già stati puliti per noi e hanno solo le caratteristiche numeriche.

“””

con st.echo():

da sklearn.datasets import fetch_california_housing

alloggiamento = fetch_california_housing()

“””

Questo caricherà tutti i dati nella variabile `housing` come puoi vedere di seguito

“””

st.subheader('Caratteristiche di input')

dati.abitativi

st.subheader('Etichette di output')

obiettivo.abitativo

“””

## Suddivisione dei dati in set Train, Test e Dev

Questa è una delle cose più importanti all'inizio di qualsiasi soluzione di Machine Learning, poiché il risultato di qualsiasi modello può dipendere in larga misura da quanto bene hai distribuito i dati in questi set.

Fortunatamente per noi, abbiamo scikit-learn in soccorso dove è diventato facile come 2 righe di codice.

“””

con st.echo():

da sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

dati.abitativi, obiettivo.abitativo

)

X_treno, X_valido, y_treno, y_valid = treno_test_split(

X_treno_completo, y_treno_completo

)

“””

La funzione `train_test_split()` divide i dati in 2 set in cui il set di test è il 25% del set di dati totale. Abbiamo usato di nuovo la stessa funzione su train_full per dividerlo in set di treni e di convalida. 25% è un parametro predefinito e puoi modificarlo secondo le tue esigenze. Dai un'occhiata dalla [Documentazione di Scikit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).

## Dando un'occhiata ai dati del treno

Le colonne rappresentano i seguenti dati:

“””

st.write(housing.feature_names)

“””

Ora diamo un'occhiata alla posizione delle case tracciandola sulla mappa utilizzando i valori di Latitudine e Longitudine:

“””

con st.echo():

map_data = pd.DataFrame(

X_treno,

colonne=[

'MedInc',

'House Age',

'AveRooms',

'AveBedrms',

'Popolazione',

'AveOccup',

'latitudine',

'longitudine'

])

punto medio = (np.average(map_data[“latitudine”]), np.average(map_data[“longitude”])))

st.write(pdk.Deck(

map_style="mapbox://styles/mapbox/light-v9″,

initial_view_state={

“latitudine”: punto medio[0],

“longitudine”: punto medio[1],

“zoom”: 6,

“campo”: 75,

},

strati=[

pdk.Layer(

"Strato esagonale",

dati=mappa_dati,

get_position=[“longitudine”, “latitudine”],

raggio=1000,

elevazione_scala=4,

elevazione_intervallo=[0, 10000],

selezionabile=Vero,

estruso=Vero,

),

],

))

“””

**Sentiti libero di ingrandire o trascinare mentre premi il tasto ALT per modificare l'angolo di visualizzazione 3D della mappa, come richiesto.**

## Preelaborazione

Come sottolineato in precedenza, questo set di dati è già ben preelaborato da scikit-learn per poterlo utilizzare direttamente senza preoccuparsi di valori NaN e altre cose.

Tuttavia, scaleremo i valori in intervalli specifici utilizzando "StandardScaler" per aiutare il nostro modello a funzionare in modo efficiente.

“””

con st.echo():

da sklearn.preprocessing import StandardScaler

scaler = scaler standard()

X_treno = scaler.fit_transform(X_treno)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

“””

## Creazione di un modello

Creeremo un semplice modello sequenziale con il primo strato contenente 30 neuroni e la funzione di attivazione di RELU.

Il livello successivo sarà un singolo livello neuronale senza funzione di attivazione poiché vogliamo che il modello preveda un intervallo di valori e non solo risultati binari o multiclasse come problemi di classificazione.

“””

st.sidebar.title('Iperparametri')

n_neuroni = st.sidebar.slider('Neuroni', 1, 128, 30)

l_rate = st.sidebar.selectbox('Tasso di apprendimento', (0.0001, 0.001, 0.01), 1)

n_epochs = st.sidebar.number_input('Numero di epoche', 1, 50, 20)

#The n_neurons, l_rate e _nepochs sono gli input presi dall'utente per addestrare il modello. Vengono impostati anche i valori predefiniti per loro. Il valore predefinito per n_neurons è 30, il valore predefinito per l_rate è 0,01 e il valore predefinito per n_epochs è 20. Quindi all'inizio il modello avrà 30 neuroni nel primo livello, la velocità di apprendimento sarà 0,01 e il numero di epoche per per cui il modello si allenerà è 20.

con st.echo():

importa flusso tensoriale come tf

modello = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

“””

## Compilazione del modello

Tensorflow keras API ci fornisce la funzione `model.compile()` per assegnare gli ottimizzatori, la funzione di perdita e alcuni altri dettagli per il modello.

“””

con st.echo():

modello.compila(

perdita = 'mean_squared_error',

ottimizzatore=tf.keras.optimizers.SGD(l_rate)

)

“””

## Addestrare il modello

Per addestrare il modello devi semplicemente chiamare la funzione `fit()` sul modello con il set di training e validazione e un numero di epoche per cui vuoi che il modello si alleni.

**Prova a giocare con gli iperparametri dalla barra laterale sul lato sinistro e fai clic sul pulsante `Train Model` riportato di seguito per iniziare l'allenamento.**

“””

treno = st.button('Modello treno')

se treno:

with st.spinner('Modello di allenamento...'):

con st.echo():

model.summary(print_fn=lambda x: st.write(“{}”.format(x)))

cronologia = modello.fit(

X_treno,

y_train,

epoche=n_epoche,

validation_data=(X_valido, y_valido)

)

st.success('Addestramento modello completato!')

“””

## Prestazioni del modello

“””

con st.echo():

st.line_chart(pd.DataFrame(history.history))

“””

## Valutazione del modello sul set di test

Ancora un altro passo importante ma facile da fare è valutare il tuo modello sui dati di test che non ha mai visto prima. Ricorda che dovresti farlo solo dopo che sei abbastanza sicuro del modello che hai costruito e dovresti resistere alla messa a punto di qualsiasi iperparametro dopo aver valutato il modello sul set di test poiché lo renderebbe semplicemente migliore per il set di test e di nuovo ci sarà essere un problema di generalizzazione quando il modello vedrà nuovi dati nella fase di produzione.

“””

con st.echo():

valutazione = modello.valuta(X_test, y_test)

valutazione

“””

> Questa perdita sul set di test è leggermente peggiore di quella sul set di convalida, che è come previsto, poiché il modello non ha mai visto le immagini del set di test.

“””

“””

## Previsioni usando il Modello

“””

con st.echo():

X_nuovo = X_test[:3]

previsioni = model.predict(X_new)

“””

### Predizioni

“””

predizioni

“””

### Realtà di base

“””

y_test[:3]

Era questo! Solo poche righe di codice extra e hai già creato un'ottima app Web che sembra bella e ha anche contenuti dinamici. Non è stato così difficile, vero? Prova a costruire diversi progetti e ad utilizzare altre funzioni di Streamlit dalla loro documentazione. È abbastanza facile e intuitivo.

Leggi: Machine Learning con Python

Distribuzione dell'app Web ottimizzata

Le app Web ottimizzate possono essere distribuite per l'uso diretto tramite varie opzioni disponibili su Internet. Possiamo esaminarli brevemente e vedere come si può fare.

Prima di passare a qualsiasi altra piattaforma che possa aiutarci a distribuire le nostre app Web, vediamo cosa ha da offrirci Streamlit. Una versione di funzionalità molto recente che hanno fatto è Streamlit Sharing. Ciò consente agli utenti di distribuire le proprie app Web Streamlit con un solo clic.

Se hai caricato il tuo codice sui tuoi repository GitHub, puoi semplicemente scegliere il repository dalla dashboard di Streamlit e lo ospiterà automaticamente per te. È molto sorprendente e totalmente gratuito a partire da ora. Non esisteva un modo più semplice prima di distribuire app Web di machine learning.

Heroku è un altro buon metodo per distribuire l'app Web Streamlit. In questo modo non dovrai selezionare alcun server cloud e quindi configurare istanze virtuali al loro interno. È tutto curato da Heroku.

C'è un semplice inconveniente in Heroku che la sua versione gratuita non ti consentirà di avere tutti i pacchetti di dimensioni superiori a 512 MB in una versione gratuita. TensorFlow 2.2.0 che ho usato per il progetto è un po' più grande dello spazio specificato, quindi ho dovuto usare altri servizi.

AWS (Amazon Web Services) è anche un bel modo per distribuire le tue app Streamlit. È un po' complesso per un principiante, ma man mano che lo usi, diventa più facile da configurare. Forniscono istanze EC2 gratuite per i nuovi utenti. Puoi avviarne uno con Ubuntu 18.04 o versioni successive e installare tutte le dipendenze necessarie per l'app.

Dopo aver impostato tutto, puoi eseguire l'app usando il comando – streamlit run filename.py. Qui otterrai un URL pubblico che può essere condiviso con tutti. Uno dei principali inconvenienti qui è che l'app non è disponibile online se si spegne l'istanza. Quindi un'istanza gratuita avrà alcune limitazioni.

Se hai il codice nel repository GitHub, c'è un altro modo interessante per ospitare la tua app. Non è molto professionale e legittimo perché l'utente deve avere Streamlit installato anche sui propri sistemi.

Se Streamlit è disponibile sul sistema e si dispone del collegamento per il file Python dell'app Streamlit, è possibile eseguire l'app Web semplicemente eseguendo il comando: streamlit run url . Puoi controllare la mia app in locale se hai installato Streamlit. Usa il seguente comando nei tuoi terminali:

corsa ottimizzata https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py

Conclusione

Hai visto quanto è semplice ma potente Streamlit. Non ho mai incontrato uno strumento del genere prima che mi abbia aiutato in questa misura e ha reso la mia vita di sviluppo più facile. Quindi, questo è il motivo per cui ritengo che Streamlit sia un framework impressionante che può aiutare tutti a concentrarsi sulle parti importanti dello sviluppo di Machine Learning e aiutarci a concentrarci maggiormente sui principali apprendimenti di AI e ML. Ciò rende la curva di apprendimento molto più semplice e ci consente di creare e distribuire facilmente progetti di hobby.

Una cosa che rende questo framework così semplice per l'implementazione è la loro documentazione ufficiale. Tutto ciò che è scritto nei documenti è preciso e semplice. Ti suggerisco di esaminare i documenti una volta e provare a implementare un nuovo progetto. È il modo migliore per iniziare con qualsiasi nuovo framework. Trova la documentazione ufficiale di Streamlit al seguente link: https://docs.streamlit.io/en/stable/ target=”_blank” rel=”nofollow” .

La community è sempre la migliore risorsa per imparare le cose e trovare un problema con le nostre soluzioni. Streamlit ha un meraviglioso forum di discussione in cui puoi pubblicare qualsiasi domanda relativa al processo di sviluppo di un'app Streamlit, qualsiasi dubbio riguardante la distribuzione, richieste di funzionalità, segnalazioni di bug e qualsiasi altra cosa che potrebbe aiutarti a creare la tua app con successo. Unisciti al forum di discussione al seguente link — https://discuss.streamlit.io/

Se sei interessato a saperne di più sull'apprendimento automatico, dai un'occhiata al Diploma PG di IIIT-B e upGrad in Machine Learning e AI, progettato per i professionisti che lavorano e offre oltre 450 ore di formazione rigorosa, oltre 30 casi di studio e incarichi, IIIT- B Status di Alumni, oltre 5 progetti pratici pratici e assistenza sul lavoro con le migliori aziende.

Qual è la difficoltà maggiore nell'implementazione di un progetto di machine learning?

La difficoltà maggiore nell'implementazione di un progetto di Machine Learning è l'incompletezza della raccolta dei dati. Il più delle volte il tempo e il denaro non sono sufficienti per raccogliere tutti i dati necessari per avere un'analisi accurata. Pertanto, i dati raccolti devono essere affidabili e di buona qualità. Inoltre, devono essere scelti i dati corretti. La scelta dei dati è fondamentale per la realizzazione di un progetto.

Che cos'è Streamlit nell'apprendimento automatico?

Streamlit è un algoritmo incrementale per l'apprendimento automatico. Sfrutta il fatto che lo spazio di ricerca delle reti neurali è molto ampio e che l'addestramento è veloce, quindi non ha bisogno di cercare l'intero spazio, ma può costruire una rete neurale localmente. StreamLit è una forma di memoria a lungo termine utilizzata per l'elaborazione di dati sequenziali. È un algoritmo di deep learning che utilizzava gli RNN per codificare i dati in vettori di numeri. Questi vettori possono essere utilizzati per rappresentare dati in grafici o testo. Può anche essere utilizzato per generare testo in linguaggio naturale.

Come faccio a distribuire utilizzando Streamlit?

La distribuzione con Streamlit è semplice. Innanzitutto, devi avere un account Streamlit. In secondo luogo, è necessario un software che possa essere distribuito. Ad esempio, Beanstalk, S3 o rsync. Terzo, è necessario preparare il software per la distribuzione. Copia la tua app sul tuo server web usando rsync. Se stai distribuendo un nuovo sito Web, il sito Web è la directory che hai copiato. Se stai distribuendo un sito Web esistente, il sito Web caricato è la directory che hai copiato. Sul lato sinistro dello schermo sotto il