Un ghid pas cu pas pentru implementarea modelelor ML folosind Streamlit

Publicat: 2020-12-07

Cuprins

Introducere

Majoritatea pasionaților de învățare automată se înscriu la unele cursuri și curriculum-uri pentru a începe cu AI și ML. Aceste cursuri acoperă o mulțime de lucruri fundamentale și îi îndrumă pe cursanți să construiască și să antreneze modelele de ML de ultimă generație.

Dar un lucru cu care se luptă majoritatea începătorilor este partea de desfășurare. Un proiect de învățare automată nu poate fi lăsat așa cum este fără nicio aplicație interactivă în jurul lui. Pentru a permite utilizatorilor să interacționeze cu ușurință cu modelul sau chiar să ne expunem proiectele, trebuie să le includem în aplicații web, aplicații Android sau un fel de structuri API care utilizează servicii cloud.

Există diverse modalități de a construi aceste ambalaje pentru modelele noastre, dar în acest articol, mă voi concentra asupra modului în care puteți utiliza Streamlit ca soluție pentru această problemă și de ce îl consider un instrument atât de puternic.

Acest articol va avea un ghid pas cu pas pentru construirea unui proiect ML și crearea unei platforme de aplicații web pentru acesta folosind Streamlit. Proiectul pe care îl vom construi este un model de predicție a prețurilor caselor din California. Site-ul va fi dinamic și hiperparametri precum rata de învățare, numărul de neuroni etc. pot fi modificați și experimentați chiar prin aplicația web.

Dacă mergeți mai departe cu construirea unei astfel de aplicații web folosind niște cadre precum Flask sau Django, sunt aproape sigur că va dura mult timp pentru a construi mai întâi acea interfață de utilizare și apoi există o altă problemă de a o găzdui pe un server, astfel încât poate fi accesibil tuturor.

Și aici se ridică întrebarea principală: „De ce ar trebui pasionații de învățare automată să-și piardă timpul învățând niște cadre de interfață de utilizare, când pot folosi în schimb acel timp prețios pentru a învăța pentru a construi modele mai bune?”

Vor fi o mulțime de subiecte abordate aici despre cum să utilizați Streamlit pentru proiectele dvs. Simțiți-vă liber să treceți la părțile despre care doriți să aflați mai multe.

De ce Streamlit?
Construirea unui model ML de bază
Adăugarea Streamlit care folosește magia
Implementarea aplicației web Streamlit
Concluzie

De ce Streamlit?

Streamlit ne face foarte ușor și rapid să construim o aplicație web de învățare automată. Alte modalități care sunt disponibile pentru dezvoltarea unor astfel de ambalaje pentru modelele ML nu sunt foarte confortabile.

Flask este un cadru python care permite utilizatorilor să dezvolte aplicații web și să le implementeze folosind limbajul python. Necesită o bună cunoaștere a pythonului și, de asemenea, trebuie să investim timp în învățarea acestuia. Chiar și după aceea, nu este foarte ușor să dezvoltați o aplicație web în comparație cu Streamlit.

Django este un alt cadru bazat pe Python pentru dezvoltarea web. Se poate spune că este o versiune mai bună și complexă a Flask. Este nevoie de mult timp dedicat pentru a învăța acest cadru și, în cele din urmă, construirea unei aplicații web folosind-o nu este atât de rapidă pe cât ne-am dori să fie.

Tensorflow.js este o modalitate foarte bună de a salva modele care sunt compatibile cu platformele web și apoi aceste modele pot fi folosite pentru a construi aplicații web. Multe dintre implementările complexe ale modelelor ML și arhitecturilor de nivel înalt nu sunt încă acceptate de Tensorflow.js. Există multe modele care vor funcționa în Python și s-ar putea să nu funcționeze pe Javascript în biblioteca Tensorflow.js.

După cum am spus mai devreme, nu ar trebui să ne pierdem timpul învățând aceste cadre, ci în schimb să învățăm cum să construim modele ML bune. Și aici intervine Streamlit. Este cel mai simplu și mai rapid mod de a dezvolta aplicații web. Aplicațiile web create folosind Streamlit au elemente excelente de interfață și sunt foarte ușor de utilizat.

