Przewodnik krok po kroku dotyczący wdrażania modeli ML za pomocą Streamlit

Opublikowany: 2020-12-07

Spis treści

Wstęp

Większość entuzjastów uczenia maszynowego zapisuje się na niektóre kursy i programy nauczania, aby rozpocząć pracę z AI i ML. Kursy te obejmują wiele podstawowych rzeczy i zgrabnie prowadzą uczniów do budowania i trenowania najnowocześniejszych modeli ML.

Ale jedną rzeczą, z którą zmaga się większość początkujących, jest część rozmieszczania. Projektu uczenia maszynowego nie można pozostawić bez żadnej interaktywnej aplikacji wokół niego. Aby umożliwić użytkownikom łatwą interakcję z modelem, a nawet zaprezentowanie naszych projektów, musimy umieścić je w aplikacjach internetowych, aplikacjach na Androida lub pewnego rodzaju strukturach API korzystających z usług w chmurze.

Istnieje wiele sposobów na zbudowanie tych opakowań dla naszych modeli, ale w tym artykule skupię się na tym, jak można wykorzystać Streamlit jako rozwiązanie tego problemu i dlaczego uważam go za tak potężne narzędzie.

Ten artykuł będzie zawierał przewodnik krok po kroku dotyczący tworzenia projektu ML i tworzenia dla niego platformy aplikacji internetowej przy użyciu Streamlit. Projekt, który będziemy budować, to model California House Price Prediction. Witryna będzie dynamiczna, a hiperparametry, takie jak szybkość uczenia się, liczba neuronów itp., będą mogły być zmieniane i eksperymentowane bezpośrednio w aplikacji internetowej.

Jeśli pójdziesz dalej z budową takiej aplikacji internetowej przy użyciu niektórych frameworków, takich jak Flask lub Django, jestem prawie pewien, że najpierw zbudowanie tego interfejsu użytkownika zajmie dużo czasu, a potem pojawia się kolejny problem z hostowaniem go na serwerze, aby może być dostępny dla każdego.

I tu pojawia się główne pytanie: „Dlaczego entuzjaści uczenia maszynowego mieliby tracić czas na naukę niektórych struktur interfejsu użytkownika, skoro mogą zamiast tego wykorzystać ten cenny czas na naukę tworzenia lepszych modeli?”.

Będzie tu omawianych wiele tematów dotyczących korzystania ze Streamlit w swoich projektach. Możesz przejść do części, o których chcesz dowiedzieć się więcej.

Dlaczego Streamlit?
Budowanie podstawowego modelu ML
Dodawanie magii za pomocą Streamlit
Wdrażanie aplikacji internetowej Streamlit
Wniosek

Dlaczego Streamlit?

Dzięki Streamlit bardzo łatwo i szybko zbudujemy aplikację internetową do uczenia maszynowego. Inne dostępne sposoby opracowywania takich opakowań dla modeli ML nie są zbyt wygodne.

Flask to framework Pythona, który pozwala użytkownikom tworzyć aplikacje internetowe i wdrażać je przy użyciu języka Pythona. Wymaga dobrej znajomości Pythona, a także zainwestowania czasu w jego naukę. Nawet po tym nie jest łatwo stworzyć aplikację internetową w porównaniu ze Streamlitem.

Django to kolejna oparta na Pythonie platforma do tworzenia stron internetowych. Można powiedzieć, że to lepsza i bardziej rozbudowana wersja Flaska. Nauczenie się tego frameworka wymaga dużo czasu, a ostatecznie budowanie aplikacji internetowej przy jego użyciu nie jest tak szybkie, jak byśmy tego chcieli.

Tensorflow.js to świetny sposób na zapisywanie modeli, które są kompatybilne z platformami internetowymi, a następnie modele te można wykorzystać do tworzenia aplikacji internetowych. Wiele złożonych implementacji modeli ML i architektur wysokiego poziomu nie jest jeszcze obsługiwanych przez Tensorflow.js. Istnieje wiele modeli, które będą działać w Pythonie i mogą nie działać w JavaScript w bibliotece Tensorflow.js.