Pentru a susține afirmația mea conform căreia Streamlit este cel mai simplu și rapid mod de a construi aplicații web ML, permiteți-mi să vă împărtășesc cum am întâlnit acest cadru. Învățam cum să construiesc GAN-uri și să le folosesc pentru a genera fețe artificiale, a converti schițele alb-negru în schițe colorate și astfel de implementări.

Modelele au funcționat bine în notebook-ul Jupyter, dar am vrut să-l împărtășesc cu alții. Am început să caut cadre pentru a construi o aplicație și a găzdui modelul, dar nu am vrut să-mi pierd timpul învățând încă un cadru, deoarece voiam să explorez alte implementări GAN.

Am verificat toate resursele alternative despre care am vorbit mai devreme în acest articol. Modelul generator folosit în proiectul de generare Sketch-To-Color este puțin complex. Este un model de arhitectură U-Net și necesită săriți peste conexiuni.

Datorită complexității sale mari, nu am putut converti modelul final pentru Javascript folosind Tensorflow.js. Învățarea Flask sau Django de la zero nu a fost o opțiune pentru mine, așa că am început să caut alte cadre sau biblioteci.

Atunci am dat de Streamlit. Într-un articol al lui Adrien Treuille, el arată cum a creat o aplicație web uimitoare pentru un TL-GAN în mai puțin de 13 linii de cod. Toate acestea au fost posibile doar datorită Streamlit.

Documentația de pe site-ul lor oficial este, de asemenea, foarte precisă și utilă. Am încercat să fac o aplicație web Streamlit pentru modelul meu Sketch to Color GANs și a fost uimitor. A trebuit să adaug doar 12 linii de cod la codul meu python existent. Acesta este motivul pentru care, în cele din urmă, am continuat cu explorarea Streamlit și construirea altor proiecte folosindu-l.

Construirea unui model ML de bază

După cum sa menționat mai devreme, vom analiza problema predicției prețului caselor din California pentru acest exemplu. În primul rând, să vedem cum construim în mod normal un model pentru asta. Este o problemă de regresie.

În primul rând, vom importa bibliotecile necesare pentru modelul nostru simplu ML. Aici vom folosi TensorFlow, panda și NumPy.

import tensorflow ca tf

import numpy ca np

importa panda ca pd

Acum, vom folosi seturile de date de la Scikit-Learn pentru a descărca setul de date privind locuințele din California.

din sklearn.datasets import fetch_california_housing

carcasă = fetch_california_housing()

Apoi, trebuie să împărțim datele încărcate în seturi de tren, validare și testare. Există multe metode disponibile pentru a face acest lucru. Vom folosi funcția train_test_split disponibilă în biblioteca Scikit-Learn. Folosirea lui de două ori va împărți setul de date în 3 seturi de tren, validare și testare.

din sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = tren_test_split(

locuințe.date, locuințe.țintă

)

X_train, X_valid, y_train, y_valid = tren_test_split(

X_train_full, y_train_full

)

Datele disponibile au valorile de longitudine și latitudine ale fiecărei intrări. Pentru a vizualiza mai bine acest lucru, putem face un grafic de dispersie pe o hartă. Pentru a folosi hărțile, vom importa biblioteca Altair .

Importă altair ca alt

map_data = pd.DataFrame(

X_tren,

coloane=[

„MedInc”,

„HouseAge”,

„AveRooms”,

„AveBedrms”,

„Populație”,

„AveOccup”,

'latitudine',

'longitudine'

])

punct de mijloc = (np.average(date_hartă[„latitudine”), np.medie(date_hartă[„longitudine”]))

st.write(pdk.Deck(

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

initial_view_state={

„latitudine”: punct de mijloc[0],

„longitudine”: punct de mijloc[1],

„zoom”: 6,

„pitch”: 75,

straturi=[

pdk.Layer(

„HexagonLayer”,

date=map_date,

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

raza=1000,

elevation_scale=4,

elevation_range=[0, 10000],

pickable=Adevărat,

extrudat=Adevărat,

))

Datele pe care le avem acum la noi nu sunt procesate bine pentru model. Trebuie să facem preprocesarea pentru a obține rezultate mai bune. În primul rând, va trebui să normalizăm valorile, deoarece majoritatea modelelor de învățare automată funcționează cel mai bine atunci când datele sunt într-un interval mic de valori. Pentru aceasta, vom folosi clasa StandardScaler din biblioteca sklearn.

din sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

După pregătirea datelor, vom crea acum un model. Acest model va fi o rețea neuronală cu un număr specificat de neuroni în primul strat de intrare și un singur neuron în ultimul strat, deoarece este o problemă de regresie. Acest lucru poate fi realizat prin utilizarea bibliotecii TensorFlow.

import tensorflow ca tf

model = tf.keras.models.Sequential([

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

tf.keras.layers.Dense(1)

])

În TensorFlow, trebuie să compilam modelul după ce îl construim. Aici trebuie să menționăm funcția de pierdere pe care o vom folosi și, de asemenea, optimizatorul pe care îl dorim. Vom folosi funcția de pierdere a erorii pătrate medii și optimizatorul SGD cu o rată de învățare specifică.

model.compile(

loss='eroare_medie_pătratică',

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

)

Totul este la locul lui acum. Tot ce trebuie să facem este să antrenăm modelul. În TensorFlow, acest lucru se poate face prin simpla apelare a metodei fit(). Putem salva toate jurnalele într-o variabilă, istoric .

istoric = model.fit(

X_tren,

y_train,

epoci=n_epochs,

validation_data=(X_valid, y_valid)

)

După antrenament, putem evalua, de asemenea, acuratețea și pierderea modelului nostru folosind metoda evaluate().

evaluare = model.evaluate(X_test, y_test)

Acum, dacă dorim să prezicem orice preț al casei utilizând acest model, o putem face doar apelând metoda predict() .

X_new = X_test[:3]

predictions = model.predict(X_new)

Acesta este modul în care puteți construi un model simplu de predicție a prețului casei folosind TensorFlow, scikit-learn și panda. Dar problema, după cum puteți vedea, este că nu există nicio modalitate de a arăta acest model altor utilizatori unde pot interacționa cu el și acesta este doar un model în interiorul unui notebook Jupyter. Așa că acum să adăugăm ceva magie cu Streamlit!

Citește și: Idei de proiecte de învățare automată

Adăugarea magiei folosind Streamlit

Pentru a crea o aplicație web Machine Learning, trebuie doar să adăugați câteva rânduri de cod pentru apelurile de funcții Streamlit și gata. Nu aveți nevoie de HTML, CSS sau Javascript. Doar piton pur!

Da, ai citit corect. Nu trebuie să vă faceți griji pentru nimic altceva. Doar instalați Streamlit pe sistemul dvs. și veți fi gata de plecare. Utilizați următoarea comandă în terminalele dvs.:

pip install streamlit

Puteți folosi următoarea comandă pentru a explora în aplicația lor Hello World. Este un bun exemplu al modului în care arată aplicațiile web folosind Streamlit.:

streamlit salut

După ce ați instalat Streamlit local și ați adăugat linia magică la cod, trebuie doar să executați următoarea comandă pentru a rula aplicația local:

streamlit run file_name.py

Deci întrebarea este acum: „Ce sunt acele linii magice de cod?” Sunt destul de simple. Voi explica mai întâi funcțiile de bază utilizate în Streamlit și apoi voi arăta codul, astfel încât să îl puteți lega direct cu exemplul.

Înainte de orice, vom importa biblioteca streamlit folosind următoarea linie de cod:

import streamlit ca st

Prima caracteristică importantă este că puteți pur și simplu să tastați orice între cele 3 ghilimele duble, care arată pur și simplu textul așa cum este în aplicația web. Acceptă sintaxa limbajului markdown. Deci, puteți face o mulțime de lucruri, cum ar fi antete, puncte, tabele și multe altele. De asemenea, puteți utiliza funcția st.write() în loc de această notație. Are aceeași funcționalitate.

Urmează funcția cu st.echo() :. Practic, acesta execută codul Python scris în el și apoi îl arată și în aplicația web. În acest fel, putem construi o aplicație web care arată cum a fost construită.

st.empty() este o zonă care este rezervată mai târziu pentru un anumit conținut dinamic.

st.spinner() arată un element de încărcare atunci când există o întârziere în executarea unei bucăți de cod.

st.success() arată un mesaj în culoarea verde. Acesta are un aspect deosebit de design al dialogurilor de succes.

st.sidebar() afișează implicit conținutul într-o bară laterală la stânga.

st.sidebar.slider() oferă un glisor în bara laterală pentru a alege valori dintr-un interval de numere date. st.sidebar.selectbox() vă permite să selectați o valoare din lista dată și Streamlit are multe mai multe funcții minunate și caracteristici incluse în el. Unele dintre caracteristici sunt următoarele:

Schimbări live atunci când salvați fișierul
Reluați aplicația prin simpla apăsare pe R de pe tastatură
O cache golită prin simpla apăsare a C de pe tastatură
Înregistrați aplicația web și salvați un fișier video local pentru a-l partaja cu toată lumea

…Și mult mai mult

Trebuie citit: Carieră în învățare automată

Codul

import streamlit ca st

import altair ca alt

import pydeck ca pdk

zona_tren = st.empty()

„””

# Prețurile locuințelor din California

Acesta este setul de date privind prețurile locuințelor din California, care conține date extrase de la recensământul din 1990 din SUA. Următorul tabel oferă descrieri, intervale de date și tipuri de date pentru fiecare caracteristică din setul de date.

## Să aruncăm mai întâi o privire asupra importurilor
„””
cu st.echo():
import tensorflow ca tf
import numpy ca np
importa panda ca pd
„””
## Se încarcă setul de date
Vom folosi modulul setului de date al scikit-learn pentru a conduce date care sunt deja curățate pentru noi și au doar caracteristici numerice.
„””
cu st.echo():
din sklearn.datasets import fetch_california_housing
carcasă = fetch_california_housing()
„””
Aceasta va încărca toate datele în variabila „locuință”, așa cum puteți vedea mai jos
„””
st.subheader('Caracteristici de intrare')
locuințe.date
st.subheader('Etichete de ieșire')
locuinţă.ţintă
„””
## Împărțirea datelor în seturi Train, Test și Dev
Acesta este unul dintre cele mai importante lucruri la începutul oricărei soluții de învățare automată, deoarece rezultatul oricărui model poate depinde foarte mult de cât de bine ați distribuit datele în aceste seturi.
Din fericire pentru noi, avem scikit-learn la salvare, unde a devenit la fel de ușor ca 2 linii de cod.
„””
cu st.echo():
din sklearn.model_selection import train_test_split
X_train_full, X_test, y_train_full, y_test = tren_test_split(
locuințe.date, locuințe.țintă
)
X_train, X_valid, y_train, y_valid = tren_test_split(
X_train_full, y_train_full
)
„””
Funcția `train_test_split()` împarte datele în 2 seturi în care setul de testare reprezintă 25% din setul total de date. Am folosit din nou aceeași funcție pe train_full pentru a o împărți în tren și seturi de validare. 25% este un parametru implicit și îl puteți modifica în funcție de nevoile dvs. Aruncă o privire la aceasta din [Documentația lui Scikit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).
## Aruncând o privire la datele trenului
Coloanele reprezintă următoarele date:
„””
st.write(housing.feature_names)
„””
Acum să ne uităm la locația caselor prin trasarea acesteia pe hartă folosind valorile de Latitudine și Longitudine:
„””
cu st.echo():
map_data = pd.DataFrame(
X_tren,
coloane=[
„MedInc”,
„HouseAge”,
„AveRooms”,
„AveBedrms”,
„Populație”,
„AveOccup”,
'latitudine',
'longitudine'
])
punct de mijloc = (np.average(date_hartă[„latitudine”), np.medie(date_hartă[„longitudine”]))
st.write(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={
„latitudine”: punct de mijloc[0],
„longitudine”: punct de mijloc[1],
„zoom”: 6,
„pitch”: 75,
},
straturi=[
pdk.Layer(
„HexagonLayer”,
date=map_date,
get_position=[„longitudine”, „latitudine”],
raza=1000,
elevation_scale=4,
elevation_range=[0, 10000],
pickable=Adevărat,
extrudat=Adevărat,
),
],
))
„””
**Nu ezitați să măriți sau să trageți în timp ce apăsați tasta ALT pentru a schimba unghiul de vizualizare 3D al hărții, după cum este necesar.**
## Preprocesare
După cum sa subliniat mai devreme, acest set de date este deja bine preprocesat de scikit-learn pentru ca noi să-l folosim direct, fără să ne facem griji cu privire la valorile NaN și alte lucruri.
Deși, vom scala valorile în intervale specifice utilizând „StandardScaler” pentru a ajuta modelul nostru să funcționeze eficient.
„””
cu st.echo():
din sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)
„””
## Crearea unui model
Vom crea un model secvențial simplu cu primul strat care conține 30 de neuroni și funcția de activare a RELU.
Următorul strat va fi un singur strat de neuroni fără funcție de activare, deoarece dorim ca modelul să prezică o gamă de valori și nu doar rezultate binare sau multiclase, cum ar fi problemele de clasificare.
„””
st.sidebar.title('Hiperparametri')
n_neurons = st.sidebar.slider('Neuroni', 1, 128, 30)
l_rate = st.sidebar.selectbox('Rata de învățare', (0,0001, 0,001, 0,01), 1)
n_epochs = st.sidebar.number_input('Numărul de epoci', 1, 50, 20)
#N_neurons, l_rate și _nepochs sunt intrările luate de la utilizator pentru antrenamentul modelului. Sunt setate și valorile implicite pentru ele. Valoarea implicită pentru n_neurons este 30, valoarea implicită pentru l_rate este 0,01 și valoarea implicită pentru n_epochs este 20. Deci, la început, modelul va avea 30 de neuroni în primul strat, rata de învățare va fi 0,01 și numărul de epoci pentru pentru care modelul se va antrena este de 20.
cu st.echo():
import tensorflow ca tf

model = tf.keras.models.Sequential([
tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(1)
])
„””
## Compilarea modelului
API-ul Tensorflow keras ne oferă funcția `model.compile()` pentru a atribui optimizatorii, funcția de pierdere și alte câteva detalii pentru model.
„””
cu st.echo():
model.compile(
loss='eroare_medie_pătratică',
optimizer=tf.keras.optimizers.SGD(l_rate)
)
„””
## Antrenarea modelului
Pentru a antrena modelul trebuie pur și simplu să apelați funcția `fit()` pe modelul cu setul de antrenament și validare și un număr de epoci pentru care doriți să se antreneze modelul.
**Încercați să jucați cu hiperparametrii din bara laterală din partea stângă și faceți clic pe butonul `Model de tren` de mai jos pentru a începe antrenamentul.**
„””
tren = st.button('Model de tren')
daca tren:
cu st.spinner('Model de antrenament...'):
cu st.echo():
model.summary(print_fn=lambda x: st.write(“{}”.format(x)))
istoric = model.fit(
X_tren,
y_train,
epoci=n_epochs,
validation_data=(X_valid, y_valid)
)
st.success('Model Training Complete!')
„””
## Performanța modelului
„””
cu st.echo():
st.line_chart(pd.DataFrame(history.history))
„””
## Evaluarea modelului pe setul de testare
Din nou, un alt pas important, dar ușor de făcut, este să vă evaluați modelul pe baza datelor de testare pe care nu le-a văzut niciodată înainte. Amintiți-vă că ar trebui să faceți acest lucru numai după ce sunteți suficient de sigur de modelul pe care l-ați construit și ar trebui să rezistați la orice reglare a hiperparametrului după ce ați evaluat modelul pe setul de testare, deoarece l-ar face mai bine pentru setul de testare și din nou va exista fi o problemă de generalizare atunci când modelul va vedea date noi în faza de producție.
„””
cu st.echo():
evaluare = model.evaluate(X_test, y_test)
evaluare
„””
> Această pierdere pe setul de testare este puțin mai gravă decât pe setul de validare, ceea ce este așa cum era de așteptat, deoarece modelul nu a văzut niciodată imaginile din setul de testare.
„””
„””
## Predicții folosind modelul
„””
cu st.echo():
X_new = X_test[:3]
predictions = model.predict(X_new)
„””
### Previziuni
„””
previziuni
„””
### Adevărul de bază
„””
y_test[:3]
Asta a fost! Doar câteva rânduri de cod suplimentar și ați creat deja o aplicație web grozavă, care arată frumos și are și conținut dinamic. Nu a fost atât de greu, nu-i așa? Încercați să construiți diferite proiecte și să utilizați alte funcții ale Streamlit din documentația lor. Este destul de ușor și intuitiv.
Citiți: Învățare automată cu Python
Implementarea aplicației web Streamlit
Aplicațiile web Streamlit pot fi implementate pentru utilizare directă prin diferite opțiuni disponibile pe internet. Putem să le parcurgem pe scurt și să vedem cum se poate face.
Înainte de a merge pe alte platforme care ne pot ajuta să implementăm aplicațiile noastre web, să vedem ce ne oferă Streamlit. O versiune foarte recentă a funcției pe care au făcut-o este Streamlit Sharing. Acest lucru permite utilizatorilor să-și implementeze aplicațiile web Streamlit cu un singur clic.
Dacă aveți codul încărcat în depozitele dvs. GitHub, puteți alege pur și simplu depozitul din tabloul de bord al Streamlit și îl va găzdui automat pentru dvs. Este foarte uimitor și complet gratuit de acum. Nu a existat nicio modalitate mai ușoară înainte de a implementa aplicații web de învățare automată.
Heroku este o altă metodă bună de a implementa aplicația web Streamlit. În acest fel, nu va trebui să alegeți niciun server cloud și apoi să configurați instanțe virtuale în ele. Totul este îngrijit de Heroku.
Există un dezavantaj simplu în Heroku că versiunea sa gratuită nu vă va permite să aveți toate pachetele mai mari de dimensiunea de 512 MB într-o versiune gratuită. TensorFlow 2.2.0 pe care l-am folosit pentru proiect este puțin mai mare decât spațiul specificat, așa că a trebuit să folosesc alte servicii.
AWS (Amazon Web Services) este, de asemenea, o modalitate bună de a vă implementa aplicațiile Streamlit. Este puțin complex pentru un începător, dar pe măsură ce îl utilizați, devine mai ușor de configurat. Ele oferă instanțe EC2 gratuite pentru utilizatorii noi. Puteți lansa unul cu Ubuntu 18.04 sau o versiune ulterioară și puteți instala toate dependențele necesare pentru aplicație.
După ce totul este configurat, puteți rula aplicația folosind comanda – streamlit run filename.py. Aici, veți obține o adresă URL publică care poate fi partajată tuturor. Un dezavantaj major aici este că aplicația nu este disponibilă online dacă închideți instanța. Deci, o instanță gratuită va avea unele limitări.
Dacă aveți codul în depozitul GitHub, există o altă modalitate grozavă de a vă găzdui aplicația. Nu este foarte profesionist și legitim, deoarece utilizatorul trebuie să aibă instalat și Streamlit pe sistemele lor.
Dacă Streamlit este disponibil pe sistem și aveți linkul pentru fișierul python al aplicației Streamlit, atunci puteți rula aplicația web prin simpla executare a comenzii: streamlit run url . Puteți verifica aplicația mea local dacă ați instalat Streamlit. Utilizați următoarea comandă în terminalele dvs.:
streamlit run https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py
Concluzie
Ați văzut cât de simplu, dar puternic este Streamlit. Nu am întâlnit până acum un astfel de instrument care să mă fi ajutat în această măsură și să-mi ușureze viața de dezvoltare. De aceea, consider că Streamlit este un cadru impresionant care poate ajuta pe toată lumea să se concentreze asupra părților importante ale dezvoltării învățării automate și să ne ajute să ne concentrăm mai mult pe învățările majore ale AI și ML. Acest lucru face curba de învățare mult mai ușoară și ne permite să construim și să implementăm cu ușurință proiecte de hobby.
Un lucru care face ca acest cadru să fie atât de simplu pentru implementare este documentația lor oficială. Tot ce este scris în documente este precis și simplu. Vă sugerez să parcurgeți documentele o dată și să încercați să implementați un nou proiect. Este cel mai bun mod de a începe cu orice framework nou. Găsiți documentația oficială Streamlit pe următorul link — https://docs.streamlit.io/en/stable/ target="_blank” rel=”nofollow” .
Comunitatea este întotdeauna cea mai bună resursă pentru a învăța lucruri și pentru a găsi o problemă cu soluțiile noastre. Streamlit are un forum de discuții minunat unde puteți posta orice întrebări referitoare la procesul de dezvoltare a unei aplicații Streamlit, orice îndoieli cu privire la implementare, solicitări de funcții, rapoarte de erori și orice altceva care vă poate ajuta să vă construiți aplicația cu succes. Alăturați-vă forumului de discuții pe următorul link - https://discuss.streamlit.io/
Dacă sunteți interesat să aflați mai multe despre învățarea automată, consultați Diploma PG de la IIIT-B și upGrad în Învățare automată și AI, care este concepută pentru profesioniști care lucrează și oferă peste 450 de ore de pregătire riguroasă, peste 30 de studii de caz și sarcini, IIIT- B Statut de absolvenți, peste 5 proiecte practice practice și asistență pentru locuri de muncă cu firme de top.
Care este cea mai mare dificultate în implementarea unui proiect de învățare automată?
Cea mai mare dificultate în implementarea unui proiect de învățare automată este caracterul incomplet al colectării datelor. De cele mai multe ori timpul și banii nu sunt suficiente pentru a colecta toate datele necesare pentru a avea o analiză precisă. Prin urmare, datele culese trebuie să fie de încredere și de bună calitate. În plus, trebuie alese datele potrivite. Alegerea datelor este cheia pentru implementarea unui proiect.
Ce este Streamlit în învățarea automată?
Streamlit este un algoritm incremental pentru învățarea automată. Acesta exploatează faptul că spațiul de căutare al rețelelor neuronale este foarte mare și că antrenamentul este rapid și, prin urmare, nu trebuie să caute întreg spațiul, dar poate construi o rețea neuronală la nivel local. StreamLit este o formă de memorie pe termen lung, utilizată pentru procesarea datelor secvențiale. Este un algoritm de învățare profundă care a folosit RNN-uri pentru a codifica datele în vectori de numere. Acești vectori pot fi utilizați pentru a reprezenta date în grafice sau text. Poate fi folosit și pentru a genera text în limbaj natural.
Cum implementez folosind Streamlit?
Implementarea cu Streamlit este simplă. În primul rând, trebuie să aveți un cont Streamlit. În al doilea rând, aveți nevoie de software care poate fi implementat. De exemplu, Beanstalk, S3 sau rsync. În al treilea rând, trebuie să vă pregătiți software-ul pentru implementare. Copiați aplicația pe serverul dvs. web folosind rsync. Dacă implementați un site web nou, atunci site-ul web este directorul pe care l-ați copiat. Dacă implementați un site web existent, atunci site-ul încărcat este directorul pe care l-ați copiat. În partea stângă a ecranului, sub