Jak powiedziałem wcześniej, nie powinniśmy marnować czasu na naukę tych frameworków, a zamiast tego nauczyć się budować dobre modele ML. I tutaj pojawia się Streamlit. Jest to najprostszy i najszybszy sposób tworzenia aplikacji internetowych. Aplikacje internetowe budowane przy użyciu Streamlit mają świetne elementy interfejsu użytkownika i są bardzo łatwe w użyciu.

Aby wesprzeć moje twierdzenie, że Streamlit jest najłatwiejszym i najszybszym sposobem tworzenia aplikacji internetowych ML, pozwól, że podzielę się z Tobą, w jaki sposób natrafiłem na ten framework. Uczyłem się budować GAN-y i używać ich do generowania sztucznych twarzy, konwertowania czarno-białych szkiców na kolorowe i tego typu implementacji.

Modele działały dobrze w notatniku Jupyter, ale chciałem podzielić się nim z innymi. Zacząłem szukać frameworków do zbudowania aplikacji i hostowania modelu, ale nie chciałem tracić czasu na naukę kolejnego frameworka, ponieważ chciałem poznać inne implementacje GAN.

Sprawdziłem wszystkie alternatywne zasoby, o których mówiłem w tym artykule wcześniej. Model generatora użyty w projekcie generowania szkicu do koloru jest nieco skomplikowany. Jest to model architektury U-Net i wymaga pomijania połączeń.

Ze względu na dużą złożoność nie mogłem przekonwertować ostatecznego modelu na Javascript przy użyciu Tensorflow.js. Nauka Flaska czy Django od podstaw nie była dla mnie opcją, więc zacząłem szukać innych frameworków lub bibliotek.

Wtedy natknąłem się na Streamlit. W artykule Adriena Treuille pokazuje, jak zbudował niesamowitą aplikację internetową dla TL-GAN w 13 liniach kodu. To wszystko było możliwe tylko dzięki Streamlitowi.

Dokumentacja na ich oficjalnej stronie internetowej jest również bardzo precyzyjna i pomocna. Próbowałem stworzyć aplikację internetową Streamlit dla mojego modelu Sketch to Color GANs i było to niesamowite. Musiałem tylko dodać 12 linii kodu do mojego istniejącego kodu Pythona. Dlatego w końcu zacząłem odkrywać Streamlit i budować z niego inne projekty.

Budowanie podstawowego modelu ML

Jak wspomniano wcześniej, w tym przykładzie przyjrzymy się problemowi prognozowania cen domów w Kalifornii. Przede wszystkim zobaczmy, jak zwykle budujemy do tego model. Jest to problem regresji.

Najpierw zaimportujemy wymagane biblioteki dla naszego prostego modelu ML. Tutaj będziemy używać TensorFlow, pand i NumPy.

importuj tensorflow jako tf

importuj numer jako np

importuj pandy jako PD

Teraz użyjemy zestawów danych z Scikit-Learn, aby pobrać zestaw danych dotyczących mieszkań w Kalifornii.

ze sklearn.datasets importuj fetch_california_housing

obudowa = fetch_california_housing()

Następnie musimy podzielić załadowane dane na zestawy pociągów, walidacji i testów. Jest na to wiele sposobów. Wykorzystamy funkcję train_test_split dostępną w bibliotece Scikit-Learn. Użycie go dwukrotnie podzieli zbiór danych na 3 zestawy pociągów, walidacji i testów.

ze sklearn.model_selection importuj train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

obudowa.dane, obudowa.docelowa

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_pociąg_pełny, y_pociąg_pełny

)

Dostępne nam dane zawierają wartości długości i szerokości geograficznej każdego wpisu. Aby lepiej to zobrazować, możemy zrobić wykres punktowy na mapie. Aby korzystać z map, zaimportujemy bibliotekę Altair .

Importuj Altair jako alt

map_data = pd.DataFrame(

X_pociąg,

kolumny=[

„Medycyna”,

"Wiek Domu",

„AveRooms”,

"AveBedrms",

'Populacja',

„Zajmuj”,

'szerokość',

'długość geograficzna'

])

punkt środkowy = (np.średnia(dane_mapy[„szerokość”]), np.średnia(dane_mapy[„długość geograficzna”]))

st.write(pdk.Deck(

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

Initial_view_state={

„szerokość geograficzna”: punkt środkowy[0],

„długość geograficzna”: punkt środkowy[1],

„powiększenie”: 6,

„wysokość”: 75,

warstwy=[

pdk.Warstwa(

„Warstwa Sześciokątna”,

dane=dane_mapy,

get_position=[„długość geograficzna”, „szerokość geograficzna”],

promień=1000,

skala_wysokości=4,

zakres_wysokości=[0, 10000],

do wyboru=prawda,

wytłaczane=prawda,

))

Dane, które teraz mamy u nas, nie są dobrze przetwarzane dla modelu. Aby uzyskać lepsze wyniki, musimy wykonać wstępne przetwarzanie. Przede wszystkim będziemy musieli znormalizować wartości, ponieważ większość modeli uczenia maszynowego działa najlepiej, gdy dane znajdują się w małym zakresie wartości. W tym celu użyjemy klasy StandardScaler z biblioteki sklearn.

ze sklearn.preprocessing import StandardScaler

skaler = Standardowy skaler()

X_train = scaler.fit_transform(X_train)

X_valid = skaler.transform(X_valid)

X_test = skaler.transform(X_test)

Po przygotowaniu danych stworzymy teraz model. Model ten będzie siecią neuronową z określoną liczbą neuronów w pierwszej warstwie wejściowej i pojedynczym neuronem w ostatniej warstwie, ponieważ jest to problem regresji. Można to osiągnąć za pomocą biblioteki TensorFlow.

importuj tensorflow jako tf

model = tf.keras.models.Sequential([

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

tf.keras.warstwy.gęste(1)

])

W TensorFlow musimy skompilować model po jego zbudowaniu. Tutaj musimy wspomnieć o funkcji straty, której będziemy używać, a także o optymalizatorze, którego potrzebujemy. Będziemy używać funkcji straty średniokwadratowej i optymalizatora SGD z określoną szybkością uczenia się.

model.kompilacja(

strata='mean_squared_error',

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

)

Wszystko jest już na swoim miejscu. Wszystko, co musimy zrobić, to wytrenować model. W TensorFlow można to zrobić po prostu wywołując metodę fit(). Wszystkie logi możemy zapisać w zmiennej historii .

historia = model.fit(

X_pociąg,

y_pociąg,

epoki=n_epok,

validation_data=(X_valid, y_valid)

)

Po szkoleniu możemy również ocenić dokładność i stratę naszego modelu za pomocą metody assessment().

ocena = model.ocena(X_test, y_test)

Teraz, jeśli chcemy przewidzieć jakiekolwiek ceny domów za pomocą tego modelu, możemy po prostu zrobić to, wywołując metodę przewidywania() .

X_nowy = X_test[:3]

prognozy = model.predict(X_new)

W ten sposób można zbudować prosty model przewidywania ceny domu przy użyciu TensorFlow, scikit-learn i pand. Ale problem, jak widać, polega na tym, że nie ma sposobu, aby pokazać ten model innym użytkownikom, gdzie mogą z nim wchodzić w interakcje, a to tylko model w notatniku Jupyter. Dodajmy więc teraz trochę magii dzięki Streamlit!

Przeczytaj także: Pomysły na projekty uczenia maszynowego

Dodawanie magii za pomocą Streamlit

Aby stworzyć aplikację internetową do uczenia maszynowego, wystarczy dodać kilka wierszy kodu dla wywołań funkcji Streamlit i to wszystko. Nie potrzebujesz żadnego HTML, CSS ani Javascript. Po prostu czysty pyton!

Tak, dobrze przeczytałeś. Nie musisz się o nic martwić. Po prostu zainstaluj Streamlit w swoim systemie i będziesz gotowy do pracy. Użyj następującego polecenia w swoich terminalach:

pip install streamlit

Możesz użyć następującego polecenia, aby zbadać okolicę w aplikacji Hello World. Jest to dobry przykład tego, jak wyglądają aplikacje internetowe przy użyciu Streamlit.:

opływowy cześć

Po zainstalowaniu Streamlit lokalnie i dodaniu magicznej linii do kodu wystarczy wykonać następujące polecenie, aby uruchomić aplikację lokalnie:

streamlit run nazwa_pliku.py

Więc teraz pytanie brzmi: „Czym są te magiczne linijki kodu?” Są dość proste. Najpierw wyjaśnię podstawowe funkcje używane w Streamlit, a następnie pokażę kod, abyś mógł bezpośrednio powiązać go z przykładem.

Przede wszystkim zaimportujemy bibliotekę streamlit za pomocą następującego wiersza kodu:

importuj streamlit jako st

Pierwszą ważną funkcją jest to, że możesz po prostu wpisać cokolwiek w 3 podwójnych cudzysłowach, które po prostu pokazują tekst tak, jak jest w aplikacji internetowej. Obsługuje składnię języka przecen. Możesz więc zrobić wiele rzeczy, takich jak nagłówki, wypunktowania, tabele i wiele więcej. Możesz również użyć funkcji st.write() zamiast tej notacji. Ma taką samą funkcjonalność.

Następna jest funkcja with st.echo() :. To w zasadzie wykonuje napisany w nim kod Pythona, a następnie pokazuje go również w aplikacji internetowej. W ten sposób możemy zbudować aplikację internetową, która pokaże, jak została zbudowana.

st.empty() to obszar, który jest później zarezerwowany dla niektórych treści dynamicznych.

st.spinner() pokazuje element ładujący, gdy występuje opóźnienie w wykonaniu fragmentu kodu.

st.success() wyświetla komunikat w kolorze zielonym. Ma to świetny aspekt projektowania dialogów sukcesu.

st.sidebar() domyślnie wyświetla zawartość na pasku bocznym po lewej stronie.

st.sidebar.slider() udostępnia suwak na pasku bocznym do wybierania wartości z zakresu podanych liczb. st.sidebar.selectbox() pozwala wybrać wartość z podanej listy, a Streamlit ma o wiele więcej wspaniałych funkcji i funkcji. Niektóre z funkcji są następujące:

Zmiany na żywo po zapisaniu pliku
Uruchom ponownie aplikację, naciskając klawisz R na klawiaturze
Wyczyść pamięć podręczną po prostu naciskając C na klawiaturze
Nagraj aplikację internetową i zapisz lokalnie plik wideo, aby udostępnić go wszystkim

…I wiele więcej

Musisz przeczytać: Kariera w uczeniu maszynowym

Kod

importuj streamlit jako st

importuj altair jako alt

importuj pydeck jako pdk

obszar_pociągu = st.pusty()

„””

# Ceny mieszkań w Kalifornii

Jest to zbiór danych dotyczących cen mieszkań w Kalifornii, który zawiera dane pochodzące z amerykańskiego spisu ludności z 1990 roku. Poniższa tabela zawiera opisy, zakresy danych i typy danych dla każdej funkcji w zestawie danych.
## Przyjrzyjmy się najpierw importom
„””
z st.echo():
importuj tensorflow jako tf
importuj numer jako np
importuj pandy jako PD
„””
## Ładowanie zbioru danych
Wykorzystamy moduł zestawu danych scikit-learn do prowadzenia danych, które są już dla nas wyczyszczone i mają tylko cechy liczbowe.
„””
z st.echo():
ze sklearn.datasets importuj fetch_california_housing
obudowa = fetch_california_housing()
„””
Spowoduje to załadowanie wszystkich danych do zmiennej `housing`, jak widać poniżej
„””
st.subheader('Funkcje wejściowe')
dane.mieszkaniowe
st.subheader('Etykiety wyjściowe')
obudowa.cel
„””
## Podział danych na zestawy Train, Test i Dev
Jest to jedna z najważniejszych rzeczy na początku każdego rozwiązania uczenia maszynowego, ponieważ wynik dowolnego modelu może w dużym stopniu zależeć od tego, jak dobrze rozmieściłeś dane w tych zestawach.
Na szczęście dla nas mamy scikit-learning na ratunek, gdzie stało się to tak proste, jak 2 linijki kodu.
„””
z st.echo():
ze sklearn.model_selection importuj train_test_split
X_train_full, X_test, y_train_full, y_test = train_test_split(
obudowa.dane, obudowa.docelowa
)
X_train, X_valid, y_train, y_valid = train_test_split(
X_pociąg_pełny, y_pociąg_pełny
)
„””
Funkcja `train_test_split()` dzieli dane na 2 zestawy, gdzie zestaw testowy stanowi 25% całego zestawu danych. Ponownie użyliśmy tej samej funkcji w train_full, aby podzielić ją na zestawy pociągów i walidacji. 25% to domyślny parametr i możesz go dostosować do swoich potrzeb. Spójrz na to z [Dokumentacji Scikit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).
## Spojrzenie na dane pociągu
Kolumny reprezentują następujące dane:
„””
st.write(obudowa.feature_names)
„””
Przyjrzyjmy się teraz lokalizacji domów, wykreślając je na mapie za pomocą wartości szerokości i długości geograficznej:
„””
z st.echo():
map_data = pd.DataFrame(
X_pociąg,
kolumny=[
„Medycyna”,
"Wiek Domu",
„AveRooms”,
"AveBedrms",
'Populacja',
„Zajmuj”,
'szerokość',
'długość geograficzna'
])
punkt środkowy = (np.średnia(dane_mapy[„szerokość”]), np.średnia(dane_mapy[„długość geograficzna”]))
st.write(pdk.Deck(
map_style="mapbox://style/mapbox/light-v9",
Initial_view_state={
„szerokość geograficzna”: punkt środkowy[0],
„długość geograficzna”: punkt środkowy[1],
„powiększenie”: 6,
„wysokość”: 75,
},
warstwy=[
pdk.Warstwa(
„Warstwa Sześciokątna”,
dane=dane_mapy,
get_position=[„długość geograficzna”, „szerokość geograficzna”],
promień=1000,
skala_wysokości=4,
zakres_wysokości=[0, 10000],
do wyboru=prawda,
wytłaczane=prawda,
),
],
))
„””
**Możesz swobodnie powiększać lub przeciągać, jednocześnie naciskając klawisz ALT, aby zmienić kąt widzenia 3D mapy, zgodnie z wymaganiami.**
## Przetwarzanie wstępne
Jak wskazano wcześniej, ten zestaw danych jest już dobrze przetworzony przez scikit-learn, abyśmy mogli go używać bezpośrednio, bez martwienia się o jakiekolwiek wartości NaN i inne rzeczy.
Chociaż zamierzamy skalować wartości w określonych zakresach za pomocą „StandardScaler”, aby usprawnić działanie naszego modelu.
„””
z st.echo():
ze sklearn.preprocessing import StandardScaler
skaler = Standardowy skaler()
X_train = scaler.fit_transform(X_train)
X_valid = skaler.transform(X_valid)
X_test = skaler.transform(X_test)
„””
## Tworzenie modelu
Będziemy tworzyć prosty model sekwencyjny z pierwszą warstwą zawierającą 30 neuronów i funkcją aktywacji RELU.
Następną warstwą będzie pojedyncza warstwa neuronowa bez funkcji aktywacji, ponieważ chcemy, aby model przewidywał zakres wartości, a nie tylko wyniki binarne lub wieloklasowe, takie jak problemy z klasyfikacją.
„””
st.sidebar.title('Hiperparametry')
n_neurony = st.sidebar.slider('Neurony', 1, 128, 30)
l_rate = st.sidebar.selectbox('Wskaźnik uczenia', (0,0001, 0,001, 0,01), 1)
n_epochs = st.sidebar.number_input('Liczba epok', 1, 50, 20)
#N_neurony, l_rate i _nepochs to dane wejściowe pobierane od użytkownika w celu uczenia modelu. Ustawiane są również dla nich wartości domyślne. Domyślna wartość dla n_neuronów to 30, domyślna wartość dla l_rate to 0,01, a domyślna wartość dla n_epok to 20. Czyli na początku model będzie miał 30 neuronów w pierwszej warstwie, szybkość uczenia się wyniesie 0,01 a liczba epok dla dla których model będzie trenował to 20.
z st.echo():
importuj tensorflow jako tf

model = tf.keras.models.Sequential([
tf.keras.layers.Dense(n_neurony, aktywacja='relu', input_shape=X_train.shape[1:]),
tf.keras.warstwy.gęste(1)
])
„””
## Kompilacja modelu
Tensorflow keras API udostępnia nam funkcję `model.compile()` do przypisania optymalizatorów, funkcji straty i kilku innych szczegółów do modelu.
„””
z st.echo():
model.kompilacja(
strata='mean_squared_error',
optymalizator=tf.keras.optimizers.SGD(l_rate)
)
„””
## Szkolenie modelki
Aby trenować model, wystarczy wywołać funkcję `fit()` na modelu z zestawem uczenia i walidacji oraz liczbą epok, dla których chcesz trenować model.
**Spróbuj grać z hiperparametrami z paska bocznego po lewej stronie i kliknij przycisk „Train Model” podany poniżej, aby rozpocząć trening.**
„””
train = st.button('Model pociągu')
jeśli pociąg:
z st.spinner('Model szkoleniowy…'):
z st.echo():
model.summary(print_fn=lambda x: st.write("{}".format(x)))
historia = model.fit(
X_pociąg,
y_pociąg,
epoki=n_epok,
validation_data=(X_valid, y_valid)
)
st.success('Trening modelowania zakończony!')
„””
## Model wydajność
„””
z st.echo():
st.line_chart(pd.DataFrame(history.history))
„””
## Ocena modelu na zestawie testowym
Ponownie, kolejnym ważnym, ale łatwym krokiem do wykonania jest ocena modelu na podstawie danych testowych, których nigdy wcześniej nie widział. Pamiętaj, że powinieneś to zrobić tylko wtedy, gdy jesteś wystarczająco pewny co do zbudowanego modelu i powinieneś powstrzymać się od dostrajania hiperparametrów po ocenie modelu w zestawie testowym, ponieważ po prostu poprawiłoby to dla zestawu testowego i znowu będzie będzie problemem generalizacji, gdy model zobaczy nowe dane w fazie produkcji.
„””
z st.echo():
ocena = model.ocena(X_test, y_test)
ocena
„””
> Ta strata w zestawie testowym jest nieco gorsza niż w zestawie walidacyjnym, co jest zgodne z oczekiwaniami, ponieważ model nigdy nie widział obrazów z zestawu testowego.
„””
„””
## Prognozy z wykorzystaniem modelu
„””
z st.echo():
X_nowy = X_test[:3]
prognozy = model.predict(X_new)
„””
### Prognozy
„””
prognozy
„””
### Prawda naziemna
„””
test_y[:3]
To było to! Tylko kilka linijek dodatkowego kodu i masz już zbudowaną świetną aplikację internetową, która wygląda pięknie i ma również dynamiczną zawartość. To nie było takie trudne, prawda? Spróbuj budować różne projekty i korzystać z innych funkcji Streamlit z ich dokumentacji. To dość proste i intuicyjne.
Przeczytaj: Uczenie maszynowe w Pythonie
Wdrażanie aplikacji internetowej Streamlit
Aplikacje internetowe Streamlit można wdrażać do bezpośredniego użytku za pomocą różnych opcji dostępnych w Internecie. Możemy je krótko przejrzeć i zobaczyć, jak można to zrobić.
Zanim przejdziemy do innych platform, które mogą nam pomóc we wdrażaniu naszych aplikacji internetowych, zobaczmy, co Streamlit ma nam do zaoferowania. Bardzo niedawnym wydaniem funkcji, które zrobili, jest Streamlit Sharing. Dzięki temu użytkownicy mogą jednym kliknięciem wdrażać swoje aplikacje internetowe Streamlit.
Jeśli masz swój kod przesłany do repozytoriów GitHub, możesz po prostu wybrać repozytorium z pulpitu nawigacyjnego Streamlit, a ono automatycznie je hostuje. Jest bardzo niesamowity i od teraz całkowicie darmowy. Nie było prostszego sposobu na wdrażanie aplikacji internetowych do uczenia maszynowego.
Heroku to kolejna dobra metoda wdrażania aplikacji internetowej Streamlit. W ten sposób nie będziesz musiał wybierać żadnych serwerów w chmurze, a następnie konfigurować na nich instancje wirtualne. Tym wszystkim zajmuje się Heroku.
Heroku ma jedną prostą wadę, ponieważ jego darmowa wersja nie pozwala na posiadanie wszystkich pakietów większych niż 512 MB w wersji darmowej. TensorFlow 2.2.0, którego użyłem do projektu, jest trochę większy niż podana przestrzeń, więc musiałem skorzystać z innych usług.
AWS (Amazon Web Services) to także dobry sposób na wdrażanie aplikacji Streamlit. Jest to trochę skomplikowane dla początkującego, ale w miarę korzystania z niego staje się łatwiejsze do skonfigurowania. Zapewniają bezpłatne instancje EC2 dla nowych użytkowników. Możesz uruchomić jeden z Ubuntu 18.04 lub nowszym i zainstalować wszystkie zależności wymagane dla aplikacji.
Po skonfigurowaniu wszystkiego możesz uruchomić aplikację za pomocą polecenia – streamlit run filename.py. Tutaj otrzymasz publiczny adres URL, który można udostępnić wszystkim. Jedną z głównych wad jest to, że aplikacja nie jest dostępna online, jeśli zamkniesz instancję. Tak więc darmowa instancja będzie miała pewne ograniczenia.
Jeśli masz kod w repozytorium GitHub, istnieje inny fajny sposób hostowania aplikacji. Nie jest to bardzo profesjonalne i uzasadnione, ponieważ użytkownik musi mieć również zainstalowany Streamlit w swoich systemach.
Jeśli Streamlit jest dostępny w systemie i masz łącze do pliku Pythona aplikacji Streamlit, możesz uruchomić aplikację internetową, po prostu wykonując polecenie: streamlit run url . Możesz sprawdzić moją aplikację lokalnie, jeśli zainstalowałeś Streamlit. Użyj następującego polecenia w swoich terminalach:
streamlit run https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py
Wniosek
Widziałeś, jak prosty, ale potężny jest Streamlit. Nie spotkałem się wcześniej z takim narzędziem, które pomogło mi do tego stopnia i ułatwiło mi życie rozwojowe. Dlatego uważam, że Streamlit to imponująca platforma, która może pomóc wszystkim skoncentrować się na ważnych częściach rozwoju uczenia maszynowego i pomóc nam bardziej skoncentrować się na głównych naukach dotyczących sztucznej inteligencji i ML. To sprawia, że krzywa uczenia się jest znacznie łatwiejsza i umożliwia nam łatwe tworzenie i wdrażanie projektów hobbystycznych.
Jedną z rzeczy, która sprawia, że ten framework jest tak prosty do wdrożenia, jest ich oficjalna dokumentacja. Wszystko napisane w dokumentach jest precyzyjne i proste. Proponuję, abyś raz przejrzał dokumentację i spróbował wdrożyć nowy projekt. To najlepszy sposób na rozpoczęcie pracy z nowymi frameworkami. Znajdź oficjalną dokumentację Streamlit pod następującym linkiem — https://docs.streamlit.io/en/stable/ target=”_blank” rel=”nofollow” .
Społeczność jest zawsze najlepszym źródłem wiedzy i znajdowania problemów dzięki naszym rozwiązaniom. Streamlit ma wspaniałe forum dyskusyjne, na którym możesz zadawać pytania dotyczące procesu rozwoju aplikacji Streamlit, wszelkich wątpliwości dotyczących wdrażania, próśb o funkcje, raportów o błędach i wszystkiego, co może pomóc w pomyślnym zbudowaniu aplikacji. Dołącz do forum dyskusyjnego pod następującym linkiem — https://discuss.streamlit.io/
Jeśli chcesz dowiedzieć się więcej o uczeniu maszynowym, sprawdź dyplom PG IIIT-B i upGrad w uczeniu maszynowym i sztucznej inteligencji, który jest przeznaczony dla pracujących profesjonalistów i oferuje ponad 450 godzin rygorystycznego szkolenia, ponad 30 studiów przypadków i zadań, IIIT- Status absolwenta B, ponad 5 praktycznych, praktycznych projektów zwieńczenia i pomoc w pracy z najlepszymi firmami.
Jaka jest największa trudność we wdrożeniu projektu uczenia maszynowego?
Największą trudnością we wdrożeniu projektu uczenia maszynowego jest niekompletność gromadzenia danych. W większości przypadków czas i pieniądze nie wystarczą, aby zebrać wszystkie dane potrzebne do dokładnej analizy. Dlatego gromadzone dane muszą być rzetelne i dobrej jakości. Dodatkowo należy wybrać odpowiednie dane. Wybór danych jest kluczem do wdrożenia projektu.
Czym jest Streamlit w uczeniu maszynowym?
Streamlit to przyrostowy algorytm uczenia maszynowego. Wykorzystuje fakt, że przestrzeń przeszukiwania sieci neuronowych jest bardzo duża, a szkolenie jest szybkie, a zatem nie musi przeszukiwać całej przestrzeni, ale może lokalnie budować sieć neuronową. StreamLit to forma pamięci długoterminowej krótkotrwałej służącej do przetwarzania danych sekwencyjnych. Jest to algorytm głębokiego uczenia, który wykorzystuje RNN do kodowania danych na wektory liczb. Te wektory mogą służyć do przedstawiania danych na wykresach lub w tekście. Może być również używany do generowania tekstu w języku naturalnym.
Jak wdrożyć za pomocą Streamlit?
Wdrażanie za pomocą Streamlit jest proste. Najpierw musisz mieć konto Streamlit. Po drugie, potrzebujesz oprogramowania, które można wdrożyć. Na przykład Beanstalk, S3 lub rsync. Po trzecie, musisz przygotować oprogramowanie do wdrożenia. Skopiuj swoją aplikację na serwer WWW za pomocą rsync. Jeśli wdrażasz nową witrynę internetową, to witryna internetowa jest skopiowanym katalogiem. Jeśli wdrażasz istniejącą witrynę internetową, przesłana witryna internetowa jest skopiowanym katalogiem. Po lewej stronie ekranu pod